diff --git a/src/main/java/com/frentix/olat/course/nodes/ViteroCourseNode.java b/src/main/java/com/frentix/olat/course/nodes/ViteroCourseNode.java
new file mode 100644
index 0000000000000000000000000000000000000000..2c1f44cd25a2da7fade1cfbf991a96f2a163bf78
--- /dev/null
+++ b/src/main/java/com/frentix/olat/course/nodes/ViteroCourseNode.java
@@ -0,0 +1,165 @@
+/**
+ * OLAT - Online Learning and Training<br>
+ * http://www.olat.org
+ * <p>
+ * Licensed under the Apache License, Version 2.0 (the "License"); <br>
+ * you may not use this file except in compliance with the License.<br>
+ * You may obtain a copy of the License at
+ * <p>
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * <p>
+ * Unless required by applicable law or agreed to in writing,<br>
+ * software distributed under the License is distributed on an "AS IS" BASIS, <br>
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. <br>
+ * See the License for the specific language governing permissions and <br>
+ * limitations under the License.
+ * <p>
+ * Copyright (c) frentix GmbH<br>
+ * http://www.frentix.com<br>
+ * <p>
+ */
+package com.frentix.olat.course.nodes;
+
+import java.util.List;
+
+import org.olat.core.CoreSpringFactory;
+import org.olat.core.gui.UserRequest;
+import org.olat.core.gui.control.Controller;
+import org.olat.core.gui.control.WindowControl;
+import org.olat.core.gui.control.generic.tabbable.TabbableController;
+import org.olat.core.id.OLATResourceable;
+import org.olat.core.id.Roles;
+import org.olat.core.util.Util;
+import org.olat.core.util.resource.OresHelper;
+import org.olat.course.CourseFactory;
+import org.olat.course.CourseModule;
+import org.olat.course.ICourse;
+import org.olat.course.condition.ConditionEditController;
+import org.olat.course.editor.CourseEditorEnv;
+import org.olat.course.editor.NodeEditController;
+import org.olat.course.editor.StatusDescription;
+import org.olat.course.nodes.AbstractAccessableCourseNode;
+import org.olat.course.nodes.CourseNode;
+import org.olat.course.nodes.StatusDescriptionHelper;
+import org.olat.course.nodes.TitledWrapperHelper;
+import org.olat.course.run.navigation.NodeRunConstructionResult;
+import org.olat.course.run.userview.NodeEvaluation;
+import org.olat.course.run.userview.UserCourseEnvironment;
+import org.olat.repository.RepositoryEntry;
+import org.olat.repository.RepositoryManager;
+
+import com.frentix.olat.course.nodes.vitero.ViteroEditController;
+import com.frentix.olat.course.nodes.vitero.ViteroPeekViewController;
+import com.frentix.olat.vitero.manager.ViteroManager;
+import com.frentix.olat.vitero.ui.ViteroBookingsRunController;
+
+/**
+ *
+ * Description:<br>
+ *
+ * <P>
+ * Initial Date: 6 oct. 2011 <br>
+ *
+ * @author srosse, stephane.rosse@frentix.com, http://www.frentix.com
+ */
+public class ViteroCourseNode extends AbstractAccessableCourseNode {
+
+ private static final long serialVersionUID = 8680935159748506305L;
+
+ private static final String TYPE = "vitero";
+
+ // configuration
+ public static final String CONF_VC_CONFIGURATION = "vc_configuration";
+
+ public ViteroCourseNode() {
+ super(TYPE);
+ }
+
+ @Override
+ public void updateModuleConfigDefaults(boolean isNewNode) {
+ // no update to default config necessary
+ }
+
+ @Override
+ public TabbableController createEditController(UserRequest ureq, WindowControl wControl, ICourse course,
+ UserCourseEnvironment userCourseEnv) {
+ updateModuleConfigDefaults(false);
+ CourseNode chosenNode = course.getEditorTreeModel().getCourseNode(userCourseEnv.getCourseEditorEnv().getCurrentCourseNodeId());
+ // create edit controller
+ ViteroEditController childTabCntrllr = new ViteroEditController(ureq, wControl, this, course, userCourseEnv);
+
+ NodeEditController nodeEditCtr = new NodeEditController(ureq, wControl, course.getEditorTreeModel(), course, chosenNode,
+ course.getCourseEnvironment().getCourseGroupManager(), userCourseEnv, childTabCntrllr);
+ nodeEditCtr.addControllerListener(childTabCntrllr);
+ return nodeEditCtr;
+ }
+
+ @Override
+ public NodeRunConstructionResult createNodeRunConstructionResult(UserRequest ureq, WindowControl wControl,
+ UserCourseEnvironment userCourseEnv, NodeEvaluation ne, String nodecmd) {
+ updateModuleConfigDefaults(false);
+ // check if user is moderator of the virtual classroom
+ Roles roles = ureq.getUserSession().getRoles();
+ boolean moderator = roles.isOLATAdmin();
+ Long key = userCourseEnv.getCourseEnvironment().getCourseResourceableId();
+ if (!moderator) {
+ if(roles.isInstitutionalResourceManager() | roles.isAuthor()) {
+ RepositoryManager rm = RepositoryManager.getInstance();
+ ICourse course = CourseFactory.loadCourse(key);
+ RepositoryEntry re = rm.lookupRepositoryEntry(course, false);
+ if (re != null) {
+ moderator = rm.isOwnerOfRepositoryEntry(ureq.getIdentity(), re);
+ if(!moderator) {
+ moderator = rm.isInstitutionalRessourceManagerFor(re, ureq.getIdentity());
+ }
+ }
+ }
+ }
+ // create run controller
+
+ Long resourceId = userCourseEnv.getCourseEnvironment().getCourseResourceableId();
+ OLATResourceable ores = OresHelper.createOLATResourceableInstance(CourseModule.class, resourceId);
+ String courseTitle = userCourseEnv.getCourseEnvironment().getCourseTitle();
+ Controller runCtr = new ViteroBookingsRunController(ureq, wControl, null, ores, courseTitle, moderator);
+ Controller controller = TitledWrapperHelper.getWrapper(ureq, wControl, runCtr, this, "o_vc_icon");
+ return new NodeRunConstructionResult(controller);
+ }
+
+ @Override
+ public Controller createPeekViewRunController(UserRequest ureq, WindowControl wControl, UserCourseEnvironment userCourseEnv, NodeEvaluation ne) {
+ return new ViteroPeekViewController(ureq, wControl, userCourseEnv);
+ }
+
+ @Override
+ public StatusDescription[] isConfigValid(CourseEditorEnv cev) {
+ String translatorStr = Util.getPackageName(ConditionEditController.class);
+ List<StatusDescription> statusDescs = isConfigValidWithTranslator(cev, translatorStr, getConditionExpressions());
+ return StatusDescriptionHelper.sort(statusDescs);
+ }
+
+ @Override
+ public RepositoryEntry getReferencedRepositoryEntry() {
+ return null;
+ }
+
+ @Override
+ public StatusDescription isConfigValid() {
+ if (oneClickStatusCache != null) { return oneClickStatusCache[0]; }
+ StatusDescription status = StatusDescription.NOERROR;
+ return status;
+ }
+
+ @Override
+ public boolean needsReferenceToARepositoryEntry() {
+ return false;
+ }
+
+ @Override
+ public void cleanupOnDelete(ICourse course) {
+ // load configuration
+ ViteroManager provider = (ViteroManager)CoreSpringFactory.getBean("viteroManager");
+ // remove meeting
+ OLATResourceable ores = OresHelper.createOLATResourceableInstance(course.getResourceableTypeName(), course.getResourceableId());
+ provider.deleteAll(null, ores);
+ }
+}
\ No newline at end of file
diff --git a/src/main/java/com/frentix/olat/course/nodes/vitero/ViteroCourseNodeConfiguration.java b/src/main/java/com/frentix/olat/course/nodes/vitero/ViteroCourseNodeConfiguration.java
new file mode 100644
index 0000000000000000000000000000000000000000..63b92e304d5681fb4bc218a93ce973a18e993cd7
--- /dev/null
+++ b/src/main/java/com/frentix/olat/course/nodes/vitero/ViteroCourseNodeConfiguration.java
@@ -0,0 +1,74 @@
+/**
+ * OLAT - Online Learning and Training<br>
+ * http://www.olat.org
+ * <p>
+ * Licensed under the Apache License, Version 2.0 (the "License"); <br>
+ * you may not use this file except in compliance with the License.<br>
+ * You may obtain a copy of the License at
+ * <p>
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * <p>
+ * Unless required by applicable law or agreed to in writing,<br>
+ * software distributed under the License is distributed on an "AS IS" BASIS, <br>
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. <br>
+ * See the License for the specific language governing permissions and <br>
+ * limitations under the License.
+ * <p>
+ * Copyright (c) frentix GmbH<br>
+ * http://www.frentix.com<br>
+ * <p>
+ */
+package com.frentix.olat.course.nodes.vitero;
+
+import java.util.Locale;
+
+import org.olat.core.gui.translator.Translator;
+import org.olat.core.util.Util;
+import org.olat.course.nodes.AbstractCourseNodeConfiguration;
+import org.olat.course.nodes.CourseNode;
+import org.olat.course.nodes.CourseNodeConfiguration;
+
+import com.frentix.olat.course.nodes.ViteroCourseNode;
+
+/**
+ *
+ * Description:<br>
+ *
+ * <P>
+ * Initial Date: 6 oct. 2011 <br>
+ *
+ * @author srosse, stephane.rosse@frentix.com, http://www.frentix.com
+ */
+public class ViteroCourseNodeConfiguration extends AbstractCourseNodeConfiguration implements CourseNodeConfiguration {
+
+ public String getAlias() {
+ return "vitero";
+ }
+
+ public String getIconCSSClass() {
+ return "o_vitero_icon";
+ }
+
+ public CourseNode getInstance() {
+ return new ViteroCourseNode();
+ }
+
+ public String getLinkCSSClass() {
+ return "o_vitero_icon";
+ }
+
+ public String getLinkText(Locale locale) {
+ Translator fallback = Util.createPackageTranslator(CourseNodeConfiguration.class, locale);
+ Translator translator = Util.createPackageTranslator(this.getClass(), locale, fallback);
+ return translator.translate("title_vc");
+ }
+
+ @Override
+ public boolean isEnabled() {
+ return super.isEnabled();
+ }
+
+ public String getName() {
+ return getAlias();
+ }
+}
\ No newline at end of file
diff --git a/src/main/java/com/frentix/olat/course/nodes/vitero/ViteroEditController.java b/src/main/java/com/frentix/olat/course/nodes/vitero/ViteroEditController.java
new file mode 100644
index 0000000000000000000000000000000000000000..a490a715810d7c4adec46bcd70175b9e1f6cfecf
--- /dev/null
+++ b/src/main/java/com/frentix/olat/course/nodes/vitero/ViteroEditController.java
@@ -0,0 +1,128 @@
+/**
+ * OLAT - Online Learning and Training<br>
+ * http://www.olat.org
+ * <p>
+ * Licensed under the Apache License, Version 2.0 (the "License"); <br>
+ * you may not use this file except in compliance with the License.<br>
+ * You may obtain a copy of the License at
+ * <p>
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * <p>
+ * Unless required by applicable law or agreed to in writing,<br>
+ * software distributed under the License is distributed on an "AS IS" BASIS, <br>
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. <br>
+ * See the License for the specific language governing permissions and <br>
+ * limitations under the License.
+ * <p>
+ * Copyright (c) frentix GmbH<br>
+ * http://www.frentix.com<br>
+ * <p>
+ */
+package com.frentix.olat.course.nodes.vitero;
+
+import org.olat.core.gui.UserRequest;
+import org.olat.core.gui.components.Component;
+import org.olat.core.gui.components.tabbedpane.TabbedPane;
+import org.olat.core.gui.components.velocity.VelocityContainer;
+import org.olat.core.gui.control.Controller;
+import org.olat.core.gui.control.ControllerEventListener;
+import org.olat.core.gui.control.Event;
+import org.olat.core.gui.control.WindowControl;
+import org.olat.core.gui.control.generic.tabbable.ActivateableTabbableDefaultController;
+import org.olat.core.id.OLATResourceable;
+import org.olat.core.util.resource.OresHelper;
+import org.olat.course.ICourse;
+import org.olat.course.assessment.AssessmentHelper;
+import org.olat.course.condition.Condition;
+import org.olat.course.condition.ConditionEditController;
+import org.olat.course.editor.NodeEditController;
+import org.olat.course.run.userview.UserCourseEnvironment;
+
+import com.frentix.olat.course.nodes.ViteroCourseNode;
+import com.frentix.olat.vitero.ui.ViteroBookingsEditController;
+
+/**
+ *
+ * Description:<br>
+ *
+ * <P>
+ * Initial Date: 6 oct. 2011 <br>
+ *
+ * @author srosse, stephane.rosse@frentix.com, http://www.frentix.com
+ */
+public class ViteroEditController extends ActivateableTabbableDefaultController implements ControllerEventListener {
+
+ private static final String PANE_TAB_ACCESSIBILITY = "pane.tab.accessibility";
+ public static final String PANE_TAB_VCCONFIG = "pane.tab.vcconfig";
+ final static String[] paneKeys = { PANE_TAB_VCCONFIG, PANE_TAB_ACCESSIBILITY };
+
+ private VelocityContainer editVc;
+ private ConditionEditController accessibilityCondContr;
+ private TabbedPane tabPane;
+ private ViteroBookingsEditController editForm;
+
+ private final ViteroCourseNode courseNode;
+
+ public ViteroEditController(UserRequest ureq, WindowControl wControl, ViteroCourseNode courseNode,
+ ICourse course, UserCourseEnvironment userCourseEnv) {
+ super(ureq, wControl);
+ this.courseNode = courseNode;
+
+
+ Condition accessCondition = courseNode.getPreConditionAccess();
+ accessibilityCondContr = new ConditionEditController(ureq, wControl, course.getCourseEnvironment().getCourseGroupManager(),
+ accessCondition, "accessabilityConditionForm", AssessmentHelper.getAssessableNodes(course.getEditorTreeModel(), courseNode),
+ userCourseEnv);
+ listenTo(accessibilityCondContr);
+
+ OLATResourceable ores = OresHelper.createOLATResourceableInstance(course.getResourceableTypeName(), course.getResourceableId());
+ editForm = new ViteroBookingsEditController(ureq, wControl, null, ores, course.getCourseTitle());
+ listenTo(editForm);
+
+ editVc = createVelocityContainer("edit");
+ editVc.put("editRooms", editForm.getInitialComponent());
+ }
+
+ @Override
+ public String[] getPaneKeys() {
+ return paneKeys;
+ }
+
+ @Override
+ public TabbedPane getTabbedPane() {
+ return tabPane;
+ }
+
+ @Override
+ protected void doDispose() {
+ if(editForm != null) {
+ removeAsListenerAndDispose(editForm);
+ editForm = null;
+ }
+ }
+
+ @Override
+ protected void event(UserRequest ureq, Component source, Event event) {
+ // nothing to do
+ }
+
+ @Override
+ protected void event(UserRequest ureq, Controller source, Event event) {
+ if (source == accessibilityCondContr) {
+ if (event == Event.CHANGED_EVENT) {
+ Condition cond = accessibilityCondContr.getCondition();
+ courseNode.setPreConditionAccess(cond);
+ fireEvent(ureq, NodeEditController.NODECONFIG_CHANGED_EVENT);
+ }
+ } else if (source == editForm) {
+ //nothing to do
+ }
+ }
+
+ public void addTabs(TabbedPane tabbedPane) {
+ tabPane = tabbedPane;
+ tabbedPane.addTab(translate(PANE_TAB_ACCESSIBILITY),
+ accessibilityCondContr.getWrappedDefaultAccessConditionVC(translate("condition.accessibility.title")));
+ tabbedPane.addTab(translate(PANE_TAB_VCCONFIG), editVc);
+ }
+}
\ No newline at end of file
diff --git a/src/main/java/com/frentix/olat/course/nodes/vitero/ViteroPeekViewController.java b/src/main/java/com/frentix/olat/course/nodes/vitero/ViteroPeekViewController.java
new file mode 100644
index 0000000000000000000000000000000000000000..050b59ee0077a0c239502d6704b900e0f4f2c1f0
--- /dev/null
+++ b/src/main/java/com/frentix/olat/course/nodes/vitero/ViteroPeekViewController.java
@@ -0,0 +1,106 @@
+/**
+ * OLAT - Online Learning and Training<br>
+ * http://www.olat.org
+ * <p>
+ * Licensed under the Apache License, Version 2.0 (the "License"); <br>
+ * you may not use this file except in compliance with the License.<br>
+ * You may obtain a copy of the License at
+ * <p>
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * <p>
+ * Unless required by applicable law or agreed to in writing,<br>
+ * software distributed under the License is distributed on an "AS IS" BASIS, <br>
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. <br>
+ * See the License for the specific language governing permissions and <br>
+ * limitations under the License.
+ * <p>
+ * Copyright (c) frentix GmbH<br>
+ * http://www.frentix.com<br>
+ * <p>
+ */
+package com.frentix.olat.course.nodes.vitero;
+
+import java.util.Collections;
+import java.util.List;
+
+import org.olat.core.CoreSpringFactory;
+import org.olat.core.gui.UserRequest;
+import org.olat.core.gui.components.Component;
+import org.olat.core.gui.components.table.DefaultColumnDescriptor;
+import org.olat.core.gui.components.table.TableController;
+import org.olat.core.gui.components.table.TableGuiConfiguration;
+import org.olat.core.gui.control.Event;
+import org.olat.core.gui.control.WindowControl;
+import org.olat.core.gui.control.controller.BasicController;
+import org.olat.core.id.OLATResourceable;
+import org.olat.core.util.resource.OresHelper;
+import org.olat.course.CourseModule;
+import org.olat.course.run.userview.UserCourseEnvironment;
+
+import com.frentix.olat.vitero.manager.ViteroManager;
+import com.frentix.olat.vitero.manager.VmsNotAvailableException;
+import com.frentix.olat.vitero.model.StartBookingComparator;
+import com.frentix.olat.vitero.model.ViteroBooking;
+import com.frentix.olat.vitero.ui.FilterBookings;
+import com.frentix.olat.vitero.ui.ViteroBookingDataModel;
+
+/**
+ *
+ * Description:<br>
+ *
+ * <P>
+ * Initial Date: 11 oct. 2011 <br>
+ *
+ * @author srosse, stephane.rosse@frentix.com, http://www.frentix.com
+ */
+public class ViteroPeekViewController extends BasicController {
+
+
+ public ViteroPeekViewController(UserRequest ureq, WindowControl wControl, UserCourseEnvironment userCourseEnv) {
+ super(ureq, wControl);
+
+ ViteroManager viteroManager = (ViteroManager)CoreSpringFactory.getBean("viteroManager");
+ OLATResourceable ores = OresHelper.createOLATResourceableInstance(CourseModule.class,
+ userCourseEnv.getCourseEnvironment().getCourseResourceableId());
+
+ List<ViteroBooking> bookings;
+ try {
+ bookings = viteroManager.getBookings(null, ores);
+ List<ViteroBooking> myBookings = viteroManager.getBookingInFutures(getIdentity());
+ FilterBookings.filterMyFutureBookings(bookings, myBookings);
+ Collections.sort(bookings, new StartBookingComparator());
+ } catch (VmsNotAvailableException e) {
+ bookings = Collections.emptyList();
+ showError(VmsNotAvailableException.I18N_KEY);
+ }
+
+ TableGuiConfiguration tableConfig = new TableGuiConfiguration();
+ tableConfig.setTableEmptyMessage(translate("table.empty"));
+ tableConfig.setDisplayTableHeader(false);
+ tableConfig.setCustomCssClass("b_portlet_table");
+ tableConfig.setDisplayRowCount(false);
+ tableConfig.setPageingEnabled(false);
+ tableConfig.setDownloadOffered(false);
+ tableConfig.setSortingEnabled(false);
+
+ TableController tableCtrl = new TableController(tableConfig, ureq, getWindowControl(), getTranslator());
+ listenTo(tableCtrl);
+
+ // dummy header key, won't be used since setDisplayTableHeader is set to false
+ tableCtrl.addColumnDescriptor(new DefaultColumnDescriptor("vc.table.begin", ViteroBookingDataModel.Column.begin.ordinal(), null, ureq.getLocale()));
+ tableCtrl.addColumnDescriptor(new DefaultColumnDescriptor("vc.table.end", ViteroBookingDataModel.Column.end.ordinal(), null, ureq.getLocale()));
+ tableCtrl.setTableDataModel(new ViteroBookingDataModel(bookings));
+
+ putInitialPanel(tableCtrl.getInitialComponent());
+ }
+
+ @Override
+ protected void doDispose() {
+ //
+ }
+
+ @Override
+ protected void event(UserRequest ureq, Component source, Event event) {
+ //
+ }
+}
diff --git a/src/main/java/com/frentix/olat/course/nodes/vitero/ViteroRunController.java b/src/main/java/com/frentix/olat/course/nodes/vitero/ViteroRunController.java
new file mode 100644
index 0000000000000000000000000000000000000000..24b7970866c6e847e235f6bb50e4afac60f2d17e
--- /dev/null
+++ b/src/main/java/com/frentix/olat/course/nodes/vitero/ViteroRunController.java
@@ -0,0 +1,63 @@
+/**
+ * OLAT - Online Learning and Training<br>
+ * http://www.olat.org
+ * <p>
+ * Licensed under the Apache License, Version 2.0 (the "License"); <br>
+ * you may not use this file except in compliance with the License.<br>
+ * You may obtain a copy of the License at
+ * <p>
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * <p>
+ * Unless required by applicable law or agreed to in writing,<br>
+ * software distributed under the License is distributed on an "AS IS" BASIS, <br>
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. <br>
+ * See the License for the specific language governing permissions and <br>
+ * limitations under the License.
+ * <p>
+ * Copyright (c) frentix GmbH<br>
+ * http://www.frentix.com<br>
+ * <p>
+ */
+package com.frentix.olat.course.nodes.vitero;
+
+import org.olat.core.gui.UserRequest;
+import org.olat.core.gui.components.Component;
+import org.olat.core.gui.control.Event;
+import org.olat.core.gui.control.WindowControl;
+import org.olat.core.gui.control.controller.BasicController;
+import org.olat.core.id.OLATResourceable;
+
+import com.frentix.olat.vitero.ui.ViteroBookingsRunController;
+
+/**
+ *
+ * Description:<br>
+ *
+ * <P>
+ * Initial Date: 6 oct. 2011 <br>
+ *
+ * @author srosse, stephane.rosse@frentix.com, http://www.frentix.com
+ */
+public class ViteroRunController extends BasicController {
+
+ private final ViteroBookingsRunController bookingsController;
+
+ public ViteroRunController(UserRequest ureq, WindowControl wControl, OLATResourceable ores) {
+ super(ureq, wControl);
+
+ bookingsController = new ViteroBookingsRunController(ureq, wControl, null, ores, "Test", false);
+ listenTo(bookingsController);
+
+ putInitialPanel(bookingsController.getInitialComponent());
+ }
+
+ @Override
+ protected void event(UserRequest ureq, Component source, Event event) {
+ // nothing to do
+ }
+
+ @Override
+ protected void doDispose() {
+ // nothing to do
+ }
+}
\ No newline at end of file
diff --git a/src/main/java/com/frentix/olat/course/nodes/vitero/_content/edit.html b/src/main/java/com/frentix/olat/course/nodes/vitero/_content/edit.html
new file mode 100644
index 0000000000000000000000000000000000000000..b6db8fce606d9dc183fced1f8352ab0f805ff802
--- /dev/null
+++ b/src/main/java/com/frentix/olat/course/nodes/vitero/_content/edit.html
@@ -0,0 +1,2 @@
+
+$r.render('editRooms')
diff --git a/src/main/java/com/frentix/olat/course/nodes/vitero/_content/run.html b/src/main/java/com/frentix/olat/course/nodes/vitero/_content/run.html
new file mode 100644
index 0000000000000000000000000000000000000000..445a34418c4b3ab38a9f51a89cb10b49f23ae2a5
--- /dev/null
+++ b/src/main/java/com/frentix/olat/course/nodes/vitero/_content/run.html
@@ -0,0 +1 @@
+Hello world (by Vitero)
\ No newline at end of file
diff --git a/src/main/java/com/frentix/olat/course/nodes/vitero/_i18n/LocalStrings_de.properties b/src/main/java/com/frentix/olat/course/nodes/vitero/_i18n/LocalStrings_de.properties
new file mode 100644
index 0000000000000000000000000000000000000000..55f7a60f4065e82be6df3a8fab79bce4030cf618
--- /dev/null
+++ b/src/main/java/com/frentix/olat/course/nodes/vitero/_i18n/LocalStrings_de.properties
@@ -0,0 +1,6 @@
+error.vmsNotAvailable=$com.frentix.olat.vitero.ui\:verror.vmsNotAvailable
+table.empty=$com.frentix.olat.vitero.ui\:table.empty
+pane.tab.accessibility=Zugang
+pane.tab.vcconfig=Konfiguration
+condition.accessibility.title=Zugang
+title_vc=vitero
\ No newline at end of file
diff --git a/src/main/java/com/frentix/olat/course/nodes/vitero/_i18n/LocalStrings_en.properties b/src/main/java/com/frentix/olat/course/nodes/vitero/_i18n/LocalStrings_en.properties
new file mode 100644
index 0000000000000000000000000000000000000000..ee53d0c72ce401f9def3bbdb8e4e0c4f21d327f1
--- /dev/null
+++ b/src/main/java/com/frentix/olat/course/nodes/vitero/_i18n/LocalStrings_en.properties
@@ -0,0 +1,6 @@
+error.vmsNotAvailable=$com.frentix.olat.vitero.ui\:verror.vmsNotAvailable
+table.empty=$com.frentix.olat.vitero.ui\:table.empty
+pane.tab.accessibility=Access
+pane.tab.vcconfig=Configuration
+condition.accessibility.title=Access
+title_vc=vitero
\ No newline at end of file
diff --git a/src/main/java/com/frentix/olat/course/nodes/vitero/_spring/buildingblockContext.xml b/src/main/java/com/frentix/olat/course/nodes/vitero/_spring/buildingblockContext.xml
new file mode 100644
index 0000000000000000000000000000000000000000..4f6e38432bda7123faea40328350f3500d33a293
--- /dev/null
+++ b/src/main/java/com/frentix/olat/course/nodes/vitero/_spring/buildingblockContext.xml
@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<beans xmlns="http://www.springframework.org/schema/beans"
+ xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+ xmlns:context="http://www.springframework.org/schema/context"
+ xsi:schemaLocation="
+ http://www.springframework.org/schema/beans
+ http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
+
+ <bean id="vitero" class="com.frentix.olat.course.nodes.vitero.ViteroCourseNodeConfiguration" scope="prototype">
+ <property name="enabled" value="${course.node.vitero.enabled}" />
+ <property name="order" value="301" />
+ </bean>
+
+</beans>
\ No newline at end of file
diff --git a/src/main/java/com/frentix/olat/vitero/ViteroModule.java b/src/main/java/com/frentix/olat/vitero/ViteroModule.java
new file mode 100644
index 0000000000000000000000000000000000000000..9a6cd8d04932805825b68f95fc4f9dc341bc3235
--- /dev/null
+++ b/src/main/java/com/frentix/olat/vitero/ViteroModule.java
@@ -0,0 +1,294 @@
+/**
+ * OLAT - Online Learning and Training<br>
+ * http://www.olat.org
+ * <p>
+ * Licensed under the Apache License, Version 2.0 (the "License"); <br>
+ * you may not use this file except in compliance with the License.<br>
+ * You may obtain a copy of the License at
+ * <p>
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * <p>
+ * Unless required by applicable law or agreed to in writing,<br>
+ * software distributed under the License is distributed on an "AS IS" BASIS, <br>
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. <br>
+ * See the License for the specific language governing permissions and <br>
+ * limitations under the License.
+ * <p>
+ * Copyright (c) frentix GmbH<br>
+ * http://www.frentix.com<br>
+ * <p>
+ */
+package com.frentix.olat.vitero;
+
+import java.net.URI;
+import java.text.ParseException;
+
+import javax.ws.rs.core.UriBuilder;
+
+import org.olat.core.configuration.AbstractOLATModule;
+import org.olat.core.configuration.ConfigOnOff;
+import org.olat.core.configuration.PersistedProperties;
+import org.olat.core.util.StringHelper;
+import org.quartz.CronTrigger;
+import org.quartz.JobDetail;
+import org.quartz.Scheduler;
+import org.quartz.SchedulerException;
+
+import com.frentix.olat.vitero.manager.ViteroZombieSlayerJob;
+import com.ibm.icu.util.Calendar;
+
+/**
+ *
+ * Description:<br>
+ *
+ * <P>
+ * Initial Date: 6 oct. 2011 <br>
+ *
+ * @author srosse, stephane.rosse@frentix.com, http://www.frentix.com
+ */
+public class ViteroModule extends AbstractOLATModule implements ConfigOnOff {
+
+ private static final String ENABLED = "vc.vitero.enabled";
+ private static final String PROTOCOL = "protocol";
+ private static final String PORT = "port";
+ private static final String BASE_URL = "baseUrl";
+ private static final String CONTEXT_PATH = "contextPath";
+ private static final String ADMIN_LOGIN = "adminLogin";
+ private static final String ADMIN_PASSWORD = "adminPassword";
+ private static final String CUSTOMER_ID = "customerId";
+ private static final String OLAT_TIMEZONE_ID = "olatTimeZoneId";
+
+ private boolean enabled;
+ private String displayName;
+ private String protocol;
+ private int port;
+ private String baseUrl;
+ private String contextPath;
+ private String adminLogin;
+ private String adminPassword;
+ private int customerId;
+ private String olatTimeZoneId;
+
+ private String cronExpression;
+ private final Scheduler scheduler;
+ private boolean deleteVmsUserOnUserDelete;
+
+ public ViteroModule(Scheduler scheduler) {
+ this.scheduler = scheduler;
+ }
+
+ @Override
+ public void init() {
+ String enabledObj = getStringPropertyValue(ENABLED, true);
+ if(StringHelper.containsNonWhitespace(enabledObj)) {
+ enabled = "true".equals(enabledObj);
+ }
+
+ String protocolObj = getStringPropertyValue(PROTOCOL, true);
+ if(StringHelper.containsNonWhitespace(protocolObj)) {
+ protocol = protocolObj;
+ }
+ String portObj = getStringPropertyValue(PORT, true);
+ if(StringHelper.containsNonWhitespace(portObj)) {
+ port = Integer.parseInt(portObj);
+ }
+ String baseUrlObj = getStringPropertyValue(BASE_URL, true);
+ if(StringHelper.containsNonWhitespace(baseUrlObj)) {
+ baseUrl = baseUrlObj;
+ }
+ String contextPathObj = getStringPropertyValue(CONTEXT_PATH, true);
+ if(StringHelper.containsNonWhitespace(contextPathObj)) {
+ contextPath = contextPathObj;
+ }
+ String adminLoginObj = getStringPropertyValue(ADMIN_LOGIN, true);
+ if(StringHelper.containsNonWhitespace(adminLoginObj)) {
+ adminLogin = adminLoginObj;
+ }
+ String adminPasswordObj = getStringPropertyValue(ADMIN_PASSWORD, true);
+ if(StringHelper.containsNonWhitespace(adminPasswordObj)) {
+ adminPassword = adminPasswordObj;
+ }
+ String customerIdObj = getStringPropertyValue(CUSTOMER_ID, true);
+ if(StringHelper.containsNonWhitespace(customerIdObj)) {
+ customerId = Integer.parseInt(customerIdObj);
+ }
+ String olatTimeZoneIdObj = getStringPropertyValue(OLAT_TIMEZONE_ID, true);
+ if(StringHelper.containsNonWhitespace(olatTimeZoneIdObj)) {
+ olatTimeZoneId = olatTimeZoneIdObj;
+ }
+
+ initCronJob();
+ }
+
+ @Override
+ protected void initDefaultProperties() {
+ enabled = getBooleanConfigParameter(ENABLED, true);
+ protocol = getStringConfigParameter(PROTOCOL, "http", false);
+ port = getIntConfigParameter(PORT, 8080);
+ baseUrl = getStringConfigParameter(BASE_URL, "localhost", false);
+ contextPath = getStringConfigParameter(CONTEXT_PATH, "vitero", false);
+ adminLogin = getStringConfigParameter(ADMIN_LOGIN, "admin", false);
+ adminPassword = getStringConfigParameter(ADMIN_PASSWORD, "007", false);
+ customerId = Integer.parseInt(getStringConfigParameter(CUSTOMER_ID, "1", false));
+ olatTimeZoneId = getStringConfigParameter(OLAT_TIMEZONE_ID, "Africa/Ceuta", false);
+ }
+
+ @Override
+ protected void initFromChangedProperties() {
+ init();
+ }
+
+ private void initCronJob() {
+ try {
+ if(scheduler.getTrigger("Vitero_Cleaner_Cron_Job", Scheduler.DEFAULT_GROUP) == null) {
+ JobDetail jobDetail = new JobDetail("Vitero_Cleaner_Cron_Job", Scheduler.DEFAULT_GROUP, ViteroZombieSlayerJob.class);
+ CronTrigger trigger = new CronTrigger();
+
+ Calendar cal = Calendar.getInstance();
+ cal.add(Calendar.SECOND, 30);
+ trigger.setStartTime(cal.getTime());
+ trigger.setName("Vitero_Cleaner_Cron_Trigger");
+ trigger.setCronExpression(cronExpression);
+ scheduler.scheduleJob(jobDetail, trigger);
+ }
+ } catch (ParseException e) {
+ logError("Cannot start the Quartz Job which clean the Vitero rooms", e);
+ } catch (SchedulerException e) {
+ logError("Cannot start the Quartz Job which clean the Vitero rooms", e);
+ }
+ }
+
+ @Override
+ public void setPersistedProperties(PersistedProperties persistedProperties) {
+ this.moduleConfigProperties = persistedProperties;
+ }
+
+ public boolean isDeleteVmsUserOnUserDelete() {
+ return deleteVmsUserOnUserDelete;
+ }
+
+ /**
+ * [user by String]
+ * @param cronExpression
+ */
+ public void setCronExpression(String cronExpression) {
+ this.cronExpression = cronExpression;
+ }
+
+ /**
+ * [user by Spring]
+ * @param deleteVmsUserOnUserDelete
+ */
+ public void setDeleteVmsUserOnUserDelete(boolean deleteVmsUserOnUserDelete) {
+ this.deleteVmsUserOnUserDelete = deleteVmsUserOnUserDelete;
+ }
+
+ public URI getVmsURI() {
+ UriBuilder builder = UriBuilder.fromUri(getProtocol() + "://" + getBaseUrl());
+ if(getPort() > 0) {
+ builder = builder.port(getPort());
+ }
+ if(StringHelper.containsNonWhitespace(getContextPath())) {
+ builder = builder.path(getContextPath());
+ }
+ return builder.build();
+ }
+
+ public void setVmsURI(URI uri) {
+ String host = uri.getHost();
+ setBaseUrl(host);
+ int port = uri.getPort();
+ setPort(port);
+ String path = uri.getPath();
+ if(StringHelper.containsNonWhitespace(path) && path.startsWith("/")) {
+ path = path.substring(1, path.length());
+ }
+ setContextPath(path);
+ String scheme = uri.getScheme();
+ setProtocol(scheme);
+ }
+
+ public boolean isEnabled() {
+ return enabled;
+ }
+
+ public void setEnabled(boolean enabled) {
+ setBooleanProperty(ENABLED, enabled, true);
+ }
+
+ /**
+ * Return the time zone of OLAT within the IDS allowed by Vitero
+ * @return
+ */
+ public String getTimeZoneId() {
+ return olatTimeZoneId;
+ }
+
+ public void setTimeZoneId(String timeZoneId) {
+ setStringProperty(OLAT_TIMEZONE_ID, timeZoneId, true);
+ }
+
+ public String getProtocol() {
+ return protocol;
+ }
+
+ public void setProtocol(String protocol) {
+ setStringProperty(PROTOCOL, protocol, true);
+ }
+
+ public int getPort() {
+ return port;
+ }
+
+ public void setPort(int port) {
+ setStringProperty(PORT, Integer.toString(port), true);
+ }
+
+ public String getBaseUrl() {
+ return baseUrl;
+ }
+
+ public void setBaseUrl(String baseUrl) {
+ setStringProperty(BASE_URL, baseUrl, true);
+ }
+
+ public String getContextPath() {
+ return contextPath;
+ }
+
+ public void setContextPath(String contextPath) {
+ setStringProperty(CONTEXT_PATH, contextPath, true);
+ }
+
+ public String getDisplayName() {
+ return displayName;
+ }
+
+ public void setDisplayName(String displayName) {
+ this.displayName = displayName;
+ }
+
+ public String getAdminLogin() {
+ return adminLogin;
+ }
+
+ public void setAdminLogin(String adminLogin) {
+ setStringProperty(ADMIN_LOGIN, adminLogin, true);
+ }
+
+ public String getAdminPassword() {
+ return adminPassword;
+ }
+
+ public void setAdminPassword(String adminPassword) {
+ setStringProperty(ADMIN_PASSWORD, adminPassword, true);
+ }
+
+ public int getCustomerId() {
+ return customerId;
+ }
+
+ public void setCustomerId(int customerId) {
+ setStringProperty(CUSTOMER_ID, Integer.toString(customerId), true);
+ }
+}
\ No newline at end of file
diff --git a/src/main/java/com/frentix/olat/vitero/ViteroTimezoneIDs.java b/src/main/java/com/frentix/olat/vitero/ViteroTimezoneIDs.java
new file mode 100644
index 0000000000000000000000000000000000000000..0039138913ff0746675abe0452121198991ea5eb
--- /dev/null
+++ b/src/main/java/com/frentix/olat/vitero/ViteroTimezoneIDs.java
@@ -0,0 +1,127 @@
+/**
+ * OLAT - Online Learning and Training<br>
+ * http://www.olat.org
+ * <p>
+ * Licensed under the Apache License, Version 2.0 (the "License"); <br>
+ * you may not use this file except in compliance with the License.<br>
+ * You may obtain a copy of the License at
+ * <p>
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * <p>
+ * Unless required by applicable law or agreed to in writing,<br>
+ * software distributed under the License is distributed on an "AS IS" BASIS, <br>
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. <br>
+ * See the License for the specific language governing permissions and <br>
+ * limitations under the License.
+ * <p>
+ * Copyright (c) frentix GmbH<br>
+ * http://www.frentix.com<br>
+ * <p>
+ */
+package com.frentix.olat.vitero;
+
+/**
+ *
+ * Description:<br>
+ * the list of Time Zone which Vitero accepts
+ *
+ * <P>
+ * Initial Date: 12 oct. 2011 <br>
+ *
+ * @author srosse, stephane.rosse@frentix.com, http://www.frentix.com
+ */
+public class ViteroTimezoneIDs {
+
+ public static final String[] TIMEZONE_IDS = {
+ "Pacific/Apia",
+ "Pacific/Fakaofo",
+ "America/Adak",
+ "Pacific/Marquesas",
+ "Pacific/Gambier",
+ "America/Anchorage",
+ "America/Ensenada",
+ "Pacific/Pitcairn",
+ "America/Dawson",
+ "America/Chihuahua",
+ "America/Boise",
+ "America/Dawson_Creek",
+ "America/Belize",
+ "Pacific/Easter",
+ "America/Chicago",
+ "America/Cancun",
+ "America/Havana",
+ "America/Detroit",
+ "America/Atikokan",
+ "America/Caracas",
+ "America/Glace_Bay",
+ "America/Campo_Grande",
+ "America/Goose_Bay",
+ "America/Anguilla",
+ "America/Asuncion",
+ "America/Santiago",
+ "Atlantic/Stanley",
+ "America/St_Johns",
+ "America/Montevideo",
+ "America/Miquelon",
+ "America/Sao_Paulo",
+ "America/Godthab",
+ "America/Argentina/Buenos_Aires",
+ "America/Araguaina",
+ "America/Noronha",
+ "Atlantic/Cape_Verde",
+ "America/Scoresbysund",
+ "Africa/Abidjan",
+ "Atlantic/Canary",
+ "Africa/Windhoek",
+ "Africa/Algiers",
+ "Africa/Ceuta",
+ "Africa/Tunis",
+ "Africa/Cairo",
+ "Asia/Amman",
+ "Asia/Gaza",
+ "Asia/Beirut",
+ "Asia/Jerusalem",
+ "Europe/Kaliningrad",
+ "Asia/Damascus",
+ "Asia/Istanbul",
+ "Africa/Blantyre",
+ "Africa/Addis_Ababa",
+ "Europe/Moscow",
+ "Asia/Riyadh87",
+ "Asia/Tehran",
+ "Asia/Dubai",
+ "Asia/Baku",
+ "Indian/Mauritius",
+ "Asia/Yerevan",
+ "Asia/Kabul",
+ "Asia/Aqtau",
+ "Asia/Yekaterinburg",
+ "Asia/Calcutta",
+ "Asia/Katmandu",
+ "Asia/Novosibirsk",
+ "Asia/Almaty",
+ "Asia/Rangoon",
+ "Asia/Bangkok",
+ "Asia/Krasnoyarsk",
+ "Asia/Brunei",
+ "Asia/Irkutsk",
+ "Australia/Eucla",
+ "Asia/Dili",
+ "Asia/Yakutsk",
+ "Australia/Darwin",
+ "Australia/Adelaide",
+ "Asia/Sakhalin",
+ "Australia/Brisbane",
+ "Australia/ACT",
+ "Australia/LHI",
+ "Pacific/Efate",
+ "Asia/Magadan",
+ "Pacific/Norfolk",
+ "Asia/Anadyr",
+ "Pacific/Fiji",
+ "Pacific/Auckland",
+ "Pacific/Chatham",
+ "Pacific/Enderbury",
+ "Pacific/Kiritimati"
+ };
+}
diff --git a/src/main/java/com/frentix/olat/vitero/ViteroUIFactory.java b/src/main/java/com/frentix/olat/vitero/ViteroUIFactory.java
new file mode 100755
index 0000000000000000000000000000000000000000..202ca522f92b138b987199af940cc0372f822f07
--- /dev/null
+++ b/src/main/java/com/frentix/olat/vitero/ViteroUIFactory.java
@@ -0,0 +1,50 @@
+/**
+ * OLAT - Online Learning and Training<br>
+ * http://www.olat.org
+ * <p>
+ * Licensed under the Apache License, Version 2.0 (the "License"); <br>
+ * you may not use this file except in compliance with the License.<br>
+ * You may obtain a copy of the License at
+ * <p>
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * <p>
+ * Unless required by applicable law or agreed to in writing,<br>
+ * software distributed under the License is distributed on an "AS IS" BASIS, <br>
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. <br>
+ * See the License for the specific language governing permissions and <br>
+ * limitations under the License.
+ * <p>
+ * Copyright (c) frentix GmbH<br>
+ * http://www.frentix.com<br>
+ * <p>
+ */
+package com.frentix.olat.vitero;
+
+import org.olat.core.gui.UserRequest;
+import org.olat.core.gui.control.Controller;
+import org.olat.core.gui.control.WindowControl;
+
+import com.frentix.olat.vitero.ui.ViteroAdminController;
+
+/**
+ *
+ * Description:<br>
+ *
+ * <P>
+ * Initial Date: 6 oct. 2011 <br>
+ *
+ * @author srosse, stephane.rosse@frentix.com, http://www.frentix.com
+ */
+public class ViteroUIFactory {
+
+ /**
+ * Get a controller for admin-setup of Vitero Integration
+ * used directly over extension-config, therefore needs to be static
+ * @param ureq
+ * @param wControl
+ * @return
+ */
+ public static Controller createViteroAdminController(UserRequest ureq, WindowControl wControl) {
+ return new ViteroAdminController(ureq, wControl);
+ }
+}
\ No newline at end of file
diff --git a/src/main/java/com/frentix/olat/vitero/_spring/viteroContext.xml b/src/main/java/com/frentix/olat/vitero/_spring/viteroContext.xml
new file mode 100644
index 0000000000000000000000000000000000000000..fda0fb3d3d5f2df5acdb2854efb5621f67ea7de2
--- /dev/null
+++ b/src/main/java/com/frentix/olat/vitero/_spring/viteroContext.xml
@@ -0,0 +1,67 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<beans xmlns="http://www.springframework.org/schema/beans"
+ xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+ xmlns:context="http://www.springframework.org/schema/context"
+ xsi:schemaLocation="
+ http://www.springframework.org/schema/beans
+ http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
+ http://www.springframework.org/schema/context
+ http://www.springframework.org/schema/context/spring-context-3.0.xsd">
+
+ <context:annotation-config />
+ <context:component-scan base-package="com.frentix.olat.vitero" />
+
+ <!-- Definition of the providers -->
+ <bean id="viteroModule" class="com.frentix.olat.vitero.ViteroModule">
+ <constructor-arg index="0" ref="schedulerFactoryBean"/>
+ <property name="cronExpression" value="0 15 */12 * * ?" />
+ <property name="deleteVmsUserOnUserDelete" value="${vc.vitero.deleteVmsUserOnUserDelete}" />
+
+ <property name="persistedProperties">
+ <bean class="org.olat.core.configuration.PersistedProperties" scope="prototype" init-method="init" destroy-method="destroy"
+ depends-on="coordinatorManager,org.olat.core.util.WebappHelper">
+ <constructor-arg index="0" ref="coordinatorManager"/>
+ <constructor-arg index="1" ref="viteroModule" />
+ </bean>
+ </property>
+
+ </bean>
+
+ <!-- default configuration -->
+ <bean class="org.springframework.beans.factory.config.MethodInvokingFactoryBean">
+ <property name="targetObject" ref="viteroModule" />
+ <property name="targetMethod" value="init" />
+ <property name="arguments">
+ <value>
+ vc.vitero.enabled=${vc.vitero.enabled}
+ protocol=${vc.vitero.protocol}
+ port=${vc.vitero.port}
+ baseUrl=${vc.vitero.baseurl}
+ contextPath=${vc.vitero.contextPath}
+ adminLogin=${vc.vitero.adminlogin}
+ adminPassword=${vc.vitero.adminpassword}
+ customerId=${vc.vitero.customerid}
+ olatTimeZoneId=${vc.vitero.olatTimeZoneId}
+ </value>
+ </property>
+ </bean>
+
+ <!-- Portfolio admin. panel -->
+ <bean class="org.olat.core.extensions.action.GenericActionExtension" init-method="initExtensionPoints">
+ <property name="actionController">
+ <bean class="org.olat.core.gui.control.creator.FactoryControllerCreator" scope="prototype">
+ <property name="factoryName" value="com.frentix.olat.vitero.ViteroUIFactory"/>
+ <property name="factoryMethod" value="createViteroAdminController"/>
+ </bean>
+ </property>
+ <property name="i18nActionKey" value="admin.menu.title"/>
+ <property name="i18nDescriptionKey" value="admin.menu.title.alt"/>
+ <property name="translationPackage" value="com.frentix.olat.vitero.ui"/>
+ <property name="extensionPoints">
+ <list>
+ <value>org.olat.admin.SystemAdminMainController</value>
+ </list>
+ </property>
+ <property name="order" value="39" />
+ </bean>
+</beans>
\ No newline at end of file
diff --git a/src/main/java/com/frentix/olat/vitero/manager/EmptyOMElement.java b/src/main/java/com/frentix/olat/vitero/manager/EmptyOMElement.java
new file mode 100644
index 0000000000000000000000000000000000000000..27cc8776e2f66da75c0e9ee0e65f2f67e8f5dcd0
--- /dev/null
+++ b/src/main/java/com/frentix/olat/vitero/manager/EmptyOMElement.java
@@ -0,0 +1,369 @@
+package com.frentix.olat.vitero.manager;
+
+import java.io.OutputStream;
+import java.io.Writer;
+import java.util.Iterator;
+import java.util.NoSuchElementException;
+
+import javax.xml.namespace.QName;
+import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.XMLStreamReader;
+import javax.xml.stream.XMLStreamWriter;
+
+import org.apache.axiom.om.OMAttribute;
+import org.apache.axiom.om.OMContainer;
+import org.apache.axiom.om.OMElement;
+import org.apache.axiom.om.OMException;
+import org.apache.axiom.om.OMFactory;
+import org.apache.axiom.om.OMNamespace;
+import org.apache.axiom.om.OMNode;
+import org.apache.axiom.om.OMOutputFormat;
+import org.apache.axiom.om.OMXMLParserWrapper;
+
+
+public class EmptyOMElement implements OMElement {
+
+ private static final Iterator<Object> EMPTY_ITERATOR = new EmptyIterator();
+
+ @Override
+ public void addChild(OMNode omNode) {
+ //
+ }
+
+ @Override
+ public Iterator<?> getChildrenWithName(QName elementQName) {
+ return EMPTY_ITERATOR;
+ }
+
+ @Override
+ public Iterator<?> getChildrenWithLocalName(String localName) {
+ return EMPTY_ITERATOR;
+ }
+
+ @Override
+ public Iterator<?> getChildrenWithNamespaceURI(String uri) {
+ return EMPTY_ITERATOR;
+ }
+
+ @Override
+ public OMElement getFirstChildWithName(QName elementQName) throws OMException {
+ return null;
+ }
+
+ @Override
+ public Iterator<?> getChildren() {
+ return EMPTY_ITERATOR;
+ }
+
+ @Override
+ public OMNode getFirstOMChild() {
+ return null;
+ }
+
+ @Override
+ public void buildNext() {
+ //
+ }
+
+ @Override
+ public OMContainer getParent() {
+ return null;
+ }
+
+ @Override
+ public OMNode getNextOMSibling() throws OMException {
+ return null;
+ }
+
+ @Override
+ public boolean isComplete() {
+ return false;
+ }
+
+ @Override
+ public OMNode detach() throws OMException {
+ return null;
+ }
+
+ @Override
+ public void discard() throws OMException {
+ //
+ }
+
+ @Override
+ public void insertSiblingAfter(OMNode sibling) throws OMException {
+ //
+ }
+
+ @Override
+ public void insertSiblingBefore(OMNode sibling) throws OMException {
+ //
+ }
+
+ @Override
+ public int getType() {
+ return 0;
+ }
+
+ @Override
+ public OMNode getPreviousOMSibling() {
+ return null;
+ }
+
+ @Override
+ public void serialize(XMLStreamWriter xmlWriter) throws XMLStreamException {
+ //
+ }
+
+ @Override
+ public void serialize(OutputStream output) throws XMLStreamException {
+ //
+ }
+
+ @Override
+ public void serialize(Writer writer) throws XMLStreamException {
+ //
+ }
+
+ @Override
+ public void serialize(OutputStream output, OMOutputFormat format) throws XMLStreamException {
+ //
+ }
+
+ @Override
+ public void serialize(Writer writer, OMOutputFormat format) throws XMLStreamException {
+ //
+ }
+
+ @Override
+ public void serializeAndConsume(XMLStreamWriter xmlWriter) throws XMLStreamException {
+ //
+ }
+
+ @Override
+ public void serializeAndConsume(OutputStream output) throws XMLStreamException {
+ //
+ }
+
+ @Override
+ public void serializeAndConsume(Writer writer) throws XMLStreamException {
+ //
+ }
+
+ @Override
+ public void serializeAndConsume(OutputStream output, OMOutputFormat format) throws XMLStreamException {
+ //
+ }
+
+ @Override
+ public void serializeAndConsume(Writer writer, OMOutputFormat format) throws XMLStreamException {
+ //
+ }
+
+ @Override
+ public void build() {
+ //
+ }
+
+ @Override
+ public void buildWithAttachments() {
+ //
+ }
+
+ @Override
+ public void close(boolean build) {
+ //
+ }
+
+ @Override
+ public OMFactory getOMFactory() {
+ return null;
+ }
+
+ @Override
+ public Iterator<?> getChildElements() {
+ return EMPTY_ITERATOR;
+ }
+
+ @Override
+ public OMNamespace declareNamespace(String uri, String prefix) {
+ return null;
+ }
+
+ @Override
+ public OMNamespace declareDefaultNamespace(String uri) {
+ return null;
+ }
+
+ @Override
+ public OMNamespace getDefaultNamespace() {
+ return null;
+ }
+
+ @Override
+ public OMNamespace declareNamespace(OMNamespace namespace) {
+ return null;
+ }
+
+ @Override
+ public OMNamespace findNamespace(String uri, String prefix) {
+ return null;
+ }
+
+ @Override
+ public OMNamespace findNamespaceURI(String prefix) {
+ return null;
+ }
+
+ @Override
+ public Iterator<?> getAllDeclaredNamespaces() throws OMException {
+ return EMPTY_ITERATOR;
+ }
+
+ @Override
+ public Iterator<?> getAllAttributes() {
+ return EMPTY_ITERATOR;
+ }
+
+ @Override
+ public OMAttribute getAttribute(QName qname) {
+ return null;
+ }
+
+ @Override
+ public String getAttributeValue(QName qname) {
+ return null;
+ }
+
+ @Override
+ public OMAttribute addAttribute(OMAttribute attr) {
+ return null;
+ }
+
+ @Override
+ public OMAttribute addAttribute(String attributeName, String value, OMNamespace ns) {
+ return null;
+ }
+
+ @Override
+ public void removeAttribute(OMAttribute attr) {
+ //
+ }
+
+ @Override
+ public void setBuilder(OMXMLParserWrapper wrapper) {
+ //
+ }
+
+ @Override
+ public OMXMLParserWrapper getBuilder() {
+ return null;
+ }
+
+ @Override
+ public void setFirstChild(OMNode node) {
+ //
+ }
+
+ @Override
+ public OMElement getFirstElement() {
+ return null;
+ }
+
+ @Override
+ public XMLStreamReader getXMLStreamReader() {
+ return null;
+ }
+
+ @Override
+ public XMLStreamReader getXMLStreamReaderWithoutCaching() {
+ return null;
+ }
+
+ @Override
+ public void setText(String text) {
+ //
+ }
+
+ @Override
+ public void setText(QName text) {
+ //
+ }
+
+ @Override
+ public String getText() {
+ return null;
+ }
+
+ @Override
+ public QName getTextAsQName() {
+ return null;
+ }
+
+ @Override
+ public String getLocalName() {
+ return null;
+ }
+
+ @Override
+ public void setLocalName(String localName) {
+ //
+ }
+
+ @Override
+ public OMNamespace getNamespace() throws OMException {
+ return null;
+ }
+
+ @Override
+ public void setNamespace(OMNamespace namespace) {
+ //
+ }
+
+ @Override
+ public void setNamespaceWithNoFindInCurrentScope(OMNamespace namespace) {
+ //
+ }
+
+ @Override
+ public QName getQName() {
+ return null;
+ }
+
+ @Override
+ public String toStringWithConsume() throws XMLStreamException {
+ return null;
+ }
+
+ @Override
+ public QName resolveQName(String qname) {
+ return null;
+ }
+
+ @Override
+ public OMElement cloneOMElement() {
+ return null;
+ }
+
+ @Override
+ public void setLineNumber(int lineNumber) {
+ //
+ }
+
+ @Override
+ public int getLineNumber() {
+ return 0;
+ }
+
+ static class EmptyIterator implements Iterator<Object> {
+ public boolean hasNext() {
+ return false;
+ }
+ public Object next() {
+ throw new NoSuchElementException();
+ }
+ public void remove() {
+ throw new IllegalStateException();
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/main/java/com/frentix/olat/vitero/manager/SecurityHeader.java b/src/main/java/com/frentix/olat/vitero/manager/SecurityHeader.java
new file mode 100644
index 0000000000000000000000000000000000000000..c73693f2cdea31a028c0b3c52c2689fa7e21ef96
--- /dev/null
+++ b/src/main/java/com/frentix/olat/vitero/manager/SecurityHeader.java
@@ -0,0 +1,103 @@
+/**
+ * OLAT - Online Learning and Training<br>
+ * http://www.olat.org
+ * <p>
+ * Licensed under the Apache License, Version 2.0 (the "License"); <br>
+ * you may not use this file except in compliance with the License.<br>
+ * You may obtain a copy of the License at
+ * <p>
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * <p>
+ * Unless required by applicable law or agreed to in writing,<br>
+ * software distributed under the License is distributed on an "AS IS" BASIS, <br>
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. <br>
+ * See the License for the specific language governing permissions and <br>
+ * limitations under the License.
+ * <p>
+ * Copyright (c) frentix GmbH<br>
+ * http://www.frentix.com<br>
+ * <p>
+ */
+package com.frentix.olat.vitero.manager;
+
+import java.text.SimpleDateFormat;
+import java.util.Date;
+import java.util.UUID;
+
+import javax.xml.namespace.QName;
+
+import org.apache.axiom.om.OMAbstractFactory;
+import org.apache.axiom.om.OMElement;
+import org.apache.axiom.om.OMFactory;
+import org.apache.axiom.om.OMNamespace;
+import org.apache.axis2.client.ServiceClient;
+import org.apache.axis2.client.Stub;
+import org.apache.commons.codec.binary.Base64;
+
+import com.frentix.olat.vitero.ViteroModule;
+
+/**
+ *
+ * Description:<br>
+ * Generate the SOAP header to authenticate against VMS
+ *
+ * <P>
+ * Initial Date: 6 oct. 2011 <br>
+ *
+ * @author srosse, stephane.rosse@frentix.com, http://www.frentix.com
+ */
+public class SecurityHeader {
+
+ public static void addAdminSecurityHeader(ViteroModule module, Stub stub) {
+ addAdminSecurityHeader(module.getAdminLogin(), module.getAdminPassword(), stub);
+ }
+
+ public static void addAdminSecurityHeader(String login, String password, Stub stub) {
+ ServiceClient client = stub._getServiceClient();
+ OMElement securityEl = generateSecurityHeader(login, password);
+ client.addHeader(securityEl);
+ }
+
+ public static OMElement generateSecurityHeader(String username, String password) {
+ OMFactory omFactory = OMAbstractFactory.getOMFactory();
+
+ OMNamespace soapenvNamespace = omFactory.createOMNamespace("http://schemas.xmlsoap.org/soap/envelope/", "soapenv");
+ OMNamespace wsuNamespace = omFactory.createOMNamespace("http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd", "wsu");
+
+ //Security
+ OMElement securityElement = omFactory.createOMElement(new QName("http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd", "Security", "wsse"), null);
+ securityElement.addAttribute("mustUnderstand", "1", soapenvNamespace);
+
+ //UsernameToken
+ OMElement tokenEl = omFactory.createOMElement(new QName("http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd", "UsernameToken", "wsse"), null);
+ tokenEl.addAttribute("Id", "XWSSGID-1317643090236539015674", wsuNamespace);
+ securityElement.addChild(tokenEl);
+
+ //Username
+ OMElement usernameEl = omFactory.createOMElement(new QName("http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd", "Username", "wsse"), null);
+ usernameEl.setText(username);
+ tokenEl.addChild(usernameEl);
+ //Password
+ OMElement passwordEl = omFactory.createOMElement(new QName("http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd", "Password", "wsse"), null);
+ passwordEl.addAttribute("Type", "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-username-token-profile-1.0#PasswordText", null);
+ passwordEl.setText(password);
+ tokenEl.addChild(passwordEl);
+ //Nonce
+ OMElement nonceEl = omFactory.createOMElement(new QName("http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd", "Nonce", "wsse"), null);
+ nonceEl.addAttribute("EncodingType", "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-soap-message-security-1.0#Base64Binary", null);
+
+ String uuid = UUID.randomUUID().toString();
+ String uuid64 = Base64.encodeBase64String(uuid.getBytes());
+ nonceEl.setText(uuid64);
+ tokenEl.addChild(nonceEl);
+ //Created
+ OMElement createdEl = omFactory.createOMElement("Created", wsuNamespace);
+ SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd'T'hh:mm:ss.S'Z'");
+ String created = format.format(new Date());
+
+ createdEl.setText(created);
+ tokenEl.addChild(createdEl);
+ return securityElement;
+ }
+
+}
diff --git a/src/main/java/com/frentix/olat/vitero/manager/ViteroManager.java b/src/main/java/com/frentix/olat/vitero/manager/ViteroManager.java
new file mode 100644
index 0000000000000000000000000000000000000000..b5f50095ef485fa2c5a37e29df52ee85eb9ecb96
--- /dev/null
+++ b/src/main/java/com/frentix/olat/vitero/manager/ViteroManager.java
@@ -0,0 +1,1232 @@
+/**
+ * OLAT - Online Learning and Training<br>
+ * http://www.olat.org
+ * <p>
+ * Licensed under the Apache License, Version 2.0 (the "License"); <br>
+ * you may not use this file except in compliance with the License.<br>
+ * You may obtain a copy of the License at
+ * <p>
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * <p>
+ * Unless required by applicable law or agreed to in writing,<br>
+ * software distributed under the License is distributed on an "AS IS" BASIS, <br>
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. <br>
+ * See the License for the specific language governing permissions and <br>
+ * limitations under the License.
+ * <p>
+ * Copyright (c) frentix GmbH<br>
+ * http://www.frentix.com<br>
+ * <p>
+ */
+package com.frentix.olat.vitero.manager;
+
+import java.io.File;
+import java.io.StringWriter;
+import java.math.BigInteger;
+import java.rmi.RemoteException;
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Date;
+import java.util.List;
+import java.util.UUID;
+
+import javax.activation.DataHandler;
+import javax.activation.FileDataSource;
+import javax.annotation.PostConstruct;
+import javax.ws.rs.core.UriBuilder;
+
+import org.apache.axis2.AxisFault;
+import org.apache.commons.httpclient.ConnectTimeoutException;
+import org.olat.admin.user.delete.service.UserDeletionManager;
+import org.olat.basesecurity.Authentication;
+import org.olat.basesecurity.BaseSecurity;
+import org.olat.core.id.Identity;
+import org.olat.core.id.OLATResourceable;
+import org.olat.core.id.User;
+import org.olat.core.id.UserConstants;
+import org.olat.core.manager.BasicManager;
+import org.olat.core.util.StringHelper;
+import org.olat.core.util.xml.XStreamHelper;
+import org.olat.group.BusinessGroup;
+import org.olat.properties.Property;
+import org.olat.properties.PropertyManager;
+import org.olat.user.DisplayPortraitManager;
+import org.olat.user.UserDataDeletable;
+import org.olat.user.UserManager;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import com.frentix.olat.vitero.ViteroModule;
+import com.frentix.olat.vitero.manager.stubs.BookingServiceStub;
+import com.frentix.olat.vitero.manager.stubs.BookingServiceStub.Booking;
+import com.frentix.olat.vitero.manager.stubs.BookingServiceStub.Bookinglist;
+import com.frentix.olat.vitero.manager.stubs.BookingServiceStub.Bookingtype;
+import com.frentix.olat.vitero.manager.stubs.CustomerServiceStub;
+import com.frentix.olat.vitero.manager.stubs.GroupServiceStub;
+import com.frentix.olat.vitero.manager.stubs.GroupServiceStub.Completegrouptype;
+import com.frentix.olat.vitero.manager.stubs.LicenceServiceStub;
+import com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.Rooms_type0;
+import com.frentix.olat.vitero.manager.stubs.MtomServiceStub;
+import com.frentix.olat.vitero.manager.stubs.SessionCodeServiceStub;
+import com.frentix.olat.vitero.manager.stubs.SessionCodeServiceStub.Codetype;
+import com.frentix.olat.vitero.manager.stubs.UserServiceStub;
+import com.frentix.olat.vitero.manager.stubs.UserServiceStub.Userid;
+import com.frentix.olat.vitero.manager.stubs.UserServiceStub.Userlist;
+import com.frentix.olat.vitero.manager.stubs.UserServiceStub.Usertype;
+import com.frentix.olat.vitero.model.GroupRole;
+import com.frentix.olat.vitero.model.ViteroBooking;
+import com.frentix.olat.vitero.model.ViteroCustomer;
+import com.frentix.olat.vitero.model.ViteroGroup;
+import com.frentix.olat.vitero.model.ViteroUser;
+import com.ibm.icu.util.Calendar;
+import com.thoughtworks.xstream.XStream;
+import com.thoughtworks.xstream.io.xml.CompactWriter;
+
+/**
+ *
+ * Description:<br>
+ * Implementation of the Virtual Classroom for the Vitero Booking System
+ *
+ * <P>
+ * Initial Date: 26 sept. 2011 <br>
+ * @author srosse, stephane.rosse@frentix.com, http://www.frentix.com
+ */
+@Service
+public class ViteroManager extends BasicManager implements UserDataDeletable {
+
+ private static final SimpleDateFormat dateFormat = new SimpleDateFormat("yyyyMMddHHmm");
+
+ private static final String VMS_PROVIDER = "VMS";
+ private static final String VMS_CATEGORY = "vitero-category";
+ private static final String VMS_CATEGORY_ZOMBIE = "vitero-category-zombie";
+
+ @Autowired
+ private ViteroModule viteroModule;
+ @Autowired
+ private PropertyManager propertyManager;
+ @Autowired
+ private BaseSecurity securityManager;
+ @Autowired
+ private UserManager userManager;
+ @Autowired
+ private UserDeletionManager userDeletionManager;
+
+ private XStream xStream;
+
+ public ViteroManager() {
+ //make Spring happy
+ }
+
+ @PostConstruct
+ public void init() {
+ xStream = XStreamHelper.createXStreamInstance();
+ xStream.alias("vBooking", ViteroBooking.class);
+ xStream.omitField(ViteroBooking.class, "property");
+
+ userDeletionManager.registerDeletableUserData(this);
+ }
+
+ public void setViteroModule(ViteroModule module) {
+ this.viteroModule = module;
+ }
+
+ public List<ViteroBooking> getBookingByDate(Date start, Date end) {
+ try {
+ BookingServiceStub bookingWs = getBookingWebService();
+ BookingServiceStub.GetBookingListByDateRequest dateRequest = new BookingServiceStub.GetBookingListByDateRequest();
+ dateRequest.setStart(format(start));
+ dateRequest.setEnd(format(end));
+ dateRequest.setTimezone(viteroModule.getTimeZoneId());
+ BookingServiceStub.GetBookingListByDateResponse response = bookingWs.getBookingListByDate(dateRequest);
+
+ BookingServiceStub.Bookinglist bookingList = response.getGetBookingListByDateResponse();
+ Booking[] bookings = bookingList.getBooking();
+ return convert(bookings);
+ } catch(AxisFault f) {
+ String msg = f.getFaultDetailElement().toString();
+ logError(msg, f);
+ return Collections.emptyList();
+ } catch (RemoteException e) {
+ logError("Cannot get bookings by date", e);
+ return Collections.emptyList();
+ }
+ }
+
+ public boolean canGoBooking(ViteroBooking booking) {
+ Date now = new Date();
+
+ Calendar cal = Calendar.getInstance();
+ cal.setTime(booking.getStart());
+ cal.add(Calendar.MINUTE, -booking.getStartBuffer());
+ Date start = cal.getTime();
+ cal.setTime(booking.getEnd());
+ cal.add(Calendar.MINUTE, booking.getEndBuffer());
+ Date end = cal.getTime();
+
+ if(start.before(now) && end.after(now)) {
+ return true;
+ }
+ return false;
+ }
+
+ public String getURLToBooking(Identity identity, ViteroBooking booking)
+ throws VmsNotAvailableException {
+ String sessionCode = createSessionCode(identity, booking);
+ String url = getStartPoint(sessionCode);
+ return url;
+ }
+
+ public List<ViteroCustomer> getCustomers()
+ throws VmsNotAvailableException {
+ try {
+ CustomerServiceStub customerWs = getCustomerWebService();
+ CustomerServiceStub.GetCustomerListRequest listRequest = new CustomerServiceStub.GetCustomerListRequest();
+ listRequest.setGetCustomerListRequest(new EmptyOMElement());
+ CustomerServiceStub.GetCustomerListResponse response = customerWs.getCustomerList(listRequest);
+ CustomerServiceStub.Customertype[] customerTypes = response.getCustomer();
+ return convert(customerTypes);
+ } catch (AxisFault f) {
+ int code = handleAxisFault(f);
+ switch(code) {
+ default: logAxisError("Cannot get the list of customers.", f);
+ }
+ return Collections.emptyList();
+ } catch (RemoteException e) {
+ logError("Cannot get the list of customers.", e);
+ return Collections.emptyList();
+ }
+ }
+
+ /**
+ * Create a session code with a one hour expiration date
+ * @param identity
+ * @param booking
+ * @return
+ */
+ protected String createSessionCode(Identity identity, ViteroBooking booking)
+ throws VmsNotAvailableException {
+ try {
+ int userId = getVmsUserId(identity, true);
+ SessionCodeServiceStub sessionCodeWs = this.getSessionCodeWebService();
+ SessionCodeServiceStub.CreatePersonalBookingSessionCodeRequest codeRequest = new SessionCodeServiceStub.CreatePersonalBookingSessionCodeRequest();
+
+ SessionCodeServiceStub.Sessioncode_type2 code = new SessionCodeServiceStub.Sessioncode_type2();
+ code.setBookingid(booking.getBookingId());
+ code.setUserid(userId);
+ code.setTimezone(viteroModule.getTimeZoneId());
+
+ Calendar cal = Calendar.getInstance();
+ cal.setTime(new Date());
+ cal.add(Calendar.HOUR, 1);
+ code.setExpirationdate(format(cal.getTime()));
+
+ codeRequest.setSessioncode(code);
+
+ SessionCodeServiceStub.CreatePersonalBookingSessionCodeResponse response = sessionCodeWs.createPersonalBookingSessionCode(codeRequest);
+ Codetype myCode = response.getCreatePersonalBookingSessionCodeResponse();
+ return myCode.getCode();
+ } catch(AxisFault f) {
+ int code = handleAxisFault(f);
+ switch(code) {
+ case 53: logError("User does not exist.", f); break;
+ case 153: logError("User not assigned to group.", f); break;
+ case 303: logError("Invalid attribute.", f); break;
+ case 304: logError("Invalid time zone.", f); break;
+ case 506:
+ case 509: logError("Booking does not exist.", f); break;
+ default: logAxisError("Cannot create session code.", f);
+ }
+ return null;
+ } catch (RemoteException e) {
+ logError("Cannot create session code.", e);
+ return null;
+ }
+ }
+
+ public List<Identity> getIdentitiesInBooking(ViteroBooking booking)
+ throws VmsNotAvailableException {
+ Usertype[] vmsUsers = getVmsUsersByGroup(booking.getGroupId());
+ List<Identity> identities = new ArrayList<Identity>();
+ if(vmsUsers != null) {
+ for(Usertype vmsUser:vmsUsers) {
+ String email = vmsUser.getEmail();
+ Identity id = userManager.findIdentityByEmail(email);
+ if(id != null) {
+ identities.add(id);
+ }
+ }
+ }
+ return identities;
+ }
+
+ public List<ViteroUser> getUsersOf(ViteroBooking booking)
+ throws VmsNotAvailableException {
+ return convert(getVmsUsersByGroup(booking.getGroupId()));
+ }
+
+ protected Usertype[] getVmsUsersByGroup(int groupId)
+ throws VmsNotAvailableException {
+ try {
+ UserServiceStub userWs = getUserWebService();
+ UserServiceStub.GetUserListByGroupRequest listRequest = new UserServiceStub.GetUserListByGroupRequest();
+ listRequest.setGroupid(groupId);
+ UserServiceStub.GetUserListByGroupResponse response = userWs.getUserListByGroup(listRequest);
+ Userlist userList = response.getGetUserListByGroupResponse();
+ Usertype[] userTypes = userList.getUser();
+ return userTypes;
+ } catch(AxisFault f) {
+ int code = handleAxisFault(f);
+ switch(code) {
+ default: logAxisError("Cannot get the list of users in group: " + groupId, f);
+ }
+ return null;
+ } catch (RemoteException e) {
+ logError("Cannot get the list of users in group: " + groupId, e);
+ return null;
+ }
+ }
+
+ protected int getVmsUserId(Identity identity, boolean create)
+ throws VmsNotAvailableException {
+ int userId;
+ Authentication authentication = securityManager.findAuthentication(identity, VMS_PROVIDER);
+ if(authentication == null) {
+ if(create) {
+ userId = createVmsUser(identity);
+ if(userId > 0) {
+ securityManager.createAndPersistAuthentication(identity, VMS_PROVIDER, Integer.toString(userId), "");
+ }
+ } else {
+ userId = -1;
+ }
+ } else {
+ userId = Integer.parseInt(authentication.getAuthusername());
+ }
+ return userId;
+ }
+
+ protected int createVmsUser(Identity identity)
+ throws VmsNotAvailableException {
+ try {
+ UserServiceStub userWs = getUserWebService();
+ UserServiceStub.CreateUserRequest createRequest = new UserServiceStub.CreateUserRequest();
+ UserServiceStub.Newusertype user = new UserServiceStub.Newusertype();
+
+ //mandatory
+ User olatUser = identity.getUser();
+ user.setUsername("olat." + identity.getName());
+ user.setSurname(olatUser.getProperty(UserConstants.LASTNAME, null));
+ user.setFirstname(olatUser.getProperty(UserConstants.FIRSTNAME, null));
+ user.setEmail(olatUser.getProperty(UserConstants.EMAIL, null));
+ user.setPassword("changeme");
+
+ UserServiceStub.Idlist customerIds = new UserServiceStub.Idlist();
+ customerIds.set_int(new int[]{viteroModule.getCustomerId()});
+ user.setCustomeridlist(customerIds);
+
+ //optional
+ user.setLocale("en");
+ user.setPcstate("NOT_TESTED");
+ user.setTimezone(viteroModule.getTimeZoneId());
+
+ String street = olatUser.getProperty(UserConstants.STREET, null);
+ if(StringHelper.containsNonWhitespace(street)) {
+ user.setStreet(street);
+ }
+ String zip = olatUser.getProperty(UserConstants.ZIPCODE, null);
+ if(StringHelper.containsNonWhitespace(zip)) {
+ user.setZip(zip);
+ }
+ String city = olatUser.getProperty(UserConstants.CITY, null);
+ if(StringHelper.containsNonWhitespace(city)) {
+ user.setCity(city);
+ }
+ String country = olatUser.getProperty(UserConstants.COUNTRY, null);
+ if(StringHelper.containsNonWhitespace(country)) {
+ user.setCountry(country);
+ }
+
+ String mobile = olatUser.getProperty(UserConstants.TELMOBILE, null);
+ if(StringHelper.containsNonWhitespace(mobile)) {
+ user.setMobile(mobile);
+ }
+ String phonePrivate = olatUser.getProperty(UserConstants.TELPRIVATE, null);
+ if(StringHelper.containsNonWhitespace(phonePrivate)) {
+ user.setPhone(phonePrivate);
+ }
+ String phoneOffice = olatUser.getProperty(UserConstants.TELOFFICE, null);
+ if(StringHelper.containsNonWhitespace(phoneOffice)) {
+ user.setPhone(phoneOffice);
+ }
+ /*
+ user.setTitle("");
+ user.setCompany("");
+ */
+ user.setTechnicalnote("Generated by OpenOLAT");
+
+ createRequest.setUser(user);
+ UserServiceStub.CreateUserResponse response = userWs.createUser(createRequest);
+ Userid userId = response.getCreateUserResponse();
+
+ storePortrait(identity, userId.getUserid());
+ return userId.getUserid();
+ } catch(AxisFault f) {
+ int code = handleAxisFault(f);
+ switch(code) {
+ default: logAxisError("Cannot create vms user.", f);
+ }
+ return -1;
+ } catch (RemoteException e) {
+ logError("Cannot create vms user.", e);
+ return -1;
+ }
+ }
+
+ protected boolean storePortrait(Identity identity, int userId)
+ throws VmsNotAvailableException {
+ try {
+ File portraitDir = DisplayPortraitManager.getInstance().getPortraitDir(identity);
+ File portrait = new File(portraitDir, DisplayPortraitManager.PORTRAIT_BIG_FILENAME);
+ if(portrait.exists()) {
+ MtomServiceStub mtomWs = getMtomWebService();
+
+ MtomServiceStub.StoreAvatarRequest request = new MtomServiceStub.StoreAvatarRequest();
+ MtomServiceStub.CompleteAvatarWrapper avatar = new MtomServiceStub.CompleteAvatarWrapper();
+
+ avatar.setType(BigInteger.ZERO);
+ avatar.setUserid(BigInteger.valueOf(userId));
+ avatar.setFilename(portrait.getName());
+
+ DataHandler portraitHandler = new DataHandler(new FileDataSource(portrait));
+ avatar.setFile(portraitHandler);
+
+ request.setStoreAvatarRequest(avatar);
+ mtomWs.storeAvatar(request);
+ return true;
+ }
+ return false;
+ } catch(AxisFault f) {
+ int code = handleAxisFault(f);
+ switch(code) {
+ default: logAxisError("Cannot store the portrait of " + userId, f);
+ }
+ return false;
+ } catch (RemoteException e) {
+ logError("Cannot store the portrait of " + userId, e);
+ return false;
+ }
+ }
+
+ @Override
+ public void deleteUserData(Identity identity, String newDeletedUserName) {
+ if(!viteroModule.isDeleteVmsUserOnUserDelete()) return;
+
+ try {
+ int userId = getVmsUserId(identity, false);
+ if(userId > 0) {
+ deleteVmsUser(userId);
+ }
+ } catch (VmsNotAvailableException e) {
+ logError("Cannot delete a vms user after a OLAT user deletion.", e);
+ }
+ }
+
+ protected void deleteVmsUser(int userId)
+ throws VmsNotAvailableException {
+ try {
+ UserServiceStub userWs = getUserWebService();
+ UserServiceStub.DeleteUserRequest delRequest = new UserServiceStub.DeleteUserRequest();
+ UserServiceStub.Userid userIdType = new UserServiceStub.Userid();
+ userIdType.setUserid(userId);
+ delRequest.setDeleteUserRequest(userIdType);
+ userWs.deleteUser(delRequest);
+
+ } catch (AxisFault f) {
+ int code = handleAxisFault(f);
+ switch(code) {
+ default: logAxisError("Cannot delete vms user: " + userId, f);
+ }
+ } catch(RemoteException e) {
+ logError("Cannot delete vms user: " + userId, e);
+ }
+ }
+
+ public List<Integer> getLicencedRoomSizes()
+ throws VmsNotAvailableException {
+ List<Integer> roomSizes = new ArrayList<Integer>();
+ try {
+ LicenceServiceStub licenceWs = getLicenceWebService();
+ LicenceServiceStub.GetModulesForCustomerRequest licenceRequest = new LicenceServiceStub.GetModulesForCustomerRequest();
+ licenceRequest.setCustomerid(viteroModule.getCustomerId());
+
+ LicenceServiceStub.GetModulesForCustomerResponse response = licenceWs.getModulesForCustomer(licenceRequest);
+ LicenceServiceStub.Modulestype modules = response.getGetModulesForCustomerResponse();
+ LicenceServiceStub.Modules_type0 modulesType = modules.getModules();
+ for(LicenceServiceStub.Module_type0 module:modulesType.getModule()) {
+ if("ROOM".equals(module.getType())) {
+ Integer roomSize = module.getRoomsize();
+ if(!roomSizes.contains(roomSize)) {
+ roomSizes.add(roomSize);
+ }
+ }
+ }
+ } catch(AxisFault f) {
+ int code = handleAxisFault(f);
+ switch(code) {
+ case 303: logError("ids <=0 or invalid attributs", f); break;
+ default: logAxisError("Cannot get licence for customer: " + viteroModule.getCustomerId(), f);
+ }
+ } catch (RemoteException e) {
+ logError("Cannot get licence for customer: " + viteroModule.getCustomerId(), e);
+ }
+ return roomSizes;
+ }
+
+ public List<Integer> getLicenceForAvailableRooms(Date begin, Date end)
+ throws VmsNotAvailableException {
+ List<Integer> roomSizes = new ArrayList<Integer>();
+ try {
+ LicenceServiceStub licenceWs = getLicenceWebService();
+ LicenceServiceStub.GetBookableRoomsForGroupRequest request = new LicenceServiceStub.GetBookableRoomsForGroupRequest();
+ LicenceServiceStub.Grouprequesttype groupRequest = new LicenceServiceStub.Grouprequesttype();
+ groupRequest.setStart(format(begin));
+ groupRequest.setEnd(format(end));
+
+ request.setGetBookableRoomsForGroupRequest(groupRequest);
+
+ LicenceServiceStub.GetBookableRoomsForGroupResponse response = licenceWs.getBookableRoomsForGroup(request);
+ Rooms_type0 rooms = response.getRooms();
+ for(int roomSize : rooms.getRoomsize()) {
+ if(!roomSizes.contains(roomSize)) {
+ roomSizes.add(roomSize);
+ }
+ }
+
+ } catch(AxisFault f) {
+ int code = handleAxisFault(f);
+ switch(code) {
+ default: logAxisError("Cannot get licence for available room by dates.", f);
+ }
+ } catch (RemoteException e) {
+ logError("Cannot get licence for available room by dates.", e);
+ }
+ return roomSizes;
+ }
+
+ public int createGroup()
+ throws VmsNotAvailableException {
+ try {
+ GroupServiceStub groupWs = getGroupWebService();
+ GroupServiceStub.CreateGroupRequest createRequest = new GroupServiceStub.CreateGroupRequest();
+ GroupServiceStub.Groupnamecustomerid groupInfos = new GroupServiceStub.Groupnamecustomerid();
+ groupInfos.setGroupname("OLAT-" + UUID.randomUUID().toString());
+ groupInfos.setCustomerid(viteroModule.getCustomerId());
+ createRequest.setGroup(groupInfos);
+
+ GroupServiceStub.CreateGroupResponse response = groupWs.createGroup(createRequest);
+ GroupServiceStub.Groupid groupId = response.getCreateGroupResponse();
+
+ return groupId.getGroupid();
+ } catch(AxisFault f) {
+ int code = handleAxisFault(f);
+ switch(code) {
+ default: logAxisError("Cannot create a group",f);
+ }
+ return -1;
+ } catch (RemoteException e) {
+ logError("Cannot create a group.", e);
+ return -1;
+ }
+ }
+
+ public ViteroGroup getGroup(int id)
+ throws VmsNotAvailableException {
+ try {
+ GroupServiceStub groupWs = getGroupWebService();
+ GroupServiceStub.GetGroupRequest getRequest = new GroupServiceStub.GetGroupRequest();
+ GroupServiceStub.Groupid groupId = new GroupServiceStub.Groupid();
+ groupId.setGroupid(id);
+ getRequest.setGetGroupRequest(groupId);
+
+ GroupServiceStub.GetGroupResponse response = groupWs.getGroup(getRequest);
+ GroupServiceStub.Group group = response.getGetGroupResponse();
+ GroupServiceStub.Completegrouptype groupType = group.getGroup();
+ return convert(groupType);
+ } catch(AxisFault f) {
+ int code = handleAxisFault(f);
+ switch(code) {
+ default: logAxisError("Cannot create a group",f);
+ }
+ return null;
+ } catch (RemoteException e) {
+ logError("Cannot create a group.", e);
+ return null;
+ }
+ }
+
+ public boolean deleteGroup(ViteroBooking vBooking)
+ throws VmsNotAvailableException {
+ try {
+ GroupServiceStub groupWs = getGroupWebService();
+ GroupServiceStub.DeleteGroupRequest deleteRequest = new GroupServiceStub.DeleteGroupRequest();
+ GroupServiceStub.Groupid groupId = new GroupServiceStub.Groupid();
+ groupId.setGroupid(vBooking.getGroupId());
+ deleteRequest.setDeleteGroupRequest(groupId);
+ groupWs.deleteGroup(deleteRequest);
+ return true;
+ } catch(AxisFault f) {
+ int code = handleAxisFault(f);
+ switch(code) {
+ case 151: logError("Group doesn't exist!", f); break;
+ case 303: logError("Group id <= 0!", f);
+ default: logAxisError("Cannot delete group: " + vBooking.getGroupId(), f);
+ }
+ return false;
+ } catch (RemoteException e) {
+ logError("Cannot delete group: " + vBooking.getGroupId(), e);
+ return false;
+ }
+ }
+
+ public boolean addToRoom(ViteroBooking booking, Identity identity, GroupRole role)
+ throws VmsNotAvailableException {
+ try {
+ int userId = getVmsUserId(identity, true);
+ if(userId < 0) {
+ return false;
+ }
+
+ GroupServiceStub groupWs = getGroupWebService();
+ GroupServiceStub.AddUserToGroupRequest addRequest = new GroupServiceStub.AddUserToGroupRequest();
+ GroupServiceStub.Groupiduserid groupuserId = new GroupServiceStub.Groupiduserid();
+ groupuserId.setGroupid(booking.getGroupId());
+ groupuserId.setUserid(userId);
+
+ addRequest.setAddUserToGroupRequest(groupuserId);
+ groupWs.addUserToGroup(addRequest);
+
+ if(role != null) {
+ groupWs = getGroupWebService();
+ GroupServiceStub.ChangeGroupRoleRequest roleRequest = new GroupServiceStub.ChangeGroupRoleRequest();
+ roleRequest.setGroupid(booking.getGroupId());
+ roleRequest.setUserid(userId);
+ roleRequest.setRole(role.getVmsValue());
+ groupWs.changeGroupRole(roleRequest);
+ }
+
+ return true;
+ } catch(AxisFault f) {
+ int code = handleAxisFault(f);
+ switch(code) {
+ case 53: logError("The user doesn Ìt exist!", f); break;
+ case 103: logError("The user is not attached to the customer (to which this group belongs)", f); break;
+ case 151: logError("The group doesn Ìt exist", f); break;
+ case 303: logError("An id <= 0", f); break;
+ default: logAxisError("Cannot add an user to a group", f);
+ }
+ return false;
+ } catch (RemoteException e) {
+ logError("Cannot add an user to a group", e);
+ return false;
+ }
+ }
+
+ public boolean removeFromRoom(ViteroBooking booking, Identity identity)
+ throws VmsNotAvailableException {
+ int userId = getVmsUserId(identity, true);
+ if(userId < 0) {
+ return true;//nothing to remove
+ }
+ return removeFromRoom(booking, userId);
+ }
+
+ public boolean removeFromRoom(ViteroBooking booking, int userId)
+ throws VmsNotAvailableException {
+ try {
+
+ GroupServiceStub groupWs = getGroupWebService();
+ GroupServiceStub.RemoveUserFromGroupRequest removeRequest = new GroupServiceStub.RemoveUserFromGroupRequest();
+ GroupServiceStub.Groupiduserid groupuserId = new GroupServiceStub.Groupiduserid();
+ groupuserId.setGroupid(booking.getGroupId());
+ groupuserId.setUserid(userId);
+ removeRequest.setRemoveUserFromGroupRequest(groupuserId);
+ groupWs.removeUserFromGroup(removeRequest);
+ return true;
+ } catch(AxisFault f) {
+ int code = handleAxisFault(f);
+ switch(code) {
+ case 53: logError("The user doesn Ìt exist!", f); break;
+ case 151: logError("The group doesn Ìt exist", f); break;
+ case 303: logError("An id <= 0", f); break;
+ default: logAxisError("Cannot remove an user from a group", f);
+ }
+ return false;
+ } catch (RemoteException e) {
+ logError("Cannot remove an user from a group", e);
+ return false;
+ }
+ }
+
+ public ViteroBooking createBooking(String resourceName)
+ throws VmsNotAvailableException {
+ ViteroBooking booking = new ViteroBooking();
+
+ booking.setBookingId(-1);
+ booking.setGroupId(-1);
+ booking.setResourceName(resourceName);
+
+ Calendar cal = Calendar.getInstance();
+ int minute = cal.get(Calendar.MINUTE);
+ if(minute < 10) {
+ cal.set(Calendar.MINUTE, 15);
+ } else if (minute < 25) {
+ cal.set(Calendar.MINUTE, 30);
+ } else if (minute < 40) {
+ cal.set(Calendar.MINUTE, 45);
+ } else {
+ cal.add(Calendar.HOUR, 1);
+ cal.set(Calendar.MINUTE, 0);
+ }
+
+ cal.set(Calendar.SECOND, 0);
+ cal.set(Calendar.MILLISECOND, 0);
+
+ booking.setStart(cal.getTime());
+ booking.setStartBuffer(0);
+ cal.add(Calendar.HOUR, 1);
+ booking.setEnd(cal.getTime());
+ booking.setEndBuffer(0);
+
+ List<Integer> roomSizes = getLicencedRoomSizes();
+ if(!roomSizes.isEmpty()) {
+ booking.setRoomSize(roomSizes.get(0));
+ }
+ return booking;
+ }
+
+ public boolean createBooking(BusinessGroup group, OLATResourceable ores, ViteroBooking vBooking)
+ throws VmsNotAvailableException {
+ Bookingtype booking = getBookingById(vBooking.getBookingId());
+ if(booking != null) {
+ logInfo("Booking already exists: " + vBooking.getBookingId());
+ return true;
+ }
+
+ try {
+ //a group per meeting
+ int groupId = createGroup();
+ if(groupId < 0) {
+ return false;
+ }
+ vBooking.setGroupId(groupId);
+
+ //create the meeting with the new group
+ BookingServiceStub bookingWs = getBookingWebService();
+ BookingServiceStub.CreateBookingRequest createRequest = new BookingServiceStub.CreateBookingRequest();
+ BookingServiceStub.Newbookingtype newBooking = new BookingServiceStub.Newbookingtype();
+ //mandatory
+ newBooking.setStart(format(vBooking.getStart()));
+ newBooking.setEnd(format(vBooking.getEnd()));
+ newBooking.setStartbuffer(vBooking.getStartBuffer());
+ newBooking.setEndbuffer(vBooking.getEndBuffer());
+ newBooking.setGroupid(groupId);
+ newBooking.setRoomsize(vBooking.getRoomSize());
+
+ //optional
+ /*
+ newBooking.setIgnorefaults(false);
+ newBooking.setCafe(false);
+ newBooking.setCapture(false);
+ //phone
+ BookingServiceStub.Phonetype phone = new BookingServiceStub.Phonetype();
+ phone.setDialout(false);
+ phone.setPhoneconference(false);
+ phone.setShowdialogue(false);
+ newBooking.setPhone(phone);
+
+ newBooking.setPcstateokrequired(false);
+ newBooking.setRepetitionpattern("once");
+ newBooking.setRepetitionenddate("");
+ */
+ newBooking.setTimezone(viteroModule.getTimeZoneId());
+
+ createRequest.setBooking(newBooking);
+
+ BookingServiceStub.CreateBookingResponse response = bookingWs.createBooking(createRequest);
+ boolean bookingCollision = response.getBookingcollision();
+ boolean moduleCollision = response.getModulecollision();
+ int bookingId = response.getBookingid();
+
+ if(!bookingCollision && !moduleCollision) {
+ vBooking.setBookingId(bookingId);
+ getOrCreateProperty(group, ores, vBooking);
+ return true;
+ }
+ return false;
+ } catch(AxisFault f) {
+ int code = handleAxisFault(f);
+ switch(code) {
+ case 304: logError("Invalid time zone!", f); break;
+ case 501: logError("Booking collision!", f); break;
+ case 502: logError("Invalid module selection!", f); break;
+ case 505: logError("Booking in the past!", f); break;
+ case 703: logError("License/customer expired!", f); break;
+ default: logAxisError("Cannot create a booking.", f);
+ }
+ return false;
+ } catch (RemoteException e) {
+ logError("Cannot create a booking.", e);
+ return false;
+ }
+ }
+
+ /**
+ * There is not update on vms. We can only update some OLAT specific options.
+ * @param group
+ * @param ores
+ * @param vBooking
+ * @return
+ * @throws VmsNotAvailableException
+ */
+ public ViteroBooking updateBooking(BusinessGroup group, OLATResourceable ores, ViteroBooking vBooking)
+ throws VmsNotAvailableException {
+ Bookingtype bookingType = getBookingById(vBooking.getBookingId());
+ if(bookingType == null) {
+ logInfo("Booking doesn't exist: " + vBooking.getBookingId());
+ return null;
+ }
+
+ Booking booking = bookingType.getBooking();
+ //set the vms values
+ update(vBooking, booking);
+ //update the property
+ updateProperty(group, ores, vBooking);
+ return vBooking;
+ }
+
+ public boolean deleteBooking(ViteroBooking vBooking)
+ throws VmsNotAvailableException {
+ try {
+ BookingServiceStub bookingWs = getBookingWebService();
+ BookingServiceStub.DeleteBookingRequest deleteRequest = new BookingServiceStub.DeleteBookingRequest();
+ deleteRequest.setBookingid(vBooking.getBookingId());
+
+ BookingServiceStub.DeleteBookingResponse response = bookingWs.deleteBooking(deleteRequest);
+ BigInteger state = response.getDeletestate();
+ deleteGroup(vBooking);
+ deleteProperty(vBooking);
+ return state != null;
+ } catch(AxisFault f) {
+ int code = handleAxisFault(f);
+ switch(code) {
+ case 506:
+ case 509: {
+ deleteGroup(vBooking);
+ deleteProperty(vBooking);
+ return true;//ok, vms deleted, group deleted...
+ }
+ default: {
+ logAxisError("Cannot delete a booking.", f);
+ }
+ }
+ return false;
+ } catch (RemoteException e) {
+ logError("Cannot delete a booking.", e);
+ return false;
+ }
+ }
+
+ public void deleteAll(BusinessGroup group, OLATResourceable ores) {
+ try {
+ List<Property> properties = propertyManager.listProperties(null, group, ores, VMS_CATEGORY, null);
+ for(Property property:properties) {
+ String bookingStr = property.getTextValue();
+ ViteroBooking booking = deserializeViteroBooking(bookingStr);
+ deleteBooking(booking);
+ }
+ } catch (VmsNotAvailableException e) {
+ logError("", e);
+ markAsZombie(group, ores);
+ }
+ }
+
+ private final void markAsZombie(BusinessGroup group, OLATResourceable ores) {
+ List<Property> properties = propertyManager.listProperties(null, group, ores, VMS_CATEGORY, null);
+ for(Property property:properties) {
+ property.setName(VMS_CATEGORY_ZOMBIE);
+ propertyManager.updateProperty(property);
+ }
+ }
+
+ public void slayZombies() {
+ List<Property> properties = propertyManager.listProperties(null, null, null, VMS_CATEGORY_ZOMBIE, null);
+ for(Property property:properties) {
+ try {
+ String bookingStr = property.getTextValue();
+ ViteroBooking booking = deserializeViteroBooking(bookingStr);
+ deleteBooking(booking);
+ } catch (VmsNotAvailableException e) {
+ //try later
+ logDebug("Cannot clean-up vitero room, vms not available");
+ } catch (Exception e) {
+ logError("", e);
+ }
+ }
+ }
+
+ public List<ViteroBooking> getBookingInFutures(Identity identity)
+ throws VmsNotAvailableException {
+ int userId = getVmsUserId(identity, false);
+ if(userId > 0) {
+ Booking[] bookings = getBookingInFutureByCustomerId(userId);
+ return convert(bookings);
+ }
+ return Collections.emptyList();
+ }
+
+ /**
+ * Return the
+ * @param group The group (optional)
+ * @param ores The OLAT resourceable (of the course) (optional)
+ * @return
+ */
+ public List<ViteroBooking> getBookings(BusinessGroup group, OLATResourceable ores) {
+ List<Property> properties = propertyManager.listProperties(null, group, ores, VMS_CATEGORY, null);
+ List<ViteroBooking> bookings = new ArrayList<ViteroBooking>();
+ for(Property property:properties) {
+ String bookingStr = property.getTextValue();
+ ViteroBooking booking = deserializeViteroBooking(bookingStr);
+ booking.setProperty(property);
+ bookings.add(booking);
+ }
+ return bookings;
+ }
+
+ protected Booking[] getBookingInFutureByCustomerId(int userId)
+ throws VmsNotAvailableException {
+ try {
+ BookingServiceStub bookingWs = getBookingWebService();
+ BookingServiceStub.GetBookingListByUserInFutureRequest request = new BookingServiceStub.GetBookingListByUserInFutureRequest();
+ request.setUserid(userId);
+ request.setTimezone(viteroModule.getTimeZoneId());
+
+ BookingServiceStub.GetBookingListByUserInFutureResponse response = bookingWs.getBookingListByUserInFuture(request);
+ Bookinglist bookingList = response.getGetBookingListByUserInFutureResponse();
+
+ return bookingList.getBooking();
+ } catch(AxisFault f) {
+ int code = handleAxisFault(f);
+ switch(code) {
+ case 53: logError("The user does not exist!", f); break;
+ case 303: logError("ids <= 0!", f); break;
+ case 304: logError("Invalid time zone!", f); break;
+ default: logAxisError("Cannot get booking in future for custom: " + userId, f);
+ }
+ return null;
+ } catch (RemoteException e) {
+ logError("Cannot get booking in future for custom: " + userId, e);
+ return null;
+ }
+ }
+
+ protected Bookingtype getBookingById(int id)
+ throws VmsNotAvailableException {
+ if(id < 0) return null;
+
+ try {
+ BookingServiceStub bookingWs = getBookingWebService();
+ BookingServiceStub.GetBookingByIdRequest bookingByIdRequest = new BookingServiceStub.GetBookingByIdRequest();
+ BookingServiceStub.Bookingid bookingId = new BookingServiceStub.Bookingid();
+ bookingId.setBookingid(id);
+ bookingByIdRequest.setGetBookingByIdRequest(bookingId);
+ BookingServiceStub.GetBookingByIdResponse response = bookingWs.getBookingById(bookingByIdRequest);
+ Bookingtype booking = response.getGetBookingByIdResponse();
+ return booking;
+ } catch(AxisFault f) {
+ int code = handleAxisFault(f);
+ switch(code) {
+ case 303: logError("ids <= 0", f); break;
+ case 506: logError("The booking does not exist", f); break;
+ default: logAxisError("Cannot get booking by id: " + id, f);
+ }
+ return null;
+ } catch (RemoteException e) {
+ logError("Cannot get booking by id: " + id, e);
+ return null;
+ }
+ }
+
+ public boolean checkConnection() {
+ try {
+ return checkConnection(viteroModule.getVmsURI().toString(), viteroModule.getAdminLogin(),
+ viteroModule.getAdminPassword(), viteroModule.getCustomerId());
+ } catch (VmsNotAvailableException e) {
+ return false;
+ }
+ }
+
+ public boolean checkConnection(String url, String login, String password, int customerId)
+ throws VmsNotAvailableException {
+ try {
+ CustomerServiceStub customerWs = new CustomerServiceStub(url + "/services");
+ SecurityHeader.addAdminSecurityHeader(login, password, customerWs);
+
+ CustomerServiceStub.GetCustomerRequest cRequest = new CustomerServiceStub.GetCustomerRequest();
+ CustomerServiceStub.Customerid id = new CustomerServiceStub.Customerid();
+ id.setCustomerid(customerId);
+ cRequest.setGetCustomerRequest(id);
+ CustomerServiceStub.GetCustomerResponse response = customerWs.getCustomer(cRequest);
+ if(response == null) return false;
+ CustomerServiceStub.Customer customer = response.getGetCustomerResponse();
+ if(customer == null) return false;
+ CustomerServiceStub.Customertype customerType = customer.getCustomer();
+ if(customerType == null) return false;
+ return customerType.getId() > -1;
+ } catch(AxisFault f) {
+ handleAxisFault(f);
+ return false;
+ } catch (Exception e) {
+ logWarn("Error checking connection", e);
+ return false;
+ }
+ }
+
+ //Utilities
+ private final int handleAxisFault(final AxisFault f)
+ throws VmsNotAvailableException {
+ if(f.getFaultDetailElement() != null) {
+ String msg = f.getFaultDetailElement().toString();
+ int beginIndex = msg.indexOf("<errorCode>");
+ int endIndex = msg.indexOf("</errorCode>");
+ String errorCode = msg.substring(beginIndex + "<errorCode>".length(), endIndex);
+ int code = Integer.parseInt(errorCode);
+ return code;
+ } else if (f.getCause() instanceof ConnectTimeoutException) {
+ throw new VmsNotAvailableException(f);
+ }
+ return -1;
+ }
+
+ private void logAxisError(String message, AxisFault f) {
+ StringBuilder sb = new StringBuilder();
+ if(StringHelper.containsNonWhitespace(message)) {
+ sb.append(message);
+ }
+
+ if(f.getFaultDetailElement() != null) {
+ if(sb.length() > 0) sb.append(" -> ");
+ sb.append(f.getFaultDetailElement().toString());
+ }
+
+ if(StringHelper.containsNonWhitespace(f.getMessage())) {
+ if(sb.length() > 0) sb.append(" -> ");
+ sb.append(f.getMessage());
+ }
+
+ logError(sb.toString(), f);
+ }
+
+ private final List<ViteroBooking> convert(Booking[] bookings) {
+ List<ViteroBooking> viteroBookings = new ArrayList<ViteroBooking>();
+
+ if(bookings != null && bookings.length > 0) {
+ for(Booking b:bookings) {
+ viteroBookings.add(convert(b));
+ }
+ }
+
+ return viteroBookings;
+ }
+
+ private final ViteroBooking convert(Booking booking) {
+ ViteroBooking vb = new ViteroBooking();
+ return update(vb, booking);
+ }
+
+ private final ViteroBooking update(ViteroBooking vb, Booking booking) {
+ vb.setBookingId(booking.getBookingid());
+ vb.setGroupId(booking.getGroupid());
+ vb.setRoomSize(booking.getRoomsize());
+ vb.setStart(parse(booking.getStart()));
+ vb.setStartBuffer(booking.getEndbuffer());
+ vb.setEnd(parse(booking.getEnd()));
+ vb.setEndBuffer(booking.getStartbuffer());
+ return vb;
+ }
+
+ private final ViteroGroup convert(Completegrouptype groupType) {
+ ViteroGroup vg = new ViteroGroup();
+ vg.setGroupId(groupType.getId());
+ vg.setName(groupType.getName());
+ int numOfParticipants = groupType.getParticipant() == null ? 0 : groupType.getParticipant().length;
+ vg.setNumOfParticipants(numOfParticipants);
+ return vg;
+ }
+
+ private final List<ViteroCustomer> convert(CustomerServiceStub.Customertype[] customerTypes) {
+ List<ViteroCustomer> customers = new ArrayList<ViteroCustomer>();
+ if(customerTypes != null) {
+ for(CustomerServiceStub.Customertype customerType: customerTypes) {
+ customers.add(convert(customerType));
+ }
+ }
+ return customers;
+ }
+
+ private final ViteroCustomer convert(CustomerServiceStub.Customertype customerType) {
+ ViteroCustomer customer = new ViteroCustomer();
+ customer.setCustomerId(customerType.getId());
+ customer.setName(customerType.getDisplayname());
+ return customer;
+ }
+
+ private final List<ViteroUser> convert(Usertype[] userTypes) {
+ List<ViteroUser> vUsers = new ArrayList<ViteroUser>();
+ if(userTypes != null) {
+ for(Usertype userType:userTypes) {
+ vUsers.add(convert(userType));
+ }
+ }
+ return vUsers;
+ }
+
+ private final ViteroUser convert(Usertype userType) {
+ ViteroUser vu = new ViteroUser();
+ vu.setUserId(userType.getId());
+ vu.setFirstName(userType.getFirstname());
+ vu.setLastName(userType.getSurname());
+ vu.setEmail(userType.getEmail());
+ return vu;
+ }
+
+ //Properties
+ private final Property getProperty(final BusinessGroup group, final OLATResourceable courseResource, final ViteroBooking booking) {
+ String propertyName = Integer.toString(booking.getBookingId());
+ return propertyManager.findProperty(null, group, courseResource, VMS_CATEGORY, propertyName);
+ }
+
+ private final Property getOrCreateProperty(final BusinessGroup group, final OLATResourceable courseResource, final ViteroBooking booking) {
+ Property property = getProperty(group, courseResource, booking);
+ if(property == null) {
+ property = createProperty(group, courseResource, booking);
+ propertyManager.saveProperty(property);
+ }
+ return property;
+ }
+
+ private final Property updateProperty(final BusinessGroup group, final OLATResourceable courseResource, ViteroBooking booking) {
+ Property property = getProperty(group, courseResource, booking);
+ if(property == null) {
+ property = createProperty(group, courseResource, booking);
+ propertyManager.saveProperty(property);
+ } else {
+ String serialized = serializeViteroBooking(booking);
+ property.setTextValue(serialized);
+ propertyManager.updateProperty(property);
+ }
+ return property;
+ }
+
+ private final Property createProperty(final BusinessGroup group, final OLATResourceable courseResource, ViteroBooking booking) {
+ String serialized = serializeViteroBooking(booking);
+ String bookingId = Integer.toString(booking.getBookingId());
+ Long groupId = new Long(booking.getGroupId());
+ return propertyManager.createPropertyInstance(null, group, courseResource, VMS_CATEGORY, bookingId, null, groupId, null, serialized);
+ }
+
+ private final void deleteProperty(ViteroBooking vBooking) {
+ String bookingId = Integer.toString(vBooking.getBookingId());
+ propertyManager.deleteProperties(null, null, null, VMS_CATEGORY, bookingId);
+ }
+
+ private final String serializeViteroBooking(ViteroBooking booking) {
+ StringWriter writer = new StringWriter();
+ xStream.marshal(booking, new CompactWriter(writer));
+ writer.flush();
+ return writer.toString();
+ }
+
+ private final ViteroBooking deserializeViteroBooking(String booking) {
+ return (ViteroBooking)xStream.fromXML(booking);
+ }
+
+ //Factories for service stubs
+ private final BookingServiceStub getBookingWebService()
+ throws AxisFault {
+ BookingServiceStub bookingWs = new BookingServiceStub(getVmsEndPoint());
+ SecurityHeader.addAdminSecurityHeader(viteroModule, bookingWs);
+ return bookingWs;
+ }
+
+ private final CustomerServiceStub getCustomerWebService()
+ throws AxisFault {
+ CustomerServiceStub customerWs = new CustomerServiceStub(getVmsEndPoint());
+ SecurityHeader.addAdminSecurityHeader(viteroModule, customerWs);
+ return customerWs;
+ }
+
+ private final LicenceServiceStub getLicenceWebService()
+ throws AxisFault {
+ LicenceServiceStub licenceWs = new LicenceServiceStub(getVmsEndPoint());
+ SecurityHeader.addAdminSecurityHeader(viteroModule, licenceWs);
+ return licenceWs;
+ }
+
+ private final GroupServiceStub getGroupWebService()
+ throws AxisFault {
+ GroupServiceStub groupWs = new GroupServiceStub(getVmsEndPoint());
+ SecurityHeader.addAdminSecurityHeader(viteroModule, groupWs);
+ return groupWs;
+ }
+
+ private final UserServiceStub getUserWebService()
+ throws AxisFault {
+ UserServiceStub userWs = new UserServiceStub(getVmsEndPoint());
+ SecurityHeader.addAdminSecurityHeader(viteroModule, userWs);
+ return userWs;
+ }
+
+ private final MtomServiceStub getMtomWebService()
+ throws AxisFault {
+ MtomServiceStub mtomWs = new MtomServiceStub(getVmsEndPoint());
+ SecurityHeader.addAdminSecurityHeader(viteroModule, mtomWs);
+ return mtomWs;
+ }
+
+ private final SessionCodeServiceStub getSessionCodeWebService()
+ throws AxisFault {
+ SessionCodeServiceStub sessionCodeWs = new SessionCodeServiceStub(getVmsEndPoint());
+ SecurityHeader.addAdminSecurityHeader(viteroModule, sessionCodeWs);
+ return sessionCodeWs;
+ }
+
+ private final String getVmsEndPoint() {
+ UriBuilder builder = UriBuilder.fromUri(viteroModule.getVmsURI());
+ builder.path("services");
+ return builder.build().toString();
+ }
+
+ private final String getStartPoint(String sessionCode) {
+ UriBuilder builder = UriBuilder.fromUri(viteroModule.getVmsURI() );
+ builder.path("start.htm");
+ if(StringHelper.containsNonWhitespace(sessionCode)) {
+ builder.queryParam("sessionCode", sessionCode);
+ }
+ return builder.build().toString();
+ }
+
+ private final synchronized String format(Date date) {
+ return dateFormat.format(date);
+ }
+
+ private final synchronized Date parse(String dateString) {
+ try {
+ return dateFormat.parse(dateString);
+ } catch (ParseException e) {
+ logError("Cannot parse a date: " + dateString, e);
+ return null;
+ }
+ }
+}
diff --git a/src/main/java/com/frentix/olat/vitero/manager/ViteroTestMain.java b/src/main/java/com/frentix/olat/vitero/manager/ViteroTestMain.java
new file mode 100644
index 0000000000000000000000000000000000000000..d5c9fc69420a88ed0a0356ecdc473ce208b76ac8
--- /dev/null
+++ b/src/main/java/com/frentix/olat/vitero/manager/ViteroTestMain.java
@@ -0,0 +1,83 @@
+/**
+ * OLAT - Online Learning and Training<br>
+ * http://www.olat.org
+ * <p>
+ * Licensed under the Apache License, Version 2.0 (the "License"); <br>
+ * you may not use this file except in compliance with the License.<br>
+ * You may obtain a copy of the License at
+ * <p>
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * <p>
+ * Unless required by applicable law or agreed to in writing,<br>
+ * software distributed under the License is distributed on an "AS IS" BASIS, <br>
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. <br>
+ * See the License for the specific language governing permissions and <br>
+ * limitations under the License.
+ * <p>
+ * Copyright (c) frentix GmbH<br>
+ * http://www.frentix.com<br>
+ * <p>
+ */
+package com.frentix.olat.vitero.manager;
+
+import com.frentix.olat.vitero.ViteroModule;
+import com.frentix.olat.vitero.manager.stubs.BookingServiceStub.Bookingtype;
+
+/**
+ *
+ * Description:<br>
+ *
+ * <P>
+ * Initial Date: 6 oct. 2011 <br>
+ *
+ * @author srosse, stephane.rosse@frentix.com, http://www.frentix.com
+ */
+public class ViteroTestMain {
+
+ private final ViteroModule module;
+ private final ViteroManager manager;
+
+ public ViteroTestMain() {
+ module = new ViteroModule(null);
+ module.setAdminLogin("admin");
+ module.setAdminPassword("007");
+ module.setProtocol("http");
+ module.setBaseUrl("192.168.1.54");
+ module.setPort(8080);
+ module.setContextPath("vitero");
+
+ manager = new ViteroManager();
+ manager.setViteroModule(module);
+ }
+
+ public static final void main(String[] args) {
+ ViteroTestMain main = new ViteroTestMain();
+
+ //booking by id
+ //new ViteroTestMain().testGetBookingById(3);
+
+ //licence
+ main.testGetLicense();
+ }
+
+ public void testGetBookingById(int id) {
+ try {
+ Bookingtype type = manager.getBookingById(id);
+ System.out.println(type.getBooking().getBookingid());
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ }
+
+ public void testGetLicense() {
+
+ try {
+ manager.getLicencedRoomSizes();
+ System.out.println("Licence");
+ } catch (VmsNotAvailableException e) {
+ e.printStackTrace();
+ }
+ }
+
+
+}
diff --git a/src/main/java/com/frentix/olat/vitero/manager/ViteroZombieSlayerJob.java b/src/main/java/com/frentix/olat/vitero/manager/ViteroZombieSlayerJob.java
new file mode 100644
index 0000000000000000000000000000000000000000..991ea4d999c3d50817e04a18f9b3bf0b60f242ff
--- /dev/null
+++ b/src/main/java/com/frentix/olat/vitero/manager/ViteroZombieSlayerJob.java
@@ -0,0 +1,33 @@
+package com.frentix.olat.vitero.manager;
+
+import org.olat.core.CoreSpringFactory;
+import org.olat.core.commons.scheduler.JobWithDB;
+import org.quartz.JobExecutionContext;
+
+import com.frentix.olat.vitero.ViteroModule;
+
+/**
+ *
+ * Description:<br>
+ * Quartz job which try to slay the meeting zombies from deleted
+ * resources/groups. Make is slayer's job only if the module
+ * is enabled and a connection with the vms is possible.
+ *
+ * <P>
+ * Initial Date: 12 oct. 2011 <br>
+ *
+ * @author srosse, stephane.rosse@frentix.com, http://www.frentix.com
+ */
+public class ViteroZombieSlayerJob extends JobWithDB {
+
+ @Override
+ public void executeWithDB(JobExecutionContext arg0) {
+ ViteroModule module = (ViteroModule)CoreSpringFactory.getBean("viteroModule");
+ if(!module.isEnabled()) return;
+
+ ViteroManager viteroManager = (ViteroManager)CoreSpringFactory.getBean("viteroManager");
+ if(viteroManager.checkConnection()) {
+ viteroManager.slayZombies();
+ }
+ }
+}
diff --git a/src/main/java/com/frentix/olat/vitero/manager/VmsNotAvailableException.java b/src/main/java/com/frentix/olat/vitero/manager/VmsNotAvailableException.java
new file mode 100644
index 0000000000000000000000000000000000000000..c5a2f70215a5f99014657f6a3156d1522dcf28f5
--- /dev/null
+++ b/src/main/java/com/frentix/olat/vitero/manager/VmsNotAvailableException.java
@@ -0,0 +1,54 @@
+/**
+ * OLAT - Online Learning and Training<br>
+ * http://www.olat.org
+ * <p>
+ * Licensed under the Apache License, Version 2.0 (the "License"); <br>
+ * you may not use this file except in compliance with the License.<br>
+ * You may obtain a copy of the License at
+ * <p>
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * <p>
+ * Unless required by applicable law or agreed to in writing,<br>
+ * software distributed under the License is distributed on an "AS IS" BASIS, <br>
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. <br>
+ * See the License for the specific language governing permissions and <br>
+ * limitations under the License.
+ * <p>
+ * Copyright (c) frentix GmbH<br>
+ * http://www.frentix.com<br>
+ * <p>
+ */
+package com.frentix.olat.vitero.manager;
+
+/**
+ *
+ * Description:<br>
+ *
+ * <P>
+ * Initial Date: 12 oct. 2011 <br>
+ *
+ * @author srosse, stephane.rosse@frentix.com, http://www.frentix.com
+ */
+public class VmsNotAvailableException extends Exception {
+
+ private static final long serialVersionUID = 3260533359384969602L;
+
+ public static final String I18N_KEY = "error.vmsNotAvailable";
+
+ public VmsNotAvailableException() {
+ //
+ }
+
+ public VmsNotAvailableException(String message) {
+ super(message);
+ }
+
+ public VmsNotAvailableException(String message, Exception cause) {
+ super(message, cause);
+ }
+
+ public VmsNotAvailableException(Exception cause) {
+ super(cause);
+ }
+
+}
diff --git a/src/main/java/com/frentix/olat/vitero/manager/stubs/BookingServiceCallbackHandler.java b/src/main/java/com/frentix/olat/vitero/manager/stubs/BookingServiceCallbackHandler.java
new file mode 100644
index 0000000000000000000000000000000000000000..68ea61d637bd28b1fd4546626a2584942667ba7b
--- /dev/null
+++ b/src/main/java/com/frentix/olat/vitero/manager/stubs/BookingServiceCallbackHandler.java
@@ -0,0 +1,212 @@
+
+/**
+ * BookingServiceCallbackHandler.java
+ *
+ * This file was auto-generated from WSDL
+ * by the Apache Axis2 version: 1.4.1 Built on : Aug 13, 2008 (05:03:35 LKT)
+ */
+
+ package com.frentix.olat.vitero.manager.stubs;
+
+ /**
+ * BookingServiceCallbackHandler Callback class, Users can extend this class and implement
+ * their own receiveResult and receiveError methods.
+ */
+ public abstract class BookingServiceCallbackHandler{
+
+
+
+ protected Object clientData;
+
+ /**
+ * User can pass in any object that needs to be accessed once the NonBlocking
+ * Web service call is finished and appropriate method of this CallBack is called.
+ * @param clientData Object mechanism by which the user can pass in user data
+ * that will be avilable at the time this callback is called.
+ */
+ public BookingServiceCallbackHandler(Object clientData){
+ this.clientData = clientData;
+ }
+
+ /**
+ * Please use this constructor if you don't want to set any clientData
+ */
+ public BookingServiceCallbackHandler(){
+ this.clientData = null;
+ }
+
+ /**
+ * Get the client data
+ */
+
+ public Object getClientData() {
+ return clientData;
+ }
+
+
+ // No methods generated for meps other than in-out
+
+ /**
+ * auto generated Axis2 call back method for getBookingListByGroupInFuture method
+ * override this method for handling normal response from getBookingListByGroupInFuture operation
+ */
+ public void receiveResultgetBookingListByGroupInFuture(
+ com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingListByGroupInFutureResponse result
+ ) {
+ }
+
+ /**
+ * auto generated Axis2 Error handler
+ * override this method for handling error response from getBookingListByGroupInFuture operation
+ */
+ public void receiveErrorgetBookingListByGroupInFuture(java.lang.Exception e) {
+ }
+
+ /**
+ * auto generated Axis2 call back method for createBooking method
+ * override this method for handling normal response from createBooking operation
+ */
+ public void receiveResultcreateBooking(
+ com.frentix.olat.vitero.manager.stubs.BookingServiceStub.CreateBookingResponse result
+ ) {
+ }
+
+ /**
+ * auto generated Axis2 Error handler
+ * override this method for handling error response from createBooking operation
+ */
+ public void receiveErrorcreateBooking(java.lang.Exception e) {
+ }
+
+ /**
+ * auto generated Axis2 call back method for getBookingListByDate method
+ * override this method for handling normal response from getBookingListByDate operation
+ */
+ public void receiveResultgetBookingListByDate(
+ com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingListByDateResponse result
+ ) {
+ }
+
+ /**
+ * auto generated Axis2 Error handler
+ * override this method for handling error response from getBookingListByDate operation
+ */
+ public void receiveErrorgetBookingListByDate(java.lang.Exception e) {
+ }
+
+ /**
+ * auto generated Axis2 call back method for getBookingListByUserAndDate method
+ * override this method for handling normal response from getBookingListByUserAndDate operation
+ */
+ public void receiveResultgetBookingListByUserAndDate(
+ com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingListByUserAndDateResponse result
+ ) {
+ }
+
+ /**
+ * auto generated Axis2 Error handler
+ * override this method for handling error response from getBookingListByUserAndDate operation
+ */
+ public void receiveErrorgetBookingListByUserAndDate(java.lang.Exception e) {
+ }
+
+ /**
+ * auto generated Axis2 call back method for getBookingListByUserInFuture method
+ * override this method for handling normal response from getBookingListByUserInFuture operation
+ */
+ public void receiveResultgetBookingListByUserInFuture(
+ com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingListByUserInFutureResponse result
+ ) {
+ }
+
+ /**
+ * auto generated Axis2 Error handler
+ * override this method for handling error response from getBookingListByUserInFuture operation
+ */
+ public void receiveErrorgetBookingListByUserInFuture(java.lang.Exception e) {
+ }
+
+ /**
+ * auto generated Axis2 call back method for getBookingTimeById method
+ * override this method for handling normal response from getBookingTimeById operation
+ */
+ public void receiveResultgetBookingTimeById(
+ com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingTimeByIdResponse result
+ ) {
+ }
+
+ /**
+ * auto generated Axis2 Error handler
+ * override this method for handling error response from getBookingTimeById operation
+ */
+ public void receiveErrorgetBookingTimeById(java.lang.Exception e) {
+ }
+
+ /**
+ * auto generated Axis2 call back method for getBookingById method
+ * override this method for handling normal response from getBookingById operation
+ */
+ public void receiveResultgetBookingById(
+ com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingByIdResponse result
+ ) {
+ }
+
+ /**
+ * auto generated Axis2 Error handler
+ * override this method for handling error response from getBookingById operation
+ */
+ public void receiveErrorgetBookingById(java.lang.Exception e) {
+ }
+
+ /**
+ * auto generated Axis2 call back method for deleteBooking method
+ * override this method for handling normal response from deleteBooking operation
+ */
+ public void receiveResultdeleteBooking(
+ com.frentix.olat.vitero.manager.stubs.BookingServiceStub.DeleteBookingResponse result
+ ) {
+ }
+
+ /**
+ * auto generated Axis2 Error handler
+ * override this method for handling error response from deleteBooking operation
+ */
+ public void receiveErrordeleteBooking(java.lang.Exception e) {
+ }
+
+ /**
+ * auto generated Axis2 call back method for getBookingByBookingTimeId method
+ * override this method for handling normal response from getBookingByBookingTimeId operation
+ */
+ public void receiveResultgetBookingByBookingTimeId(
+ com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingByBookingTimeIdResponse result
+ ) {
+ }
+
+ /**
+ * auto generated Axis2 Error handler
+ * override this method for handling error response from getBookingByBookingTimeId operation
+ */
+ public void receiveErrorgetBookingByBookingTimeId(java.lang.Exception e) {
+ }
+
+ /**
+ * auto generated Axis2 call back method for getBookingListByGroupAndDate method
+ * override this method for handling normal response from getBookingListByGroupAndDate operation
+ */
+ public void receiveResultgetBookingListByGroupAndDate(
+ com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingListByGroupAndDateResponse result
+ ) {
+ }
+
+ /**
+ * auto generated Axis2 Error handler
+ * override this method for handling error response from getBookingListByGroupAndDate operation
+ */
+ public void receiveErrorgetBookingListByGroupAndDate(java.lang.Exception e) {
+ }
+
+
+
+ }
+
\ No newline at end of file
diff --git a/src/main/java/com/frentix/olat/vitero/manager/stubs/BookingServiceStub.java b/src/main/java/com/frentix/olat/vitero/manager/stubs/BookingServiceStub.java
new file mode 100644
index 0000000000000000000000000000000000000000..e3c247e69ec1a693fc609ad0b25bcb028e6f2e50
--- /dev/null
+++ b/src/main/java/com/frentix/olat/vitero/manager/stubs/BookingServiceStub.java
@@ -0,0 +1,23620 @@
+
+/**
+ * BookingServiceStub.java
+ *
+ * This file was auto-generated from WSDL
+ * by the Apache Axis2 version: 1.4.1 Built on : Aug 13, 2008 (05:03:35 LKT)
+ */
+ package com.frentix.olat.vitero.manager.stubs;
+
+
+
+ /*
+ * BookingServiceStub java implementation
+ */
+
+
+ public class BookingServiceStub extends org.apache.axis2.client.Stub
+ {
+ protected org.apache.axis2.description.AxisOperation[] _operations;
+
+ //hashmaps to keep the fault mapping
+ private java.util.HashMap faultExceptionNameMap = new java.util.HashMap();
+ private java.util.HashMap faultExceptionClassNameMap = new java.util.HashMap();
+ private java.util.HashMap faultMessageMap = new java.util.HashMap();
+
+ private static int counter = 0;
+
+ private static synchronized String getUniqueSuffix(){
+ // reset the counter if it is greater than 99999
+ if (counter > 99999){
+ counter = 0;
+ }
+ counter = counter + 1;
+ return Long.toString(System.currentTimeMillis()) + "_" + counter;
+ }
+
+
+ private void populateAxisService() throws org.apache.axis2.AxisFault {
+
+ //creating the Service with a unique name
+ _service = new org.apache.axis2.description.AxisService("BookingService" + getUniqueSuffix());
+ addAnonymousOperations();
+
+ //creating the operations
+ org.apache.axis2.description.AxisOperation __operation;
+
+ _operations = new org.apache.axis2.description.AxisOperation[11];
+
+ __operation = new org.apache.axis2.description.OutInAxisOperation();
+
+
+ __operation.setName(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking", "success"));
+ _service.addOperation(__operation);
+
+
+
+
+ _operations[0]=__operation;
+
+
+ __operation = new org.apache.axis2.description.OutInAxisOperation();
+
+
+ __operation.setName(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking", "getBookingListByGroupInFuture"));
+ _service.addOperation(__operation);
+
+
+
+
+ _operations[1]=__operation;
+
+
+ __operation = new org.apache.axis2.description.OutInAxisOperation();
+
+
+ __operation.setName(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking", "createBooking"));
+ _service.addOperation(__operation);
+
+
+
+
+ _operations[2]=__operation;
+
+
+ __operation = new org.apache.axis2.description.OutInAxisOperation();
+
+
+ __operation.setName(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking", "getBookingListByDate"));
+ _service.addOperation(__operation);
+
+
+
+
+ _operations[3]=__operation;
+
+
+ __operation = new org.apache.axis2.description.OutInAxisOperation();
+
+
+ __operation.setName(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking", "getBookingListByUserAndDate"));
+ _service.addOperation(__operation);
+
+
+
+
+ _operations[4]=__operation;
+
+
+ __operation = new org.apache.axis2.description.OutInAxisOperation();
+
+
+ __operation.setName(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking", "getBookingListByUserInFuture"));
+ _service.addOperation(__operation);
+
+
+
+
+ _operations[5]=__operation;
+
+
+ __operation = new org.apache.axis2.description.OutInAxisOperation();
+
+
+ __operation.setName(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking", "getBookingTimeById"));
+ _service.addOperation(__operation);
+
+
+
+
+ _operations[6]=__operation;
+
+
+ __operation = new org.apache.axis2.description.OutInAxisOperation();
+
+
+ __operation.setName(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking", "getBookingById"));
+ _service.addOperation(__operation);
+
+
+
+
+ _operations[7]=__operation;
+
+
+ __operation = new org.apache.axis2.description.OutInAxisOperation();
+
+
+ __operation.setName(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking", "deleteBooking"));
+ _service.addOperation(__operation);
+
+
+
+
+ _operations[8]=__operation;
+
+
+ __operation = new org.apache.axis2.description.OutInAxisOperation();
+
+
+ __operation.setName(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking", "getBookingByBookingTimeId"));
+ _service.addOperation(__operation);
+
+
+
+
+ _operations[9]=__operation;
+
+
+ __operation = new org.apache.axis2.description.OutInAxisOperation();
+
+
+ __operation.setName(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking", "getBookingListByGroupAndDate"));
+ _service.addOperation(__operation);
+
+
+
+
+ _operations[10]=__operation;
+
+
+ }
+
+ //populates the faults
+ private void populateFaults(){
+
+
+
+ }
+
+ /**
+ *Constructor that takes in a configContext
+ */
+
+ public BookingServiceStub(org.apache.axis2.context.ConfigurationContext configurationContext,
+ java.lang.String targetEndpoint)
+ throws org.apache.axis2.AxisFault {
+ this(configurationContext,targetEndpoint,false);
+ }
+
+
+ /**
+ * Constructor that takes in a configContext and useseperate listner
+ */
+ public BookingServiceStub(org.apache.axis2.context.ConfigurationContext configurationContext,
+ java.lang.String targetEndpoint, boolean useSeparateListener)
+ throws org.apache.axis2.AxisFault {
+ //To populate AxisService
+ populateAxisService();
+ populateFaults();
+
+ _serviceClient = new org.apache.axis2.client.ServiceClient(configurationContext,_service);
+
+
+ configurationContext = _serviceClient.getServiceContext().getConfigurationContext();
+
+ _serviceClient.getOptions().setTo(new org.apache.axis2.addressing.EndpointReference(
+ targetEndpoint));
+ _serviceClient.getOptions().setUseSeparateListener(useSeparateListener);
+
+
+ }
+
+ /**
+ * Default Constructor
+ */
+ public BookingServiceStub(org.apache.axis2.context.ConfigurationContext configurationContext) throws org.apache.axis2.AxisFault {
+
+ this(configurationContext,"http://192.168.1.54:8080/vitero/services/" );
+
+ }
+
+ /**
+ * Default Constructor
+ */
+ public BookingServiceStub() throws org.apache.axis2.AxisFault {
+
+ this("http://192.168.1.54:8080/vitero/services/" );
+
+ }
+
+ /**
+ * Constructor taking the target endpoint
+ */
+ public BookingServiceStub(java.lang.String targetEndpoint) throws org.apache.axis2.AxisFault {
+ this(null,targetEndpoint);
+ }
+
+
+
+
+ /**
+ * Auto generated method signature
+ *
+ * @see com.frentix.olat.vc.provider.vitero.stubs.BookingService#getBookingListByGroupInFuture
+ * @param getBookingListByGroupInFutureRequest1
+
+ */
+
+
+
+ public com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingListByGroupInFutureResponse getBookingListByGroupInFuture(
+
+ com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingListByGroupInFutureRequest getBookingListByGroupInFutureRequest1)
+
+
+ throws java.rmi.RemoteException
+
+ {
+ org.apache.axis2.context.MessageContext _messageContext = null;
+ try{
+ org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[1].getName());
+ _operationClient.getOptions().setAction("\"\"");
+ _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true);
+
+
+
+ addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&");
+
+
+ // create a message context
+ _messageContext = new org.apache.axis2.context.MessageContext();
+
+
+
+ // create SOAP envelope with that payload
+ org.apache.axiom.soap.SOAPEnvelope env = null;
+
+
+ env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()),
+ getBookingListByGroupInFutureRequest1,
+ optimizeContent(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking",
+ "getBookingListByGroupInFuture")));
+
+ //adding SOAP soap_headers
+ _serviceClient.addHeadersToEnvelope(env);
+ // set the message context with that soap envelope
+ _messageContext.setEnvelope(env);
+
+ // add the message contxt to the operation client
+ _operationClient.addMessageContext(_messageContext);
+
+ //execute the operation client
+ _operationClient.execute(true);
+
+
+ org.apache.axis2.context.MessageContext _returnMessageContext = _operationClient.getMessageContext(
+ org.apache.axis2.wsdl.WSDLConstants.MESSAGE_LABEL_IN_VALUE);
+ org.apache.axiom.soap.SOAPEnvelope _returnEnv = _returnMessageContext.getEnvelope();
+
+
+ java.lang.Object object = fromOM(
+ _returnEnv.getBody().getFirstElement() ,
+ com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingListByGroupInFutureResponse.class,
+ getEnvelopeNamespaces(_returnEnv));
+
+
+ return (com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingListByGroupInFutureResponse)object;
+
+ }catch(org.apache.axis2.AxisFault f){
+
+ org.apache.axiom.om.OMElement faultElt = f.getDetail();
+ if (faultElt!=null){
+ if (faultExceptionNameMap.containsKey(faultElt.getQName())){
+ //make the fault by reflection
+ try{
+ java.lang.String exceptionClassName = (java.lang.String)faultExceptionClassNameMap.get(faultElt.getQName());
+ java.lang.Class exceptionClass = java.lang.Class.forName(exceptionClassName);
+ java.lang.Exception ex=
+ (java.lang.Exception) exceptionClass.newInstance();
+ //message class
+ java.lang.String messageClassName = (java.lang.String)faultMessageMap.get(faultElt.getQName());
+ java.lang.Class messageClass = java.lang.Class.forName(messageClassName);
+ java.lang.Object messageObject = fromOM(faultElt,messageClass,null);
+ java.lang.reflect.Method m = exceptionClass.getMethod("setFaultMessage",
+ new java.lang.Class[]{messageClass});
+ m.invoke(ex,new java.lang.Object[]{messageObject});
+
+
+ throw new java.rmi.RemoteException(ex.getMessage(), ex);
+ }catch(java.lang.ClassCastException e){
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.ClassNotFoundException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ }catch (java.lang.NoSuchMethodException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.reflect.InvocationTargetException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.IllegalAccessException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.InstantiationException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ }
+ }else{
+ throw f;
+ }
+ }else{
+ throw f;
+ }
+ } finally {
+ _messageContext.getTransportOut().getSender().cleanup(_messageContext);
+ }
+ }
+
+ /**
+ * Auto generated method signature for Asynchronous Invocations
+ *
+ * @see com.frentix.olat.vc.provider.vitero.stubs.BookingService#startgetBookingListByGroupInFuture
+ * @param getBookingListByGroupInFutureRequest1
+
+ */
+ public void startgetBookingListByGroupInFuture(
+
+ com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingListByGroupInFutureRequest getBookingListByGroupInFutureRequest1,
+
+ final com.frentix.olat.vitero.manager.stubs.BookingServiceCallbackHandler callback)
+
+ throws java.rmi.RemoteException{
+
+ org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[1].getName());
+ _operationClient.getOptions().setAction("\"\"");
+ _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true);
+
+
+
+ addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&");
+
+
+
+ // create SOAP envelope with that payload
+ org.apache.axiom.soap.SOAPEnvelope env=null;
+ final org.apache.axis2.context.MessageContext _messageContext = new org.apache.axis2.context.MessageContext();
+
+
+ //Style is Doc.
+
+
+ env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()),
+ getBookingListByGroupInFutureRequest1,
+ optimizeContent(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking",
+ "getBookingListByGroupInFuture")));
+
+ // adding SOAP soap_headers
+ _serviceClient.addHeadersToEnvelope(env);
+ // create message context with that soap envelope
+ _messageContext.setEnvelope(env);
+
+ // add the message context to the operation client
+ _operationClient.addMessageContext(_messageContext);
+
+
+
+ _operationClient.setCallback(new org.apache.axis2.client.async.AxisCallback() {
+ public void onMessage(org.apache.axis2.context.MessageContext resultContext) {
+ try {
+ org.apache.axiom.soap.SOAPEnvelope resultEnv = resultContext.getEnvelope();
+
+ java.lang.Object object = fromOM(resultEnv.getBody().getFirstElement(),
+ com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingListByGroupInFutureResponse.class,
+ getEnvelopeNamespaces(resultEnv));
+ callback.receiveResultgetBookingListByGroupInFuture(
+ (com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingListByGroupInFutureResponse)object);
+
+ } catch (org.apache.axis2.AxisFault e) {
+ callback.receiveErrorgetBookingListByGroupInFuture(e);
+ }
+ }
+
+ public void onError(java.lang.Exception error) {
+ if (error instanceof org.apache.axis2.AxisFault) {
+ org.apache.axis2.AxisFault f = (org.apache.axis2.AxisFault) error;
+ org.apache.axiom.om.OMElement faultElt = f.getDetail();
+ if (faultElt!=null){
+ if (faultExceptionNameMap.containsKey(faultElt.getQName())){
+ //make the fault by reflection
+ try{
+ java.lang.String exceptionClassName = (java.lang.String)faultExceptionClassNameMap.get(faultElt.getQName());
+ java.lang.Class exceptionClass = java.lang.Class.forName(exceptionClassName);
+ java.lang.Exception ex=
+ (java.lang.Exception) exceptionClass.newInstance();
+ //message class
+ java.lang.String messageClassName = (java.lang.String)faultMessageMap.get(faultElt.getQName());
+ java.lang.Class messageClass = java.lang.Class.forName(messageClassName);
+ java.lang.Object messageObject = fromOM(faultElt,messageClass,null);
+ java.lang.reflect.Method m = exceptionClass.getMethod("setFaultMessage",
+ new java.lang.Class[]{messageClass});
+ m.invoke(ex,new java.lang.Object[]{messageObject});
+
+
+ callback.receiveErrorgetBookingListByGroupInFuture(new java.rmi.RemoteException(ex.getMessage(), ex));
+ } catch(java.lang.ClassCastException e){
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetBookingListByGroupInFuture(f);
+ } catch (java.lang.ClassNotFoundException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetBookingListByGroupInFuture(f);
+ } catch (java.lang.NoSuchMethodException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetBookingListByGroupInFuture(f);
+ } catch (java.lang.reflect.InvocationTargetException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetBookingListByGroupInFuture(f);
+ } catch (java.lang.IllegalAccessException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetBookingListByGroupInFuture(f);
+ } catch (java.lang.InstantiationException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetBookingListByGroupInFuture(f);
+ } catch (org.apache.axis2.AxisFault e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetBookingListByGroupInFuture(f);
+ }
+ } else {
+ callback.receiveErrorgetBookingListByGroupInFuture(f);
+ }
+ } else {
+ callback.receiveErrorgetBookingListByGroupInFuture(f);
+ }
+ } else {
+ callback.receiveErrorgetBookingListByGroupInFuture(error);
+ }
+ }
+
+ public void onFault(org.apache.axis2.context.MessageContext faultContext) {
+ org.apache.axis2.AxisFault fault = org.apache.axis2.util.Utils.getInboundFaultFromMessageContext(faultContext);
+ onError(fault);
+ }
+
+ public void onComplete() {
+ try {
+ _messageContext.getTransportOut().getSender().cleanup(_messageContext);
+ } catch (org.apache.axis2.AxisFault axisFault) {
+ callback.receiveErrorgetBookingListByGroupInFuture(axisFault);
+ }
+ }
+ });
+
+
+ org.apache.axis2.util.CallbackReceiver _callbackReceiver = null;
+ if ( _operations[1].getMessageReceiver()==null && _operationClient.getOptions().isUseSeparateListener()) {
+ _callbackReceiver = new org.apache.axis2.util.CallbackReceiver();
+ _operations[1].setMessageReceiver(
+ _callbackReceiver);
+ }
+
+ //execute the operation client
+ _operationClient.execute(false);
+
+ }
+
+ /**
+ * Auto generated method signature
+ *
+ * @see com.frentix.olat.vc.provider.vitero.stubs.BookingService#createBooking
+ * @param createBookingRequest3
+
+ */
+
+
+
+ public com.frentix.olat.vitero.manager.stubs.BookingServiceStub.CreateBookingResponse createBooking(
+
+ com.frentix.olat.vitero.manager.stubs.BookingServiceStub.CreateBookingRequest createBookingRequest3)
+
+
+ throws java.rmi.RemoteException
+
+ {
+ org.apache.axis2.context.MessageContext _messageContext = null;
+ try{
+ org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[2].getName());
+ _operationClient.getOptions().setAction("\"\"");
+ _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true);
+
+
+
+ addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&");
+
+
+ // create a message context
+ _messageContext = new org.apache.axis2.context.MessageContext();
+
+
+
+ // create SOAP envelope with that payload
+ org.apache.axiom.soap.SOAPEnvelope env = null;
+
+
+ env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()),
+ createBookingRequest3,
+ optimizeContent(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking",
+ "createBooking")));
+
+ //adding SOAP soap_headers
+ _serviceClient.addHeadersToEnvelope(env);
+ // set the message context with that soap envelope
+ _messageContext.setEnvelope(env);
+
+ // add the message contxt to the operation client
+ _operationClient.addMessageContext(_messageContext);
+
+ //execute the operation client
+ _operationClient.execute(true);
+
+
+ org.apache.axis2.context.MessageContext _returnMessageContext = _operationClient.getMessageContext(
+ org.apache.axis2.wsdl.WSDLConstants.MESSAGE_LABEL_IN_VALUE);
+ org.apache.axiom.soap.SOAPEnvelope _returnEnv = _returnMessageContext.getEnvelope();
+
+
+ java.lang.Object object = fromOM(
+ _returnEnv.getBody().getFirstElement() ,
+ com.frentix.olat.vitero.manager.stubs.BookingServiceStub.CreateBookingResponse.class,
+ getEnvelopeNamespaces(_returnEnv));
+
+
+ return (com.frentix.olat.vitero.manager.stubs.BookingServiceStub.CreateBookingResponse)object;
+
+ }catch(org.apache.axis2.AxisFault f){
+
+ org.apache.axiom.om.OMElement faultElt = f.getDetail();
+ if (faultElt!=null){
+ if (faultExceptionNameMap.containsKey(faultElt.getQName())){
+ //make the fault by reflection
+ try{
+ java.lang.String exceptionClassName = (java.lang.String)faultExceptionClassNameMap.get(faultElt.getQName());
+ java.lang.Class exceptionClass = java.lang.Class.forName(exceptionClassName);
+ java.lang.Exception ex=
+ (java.lang.Exception) exceptionClass.newInstance();
+ //message class
+ java.lang.String messageClassName = (java.lang.String)faultMessageMap.get(faultElt.getQName());
+ java.lang.Class messageClass = java.lang.Class.forName(messageClassName);
+ java.lang.Object messageObject = fromOM(faultElt,messageClass,null);
+ java.lang.reflect.Method m = exceptionClass.getMethod("setFaultMessage",
+ new java.lang.Class[]{messageClass});
+ m.invoke(ex,new java.lang.Object[]{messageObject});
+
+
+ throw new java.rmi.RemoteException(ex.getMessage(), ex);
+ }catch(java.lang.ClassCastException e){
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.ClassNotFoundException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ }catch (java.lang.NoSuchMethodException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.reflect.InvocationTargetException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.IllegalAccessException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.InstantiationException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ }
+ }else{
+ throw f;
+ }
+ }else{
+ throw f;
+ }
+ } finally {
+ _messageContext.getTransportOut().getSender().cleanup(_messageContext);
+ }
+ }
+
+ /**
+ * Auto generated method signature for Asynchronous Invocations
+ *
+ * @see com.frentix.olat.vc.provider.vitero.stubs.BookingService#startcreateBooking
+ * @param createBookingRequest3
+
+ */
+ public void startcreateBooking(
+
+ com.frentix.olat.vitero.manager.stubs.BookingServiceStub.CreateBookingRequest createBookingRequest3,
+
+ final com.frentix.olat.vitero.manager.stubs.BookingServiceCallbackHandler callback)
+
+ throws java.rmi.RemoteException{
+
+ org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[2].getName());
+ _operationClient.getOptions().setAction("\"\"");
+ _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true);
+
+
+
+ addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&");
+
+
+
+ // create SOAP envelope with that payload
+ org.apache.axiom.soap.SOAPEnvelope env=null;
+ final org.apache.axis2.context.MessageContext _messageContext = new org.apache.axis2.context.MessageContext();
+
+
+ //Style is Doc.
+
+
+ env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()),
+ createBookingRequest3,
+ optimizeContent(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking",
+ "createBooking")));
+
+ // adding SOAP soap_headers
+ _serviceClient.addHeadersToEnvelope(env);
+ // create message context with that soap envelope
+ _messageContext.setEnvelope(env);
+
+ // add the message context to the operation client
+ _operationClient.addMessageContext(_messageContext);
+
+
+
+ _operationClient.setCallback(new org.apache.axis2.client.async.AxisCallback() {
+ public void onMessage(org.apache.axis2.context.MessageContext resultContext) {
+ try {
+ org.apache.axiom.soap.SOAPEnvelope resultEnv = resultContext.getEnvelope();
+
+ java.lang.Object object = fromOM(resultEnv.getBody().getFirstElement(),
+ com.frentix.olat.vitero.manager.stubs.BookingServiceStub.CreateBookingResponse.class,
+ getEnvelopeNamespaces(resultEnv));
+ callback.receiveResultcreateBooking(
+ (com.frentix.olat.vitero.manager.stubs.BookingServiceStub.CreateBookingResponse)object);
+
+ } catch (org.apache.axis2.AxisFault e) {
+ callback.receiveErrorcreateBooking(e);
+ }
+ }
+
+ public void onError(java.lang.Exception error) {
+ if (error instanceof org.apache.axis2.AxisFault) {
+ org.apache.axis2.AxisFault f = (org.apache.axis2.AxisFault) error;
+ org.apache.axiom.om.OMElement faultElt = f.getDetail();
+ if (faultElt!=null){
+ if (faultExceptionNameMap.containsKey(faultElt.getQName())){
+ //make the fault by reflection
+ try{
+ java.lang.String exceptionClassName = (java.lang.String)faultExceptionClassNameMap.get(faultElt.getQName());
+ java.lang.Class exceptionClass = java.lang.Class.forName(exceptionClassName);
+ java.lang.Exception ex=
+ (java.lang.Exception) exceptionClass.newInstance();
+ //message class
+ java.lang.String messageClassName = (java.lang.String)faultMessageMap.get(faultElt.getQName());
+ java.lang.Class messageClass = java.lang.Class.forName(messageClassName);
+ java.lang.Object messageObject = fromOM(faultElt,messageClass,null);
+ java.lang.reflect.Method m = exceptionClass.getMethod("setFaultMessage",
+ new java.lang.Class[]{messageClass});
+ m.invoke(ex,new java.lang.Object[]{messageObject});
+
+
+ callback.receiveErrorcreateBooking(new java.rmi.RemoteException(ex.getMessage(), ex));
+ } catch(java.lang.ClassCastException e){
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorcreateBooking(f);
+ } catch (java.lang.ClassNotFoundException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorcreateBooking(f);
+ } catch (java.lang.NoSuchMethodException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorcreateBooking(f);
+ } catch (java.lang.reflect.InvocationTargetException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorcreateBooking(f);
+ } catch (java.lang.IllegalAccessException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorcreateBooking(f);
+ } catch (java.lang.InstantiationException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorcreateBooking(f);
+ } catch (org.apache.axis2.AxisFault e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorcreateBooking(f);
+ }
+ } else {
+ callback.receiveErrorcreateBooking(f);
+ }
+ } else {
+ callback.receiveErrorcreateBooking(f);
+ }
+ } else {
+ callback.receiveErrorcreateBooking(error);
+ }
+ }
+
+ public void onFault(org.apache.axis2.context.MessageContext faultContext) {
+ org.apache.axis2.AxisFault fault = org.apache.axis2.util.Utils.getInboundFaultFromMessageContext(faultContext);
+ onError(fault);
+ }
+
+ public void onComplete() {
+ try {
+ _messageContext.getTransportOut().getSender().cleanup(_messageContext);
+ } catch (org.apache.axis2.AxisFault axisFault) {
+ callback.receiveErrorcreateBooking(axisFault);
+ }
+ }
+ });
+
+
+ org.apache.axis2.util.CallbackReceiver _callbackReceiver = null;
+ if ( _operations[2].getMessageReceiver()==null && _operationClient.getOptions().isUseSeparateListener()) {
+ _callbackReceiver = new org.apache.axis2.util.CallbackReceiver();
+ _operations[2].setMessageReceiver(
+ _callbackReceiver);
+ }
+
+ //execute the operation client
+ _operationClient.execute(false);
+
+ }
+
+ /**
+ * Auto generated method signature
+ *
+ * @see com.frentix.olat.vc.provider.vitero.stubs.BookingService#getBookingListByDate
+ * @param getBookingListByDateRequest5
+
+ */
+
+
+
+ public com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingListByDateResponse getBookingListByDate(
+
+ com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingListByDateRequest getBookingListByDateRequest5)
+
+
+ throws java.rmi.RemoteException
+
+ {
+ org.apache.axis2.context.MessageContext _messageContext = null;
+ try{
+ org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[3].getName());
+ _operationClient.getOptions().setAction("\"\"");
+ _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true);
+
+
+
+ addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&");
+
+
+ // create a message context
+ _messageContext = new org.apache.axis2.context.MessageContext();
+
+
+
+ // create SOAP envelope with that payload
+ org.apache.axiom.soap.SOAPEnvelope env = null;
+
+
+ env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()),
+ getBookingListByDateRequest5,
+ optimizeContent(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking",
+ "getBookingListByDate")));
+
+ //adding SOAP soap_headers
+ _serviceClient.addHeadersToEnvelope(env);
+ // set the message context with that soap envelope
+ _messageContext.setEnvelope(env);
+
+ // add the message contxt to the operation client
+ _operationClient.addMessageContext(_messageContext);
+
+ //execute the operation client
+ _operationClient.execute(true);
+
+
+ org.apache.axis2.context.MessageContext _returnMessageContext = _operationClient.getMessageContext(
+ org.apache.axis2.wsdl.WSDLConstants.MESSAGE_LABEL_IN_VALUE);
+ org.apache.axiom.soap.SOAPEnvelope _returnEnv = _returnMessageContext.getEnvelope();
+
+
+ java.lang.Object object = fromOM(
+ _returnEnv.getBody().getFirstElement() ,
+ com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingListByDateResponse.class,
+ getEnvelopeNamespaces(_returnEnv));
+
+
+ return (com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingListByDateResponse)object;
+
+ }catch(org.apache.axis2.AxisFault f){
+
+ org.apache.axiom.om.OMElement faultElt = f.getDetail();
+ if (faultElt!=null){
+ if (faultExceptionNameMap.containsKey(faultElt.getQName())){
+ //make the fault by reflection
+ try{
+ java.lang.String exceptionClassName = (java.lang.String)faultExceptionClassNameMap.get(faultElt.getQName());
+ java.lang.Class exceptionClass = java.lang.Class.forName(exceptionClassName);
+ java.lang.Exception ex=
+ (java.lang.Exception) exceptionClass.newInstance();
+ //message class
+ java.lang.String messageClassName = (java.lang.String)faultMessageMap.get(faultElt.getQName());
+ java.lang.Class messageClass = java.lang.Class.forName(messageClassName);
+ java.lang.Object messageObject = fromOM(faultElt,messageClass,null);
+ java.lang.reflect.Method m = exceptionClass.getMethod("setFaultMessage",
+ new java.lang.Class[]{messageClass});
+ m.invoke(ex,new java.lang.Object[]{messageObject});
+
+
+ throw new java.rmi.RemoteException(ex.getMessage(), ex);
+ }catch(java.lang.ClassCastException e){
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.ClassNotFoundException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ }catch (java.lang.NoSuchMethodException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.reflect.InvocationTargetException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.IllegalAccessException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.InstantiationException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ }
+ }else{
+ throw f;
+ }
+ }else{
+ throw f;
+ }
+ } finally {
+ _messageContext.getTransportOut().getSender().cleanup(_messageContext);
+ }
+ }
+
+ /**
+ * Auto generated method signature for Asynchronous Invocations
+ *
+ * @see com.frentix.olat.vc.provider.vitero.stubs.BookingService#startgetBookingListByDate
+ * @param getBookingListByDateRequest5
+
+ */
+ public void startgetBookingListByDate(
+
+ com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingListByDateRequest getBookingListByDateRequest5,
+
+ final com.frentix.olat.vitero.manager.stubs.BookingServiceCallbackHandler callback)
+
+ throws java.rmi.RemoteException{
+
+ org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[3].getName());
+ _operationClient.getOptions().setAction("\"\"");
+ _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true);
+
+
+
+ addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&");
+
+
+
+ // create SOAP envelope with that payload
+ org.apache.axiom.soap.SOAPEnvelope env=null;
+ final org.apache.axis2.context.MessageContext _messageContext = new org.apache.axis2.context.MessageContext();
+
+
+ //Style is Doc.
+
+
+ env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()),
+ getBookingListByDateRequest5,
+ optimizeContent(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking",
+ "getBookingListByDate")));
+
+ // adding SOAP soap_headers
+ _serviceClient.addHeadersToEnvelope(env);
+ // create message context with that soap envelope
+ _messageContext.setEnvelope(env);
+
+ // add the message context to the operation client
+ _operationClient.addMessageContext(_messageContext);
+
+
+
+ _operationClient.setCallback(new org.apache.axis2.client.async.AxisCallback() {
+ public void onMessage(org.apache.axis2.context.MessageContext resultContext) {
+ try {
+ org.apache.axiom.soap.SOAPEnvelope resultEnv = resultContext.getEnvelope();
+
+ java.lang.Object object = fromOM(resultEnv.getBody().getFirstElement(),
+ com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingListByDateResponse.class,
+ getEnvelopeNamespaces(resultEnv));
+ callback.receiveResultgetBookingListByDate(
+ (com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingListByDateResponse)object);
+
+ } catch (org.apache.axis2.AxisFault e) {
+ callback.receiveErrorgetBookingListByDate(e);
+ }
+ }
+
+ public void onError(java.lang.Exception error) {
+ if (error instanceof org.apache.axis2.AxisFault) {
+ org.apache.axis2.AxisFault f = (org.apache.axis2.AxisFault) error;
+ org.apache.axiom.om.OMElement faultElt = f.getDetail();
+ if (faultElt!=null){
+ if (faultExceptionNameMap.containsKey(faultElt.getQName())){
+ //make the fault by reflection
+ try{
+ java.lang.String exceptionClassName = (java.lang.String)faultExceptionClassNameMap.get(faultElt.getQName());
+ java.lang.Class exceptionClass = java.lang.Class.forName(exceptionClassName);
+ java.lang.Exception ex=
+ (java.lang.Exception) exceptionClass.newInstance();
+ //message class
+ java.lang.String messageClassName = (java.lang.String)faultMessageMap.get(faultElt.getQName());
+ java.lang.Class messageClass = java.lang.Class.forName(messageClassName);
+ java.lang.Object messageObject = fromOM(faultElt,messageClass,null);
+ java.lang.reflect.Method m = exceptionClass.getMethod("setFaultMessage",
+ new java.lang.Class[]{messageClass});
+ m.invoke(ex,new java.lang.Object[]{messageObject});
+
+
+ callback.receiveErrorgetBookingListByDate(new java.rmi.RemoteException(ex.getMessage(), ex));
+ } catch(java.lang.ClassCastException e){
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetBookingListByDate(f);
+ } catch (java.lang.ClassNotFoundException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetBookingListByDate(f);
+ } catch (java.lang.NoSuchMethodException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetBookingListByDate(f);
+ } catch (java.lang.reflect.InvocationTargetException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetBookingListByDate(f);
+ } catch (java.lang.IllegalAccessException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetBookingListByDate(f);
+ } catch (java.lang.InstantiationException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetBookingListByDate(f);
+ } catch (org.apache.axis2.AxisFault e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetBookingListByDate(f);
+ }
+ } else {
+ callback.receiveErrorgetBookingListByDate(f);
+ }
+ } else {
+ callback.receiveErrorgetBookingListByDate(f);
+ }
+ } else {
+ callback.receiveErrorgetBookingListByDate(error);
+ }
+ }
+
+ public void onFault(org.apache.axis2.context.MessageContext faultContext) {
+ org.apache.axis2.AxisFault fault = org.apache.axis2.util.Utils.getInboundFaultFromMessageContext(faultContext);
+ onError(fault);
+ }
+
+ public void onComplete() {
+ try {
+ _messageContext.getTransportOut().getSender().cleanup(_messageContext);
+ } catch (org.apache.axis2.AxisFault axisFault) {
+ callback.receiveErrorgetBookingListByDate(axisFault);
+ }
+ }
+ });
+
+
+ org.apache.axis2.util.CallbackReceiver _callbackReceiver = null;
+ if ( _operations[3].getMessageReceiver()==null && _operationClient.getOptions().isUseSeparateListener()) {
+ _callbackReceiver = new org.apache.axis2.util.CallbackReceiver();
+ _operations[3].setMessageReceiver(
+ _callbackReceiver);
+ }
+
+ //execute the operation client
+ _operationClient.execute(false);
+
+ }
+
+ /**
+ * Auto generated method signature
+ *
+ * @see com.frentix.olat.vc.provider.vitero.stubs.BookingService#getBookingListByUserAndDate
+ * @param getBookingListByUserAndDateRequest7
+
+ */
+
+
+
+ public com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingListByUserAndDateResponse getBookingListByUserAndDate(
+
+ com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingListByUserAndDateRequest getBookingListByUserAndDateRequest7)
+
+
+ throws java.rmi.RemoteException
+
+ {
+ org.apache.axis2.context.MessageContext _messageContext = null;
+ try{
+ org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[4].getName());
+ _operationClient.getOptions().setAction("\"\"");
+ _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true);
+
+
+
+ addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&");
+
+
+ // create a message context
+ _messageContext = new org.apache.axis2.context.MessageContext();
+
+
+
+ // create SOAP envelope with that payload
+ org.apache.axiom.soap.SOAPEnvelope env = null;
+
+
+ env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()),
+ getBookingListByUserAndDateRequest7,
+ optimizeContent(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking",
+ "getBookingListByUserAndDate")));
+
+ //adding SOAP soap_headers
+ _serviceClient.addHeadersToEnvelope(env);
+ // set the message context with that soap envelope
+ _messageContext.setEnvelope(env);
+
+ // add the message contxt to the operation client
+ _operationClient.addMessageContext(_messageContext);
+
+ //execute the operation client
+ _operationClient.execute(true);
+
+
+ org.apache.axis2.context.MessageContext _returnMessageContext = _operationClient.getMessageContext(
+ org.apache.axis2.wsdl.WSDLConstants.MESSAGE_LABEL_IN_VALUE);
+ org.apache.axiom.soap.SOAPEnvelope _returnEnv = _returnMessageContext.getEnvelope();
+
+
+ java.lang.Object object = fromOM(
+ _returnEnv.getBody().getFirstElement() ,
+ com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingListByUserAndDateResponse.class,
+ getEnvelopeNamespaces(_returnEnv));
+
+
+ return (com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingListByUserAndDateResponse)object;
+
+ }catch(org.apache.axis2.AxisFault f){
+
+ org.apache.axiom.om.OMElement faultElt = f.getDetail();
+ if (faultElt!=null){
+ if (faultExceptionNameMap.containsKey(faultElt.getQName())){
+ //make the fault by reflection
+ try{
+ java.lang.String exceptionClassName = (java.lang.String)faultExceptionClassNameMap.get(faultElt.getQName());
+ java.lang.Class exceptionClass = java.lang.Class.forName(exceptionClassName);
+ java.lang.Exception ex=
+ (java.lang.Exception) exceptionClass.newInstance();
+ //message class
+ java.lang.String messageClassName = (java.lang.String)faultMessageMap.get(faultElt.getQName());
+ java.lang.Class messageClass = java.lang.Class.forName(messageClassName);
+ java.lang.Object messageObject = fromOM(faultElt,messageClass,null);
+ java.lang.reflect.Method m = exceptionClass.getMethod("setFaultMessage",
+ new java.lang.Class[]{messageClass});
+ m.invoke(ex,new java.lang.Object[]{messageObject});
+
+
+ throw new java.rmi.RemoteException(ex.getMessage(), ex);
+ }catch(java.lang.ClassCastException e){
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.ClassNotFoundException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ }catch (java.lang.NoSuchMethodException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.reflect.InvocationTargetException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.IllegalAccessException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.InstantiationException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ }
+ }else{
+ throw f;
+ }
+ }else{
+ throw f;
+ }
+ } finally {
+ _messageContext.getTransportOut().getSender().cleanup(_messageContext);
+ }
+ }
+
+ /**
+ * Auto generated method signature for Asynchronous Invocations
+ *
+ * @see com.frentix.olat.vc.provider.vitero.stubs.BookingService#startgetBookingListByUserAndDate
+ * @param getBookingListByUserAndDateRequest7
+
+ */
+ public void startgetBookingListByUserAndDate(
+
+ com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingListByUserAndDateRequest getBookingListByUserAndDateRequest7,
+
+ final com.frentix.olat.vitero.manager.stubs.BookingServiceCallbackHandler callback)
+
+ throws java.rmi.RemoteException{
+
+ org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[4].getName());
+ _operationClient.getOptions().setAction("\"\"");
+ _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true);
+
+
+
+ addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&");
+
+
+
+ // create SOAP envelope with that payload
+ org.apache.axiom.soap.SOAPEnvelope env=null;
+ final org.apache.axis2.context.MessageContext _messageContext = new org.apache.axis2.context.MessageContext();
+
+
+ //Style is Doc.
+
+
+ env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()),
+ getBookingListByUserAndDateRequest7,
+ optimizeContent(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking",
+ "getBookingListByUserAndDate")));
+
+ // adding SOAP soap_headers
+ _serviceClient.addHeadersToEnvelope(env);
+ // create message context with that soap envelope
+ _messageContext.setEnvelope(env);
+
+ // add the message context to the operation client
+ _operationClient.addMessageContext(_messageContext);
+
+
+
+ _operationClient.setCallback(new org.apache.axis2.client.async.AxisCallback() {
+ public void onMessage(org.apache.axis2.context.MessageContext resultContext) {
+ try {
+ org.apache.axiom.soap.SOAPEnvelope resultEnv = resultContext.getEnvelope();
+
+ java.lang.Object object = fromOM(resultEnv.getBody().getFirstElement(),
+ com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingListByUserAndDateResponse.class,
+ getEnvelopeNamespaces(resultEnv));
+ callback.receiveResultgetBookingListByUserAndDate(
+ (com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingListByUserAndDateResponse)object);
+
+ } catch (org.apache.axis2.AxisFault e) {
+ callback.receiveErrorgetBookingListByUserAndDate(e);
+ }
+ }
+
+ public void onError(java.lang.Exception error) {
+ if (error instanceof org.apache.axis2.AxisFault) {
+ org.apache.axis2.AxisFault f = (org.apache.axis2.AxisFault) error;
+ org.apache.axiom.om.OMElement faultElt = f.getDetail();
+ if (faultElt!=null){
+ if (faultExceptionNameMap.containsKey(faultElt.getQName())){
+ //make the fault by reflection
+ try{
+ java.lang.String exceptionClassName = (java.lang.String)faultExceptionClassNameMap.get(faultElt.getQName());
+ java.lang.Class exceptionClass = java.lang.Class.forName(exceptionClassName);
+ java.lang.Exception ex=
+ (java.lang.Exception) exceptionClass.newInstance();
+ //message class
+ java.lang.String messageClassName = (java.lang.String)faultMessageMap.get(faultElt.getQName());
+ java.lang.Class messageClass = java.lang.Class.forName(messageClassName);
+ java.lang.Object messageObject = fromOM(faultElt,messageClass,null);
+ java.lang.reflect.Method m = exceptionClass.getMethod("setFaultMessage",
+ new java.lang.Class[]{messageClass});
+ m.invoke(ex,new java.lang.Object[]{messageObject});
+
+
+ callback.receiveErrorgetBookingListByUserAndDate(new java.rmi.RemoteException(ex.getMessage(), ex));
+ } catch(java.lang.ClassCastException e){
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetBookingListByUserAndDate(f);
+ } catch (java.lang.ClassNotFoundException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetBookingListByUserAndDate(f);
+ } catch (java.lang.NoSuchMethodException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetBookingListByUserAndDate(f);
+ } catch (java.lang.reflect.InvocationTargetException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetBookingListByUserAndDate(f);
+ } catch (java.lang.IllegalAccessException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetBookingListByUserAndDate(f);
+ } catch (java.lang.InstantiationException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetBookingListByUserAndDate(f);
+ } catch (org.apache.axis2.AxisFault e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetBookingListByUserAndDate(f);
+ }
+ } else {
+ callback.receiveErrorgetBookingListByUserAndDate(f);
+ }
+ } else {
+ callback.receiveErrorgetBookingListByUserAndDate(f);
+ }
+ } else {
+ callback.receiveErrorgetBookingListByUserAndDate(error);
+ }
+ }
+
+ public void onFault(org.apache.axis2.context.MessageContext faultContext) {
+ org.apache.axis2.AxisFault fault = org.apache.axis2.util.Utils.getInboundFaultFromMessageContext(faultContext);
+ onError(fault);
+ }
+
+ public void onComplete() {
+ try {
+ _messageContext.getTransportOut().getSender().cleanup(_messageContext);
+ } catch (org.apache.axis2.AxisFault axisFault) {
+ callback.receiveErrorgetBookingListByUserAndDate(axisFault);
+ }
+ }
+ });
+
+
+ org.apache.axis2.util.CallbackReceiver _callbackReceiver = null;
+ if ( _operations[4].getMessageReceiver()==null && _operationClient.getOptions().isUseSeparateListener()) {
+ _callbackReceiver = new org.apache.axis2.util.CallbackReceiver();
+ _operations[4].setMessageReceiver(
+ _callbackReceiver);
+ }
+
+ //execute the operation client
+ _operationClient.execute(false);
+
+ }
+
+ /**
+ * Auto generated method signature
+ *
+ * @see com.frentix.olat.vc.provider.vitero.stubs.BookingService#getBookingListByUserInFuture
+ * @param getBookingListByUserInFutureRequest9
+
+ */
+
+
+
+ public com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingListByUserInFutureResponse getBookingListByUserInFuture(
+
+ com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingListByUserInFutureRequest getBookingListByUserInFutureRequest9)
+
+
+ throws java.rmi.RemoteException
+
+ {
+ org.apache.axis2.context.MessageContext _messageContext = null;
+ try{
+ org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[5].getName());
+ _operationClient.getOptions().setAction("\"\"");
+ _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true);
+
+
+
+ addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&");
+
+
+ // create a message context
+ _messageContext = new org.apache.axis2.context.MessageContext();
+
+
+
+ // create SOAP envelope with that payload
+ org.apache.axiom.soap.SOAPEnvelope env = null;
+
+
+ env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()),
+ getBookingListByUserInFutureRequest9,
+ optimizeContent(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking",
+ "getBookingListByUserInFuture")));
+
+ //adding SOAP soap_headers
+ _serviceClient.addHeadersToEnvelope(env);
+ // set the message context with that soap envelope
+ _messageContext.setEnvelope(env);
+
+ // add the message contxt to the operation client
+ _operationClient.addMessageContext(_messageContext);
+
+ //execute the operation client
+ _operationClient.execute(true);
+
+
+ org.apache.axis2.context.MessageContext _returnMessageContext = _operationClient.getMessageContext(
+ org.apache.axis2.wsdl.WSDLConstants.MESSAGE_LABEL_IN_VALUE);
+ org.apache.axiom.soap.SOAPEnvelope _returnEnv = _returnMessageContext.getEnvelope();
+
+
+ java.lang.Object object = fromOM(
+ _returnEnv.getBody().getFirstElement() ,
+ com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingListByUserInFutureResponse.class,
+ getEnvelopeNamespaces(_returnEnv));
+
+
+ return (com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingListByUserInFutureResponse)object;
+
+ }catch(org.apache.axis2.AxisFault f){
+
+ org.apache.axiom.om.OMElement faultElt = f.getDetail();
+ if (faultElt!=null){
+ if (faultExceptionNameMap.containsKey(faultElt.getQName())){
+ //make the fault by reflection
+ try{
+ java.lang.String exceptionClassName = (java.lang.String)faultExceptionClassNameMap.get(faultElt.getQName());
+ java.lang.Class exceptionClass = java.lang.Class.forName(exceptionClassName);
+ java.lang.Exception ex=
+ (java.lang.Exception) exceptionClass.newInstance();
+ //message class
+ java.lang.String messageClassName = (java.lang.String)faultMessageMap.get(faultElt.getQName());
+ java.lang.Class messageClass = java.lang.Class.forName(messageClassName);
+ java.lang.Object messageObject = fromOM(faultElt,messageClass,null);
+ java.lang.reflect.Method m = exceptionClass.getMethod("setFaultMessage",
+ new java.lang.Class[]{messageClass});
+ m.invoke(ex,new java.lang.Object[]{messageObject});
+
+
+ throw new java.rmi.RemoteException(ex.getMessage(), ex);
+ }catch(java.lang.ClassCastException e){
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.ClassNotFoundException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ }catch (java.lang.NoSuchMethodException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.reflect.InvocationTargetException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.IllegalAccessException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.InstantiationException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ }
+ }else{
+ throw f;
+ }
+ }else{
+ throw f;
+ }
+ } finally {
+ _messageContext.getTransportOut().getSender().cleanup(_messageContext);
+ }
+ }
+
+ /**
+ * Auto generated method signature for Asynchronous Invocations
+ *
+ * @see com.frentix.olat.vc.provider.vitero.stubs.BookingService#startgetBookingListByUserInFuture
+ * @param getBookingListByUserInFutureRequest9
+
+ */
+ public void startgetBookingListByUserInFuture(
+
+ com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingListByUserInFutureRequest getBookingListByUserInFutureRequest9,
+
+ final com.frentix.olat.vitero.manager.stubs.BookingServiceCallbackHandler callback)
+
+ throws java.rmi.RemoteException{
+
+ org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[5].getName());
+ _operationClient.getOptions().setAction("\"\"");
+ _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true);
+
+
+
+ addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&");
+
+
+
+ // create SOAP envelope with that payload
+ org.apache.axiom.soap.SOAPEnvelope env=null;
+ final org.apache.axis2.context.MessageContext _messageContext = new org.apache.axis2.context.MessageContext();
+
+
+ //Style is Doc.
+
+
+ env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()),
+ getBookingListByUserInFutureRequest9,
+ optimizeContent(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking",
+ "getBookingListByUserInFuture")));
+
+ // adding SOAP soap_headers
+ _serviceClient.addHeadersToEnvelope(env);
+ // create message context with that soap envelope
+ _messageContext.setEnvelope(env);
+
+ // add the message context to the operation client
+ _operationClient.addMessageContext(_messageContext);
+
+
+
+ _operationClient.setCallback(new org.apache.axis2.client.async.AxisCallback() {
+ public void onMessage(org.apache.axis2.context.MessageContext resultContext) {
+ try {
+ org.apache.axiom.soap.SOAPEnvelope resultEnv = resultContext.getEnvelope();
+
+ java.lang.Object object = fromOM(resultEnv.getBody().getFirstElement(),
+ com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingListByUserInFutureResponse.class,
+ getEnvelopeNamespaces(resultEnv));
+ callback.receiveResultgetBookingListByUserInFuture(
+ (com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingListByUserInFutureResponse)object);
+
+ } catch (org.apache.axis2.AxisFault e) {
+ callback.receiveErrorgetBookingListByUserInFuture(e);
+ }
+ }
+
+ public void onError(java.lang.Exception error) {
+ if (error instanceof org.apache.axis2.AxisFault) {
+ org.apache.axis2.AxisFault f = (org.apache.axis2.AxisFault) error;
+ org.apache.axiom.om.OMElement faultElt = f.getDetail();
+ if (faultElt!=null){
+ if (faultExceptionNameMap.containsKey(faultElt.getQName())){
+ //make the fault by reflection
+ try{
+ java.lang.String exceptionClassName = (java.lang.String)faultExceptionClassNameMap.get(faultElt.getQName());
+ java.lang.Class exceptionClass = java.lang.Class.forName(exceptionClassName);
+ java.lang.Exception ex=
+ (java.lang.Exception) exceptionClass.newInstance();
+ //message class
+ java.lang.String messageClassName = (java.lang.String)faultMessageMap.get(faultElt.getQName());
+ java.lang.Class messageClass = java.lang.Class.forName(messageClassName);
+ java.lang.Object messageObject = fromOM(faultElt,messageClass,null);
+ java.lang.reflect.Method m = exceptionClass.getMethod("setFaultMessage",
+ new java.lang.Class[]{messageClass});
+ m.invoke(ex,new java.lang.Object[]{messageObject});
+
+
+ callback.receiveErrorgetBookingListByUserInFuture(new java.rmi.RemoteException(ex.getMessage(), ex));
+ } catch(java.lang.ClassCastException e){
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetBookingListByUserInFuture(f);
+ } catch (java.lang.ClassNotFoundException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetBookingListByUserInFuture(f);
+ } catch (java.lang.NoSuchMethodException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetBookingListByUserInFuture(f);
+ } catch (java.lang.reflect.InvocationTargetException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetBookingListByUserInFuture(f);
+ } catch (java.lang.IllegalAccessException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetBookingListByUserInFuture(f);
+ } catch (java.lang.InstantiationException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetBookingListByUserInFuture(f);
+ } catch (org.apache.axis2.AxisFault e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetBookingListByUserInFuture(f);
+ }
+ } else {
+ callback.receiveErrorgetBookingListByUserInFuture(f);
+ }
+ } else {
+ callback.receiveErrorgetBookingListByUserInFuture(f);
+ }
+ } else {
+ callback.receiveErrorgetBookingListByUserInFuture(error);
+ }
+ }
+
+ public void onFault(org.apache.axis2.context.MessageContext faultContext) {
+ org.apache.axis2.AxisFault fault = org.apache.axis2.util.Utils.getInboundFaultFromMessageContext(faultContext);
+ onError(fault);
+ }
+
+ public void onComplete() {
+ try {
+ _messageContext.getTransportOut().getSender().cleanup(_messageContext);
+ } catch (org.apache.axis2.AxisFault axisFault) {
+ callback.receiveErrorgetBookingListByUserInFuture(axisFault);
+ }
+ }
+ });
+
+
+ org.apache.axis2.util.CallbackReceiver _callbackReceiver = null;
+ if ( _operations[5].getMessageReceiver()==null && _operationClient.getOptions().isUseSeparateListener()) {
+ _callbackReceiver = new org.apache.axis2.util.CallbackReceiver();
+ _operations[5].setMessageReceiver(
+ _callbackReceiver);
+ }
+
+ //execute the operation client
+ _operationClient.execute(false);
+
+ }
+
+ /**
+ * Auto generated method signature
+ *
+ * @see com.frentix.olat.vc.provider.vitero.stubs.BookingService#getBookingTimeById
+ * @param getBookingTimeByIdRequest11
+
+ */
+
+
+
+ public com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingTimeByIdResponse getBookingTimeById(
+
+ com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingTimeByIdRequest getBookingTimeByIdRequest11)
+
+
+ throws java.rmi.RemoteException
+
+ {
+ org.apache.axis2.context.MessageContext _messageContext = null;
+ try{
+ org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[6].getName());
+ _operationClient.getOptions().setAction("\"\"");
+ _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true);
+
+
+
+ addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&");
+
+
+ // create a message context
+ _messageContext = new org.apache.axis2.context.MessageContext();
+
+
+
+ // create SOAP envelope with that payload
+ org.apache.axiom.soap.SOAPEnvelope env = null;
+
+
+ env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()),
+ getBookingTimeByIdRequest11,
+ optimizeContent(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking",
+ "getBookingTimeById")));
+
+ //adding SOAP soap_headers
+ _serviceClient.addHeadersToEnvelope(env);
+ // set the message context with that soap envelope
+ _messageContext.setEnvelope(env);
+
+ // add the message contxt to the operation client
+ _operationClient.addMessageContext(_messageContext);
+
+ //execute the operation client
+ _operationClient.execute(true);
+
+
+ org.apache.axis2.context.MessageContext _returnMessageContext = _operationClient.getMessageContext(
+ org.apache.axis2.wsdl.WSDLConstants.MESSAGE_LABEL_IN_VALUE);
+ org.apache.axiom.soap.SOAPEnvelope _returnEnv = _returnMessageContext.getEnvelope();
+
+
+ java.lang.Object object = fromOM(
+ _returnEnv.getBody().getFirstElement() ,
+ com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingTimeByIdResponse.class,
+ getEnvelopeNamespaces(_returnEnv));
+
+
+ return (com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingTimeByIdResponse)object;
+
+ }catch(org.apache.axis2.AxisFault f){
+
+ org.apache.axiom.om.OMElement faultElt = f.getDetail();
+ if (faultElt!=null){
+ if (faultExceptionNameMap.containsKey(faultElt.getQName())){
+ //make the fault by reflection
+ try{
+ java.lang.String exceptionClassName = (java.lang.String)faultExceptionClassNameMap.get(faultElt.getQName());
+ java.lang.Class exceptionClass = java.lang.Class.forName(exceptionClassName);
+ java.lang.Exception ex=
+ (java.lang.Exception) exceptionClass.newInstance();
+ //message class
+ java.lang.String messageClassName = (java.lang.String)faultMessageMap.get(faultElt.getQName());
+ java.lang.Class messageClass = java.lang.Class.forName(messageClassName);
+ java.lang.Object messageObject = fromOM(faultElt,messageClass,null);
+ java.lang.reflect.Method m = exceptionClass.getMethod("setFaultMessage",
+ new java.lang.Class[]{messageClass});
+ m.invoke(ex,new java.lang.Object[]{messageObject});
+
+
+ throw new java.rmi.RemoteException(ex.getMessage(), ex);
+ }catch(java.lang.ClassCastException e){
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.ClassNotFoundException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ }catch (java.lang.NoSuchMethodException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.reflect.InvocationTargetException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.IllegalAccessException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.InstantiationException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ }
+ }else{
+ throw f;
+ }
+ }else{
+ throw f;
+ }
+ } finally {
+ _messageContext.getTransportOut().getSender().cleanup(_messageContext);
+ }
+ }
+
+ /**
+ * Auto generated method signature for Asynchronous Invocations
+ *
+ * @see com.frentix.olat.vc.provider.vitero.stubs.BookingService#startgetBookingTimeById
+ * @param getBookingTimeByIdRequest11
+
+ */
+ public void startgetBookingTimeById(
+
+ com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingTimeByIdRequest getBookingTimeByIdRequest11,
+
+ final com.frentix.olat.vitero.manager.stubs.BookingServiceCallbackHandler callback)
+
+ throws java.rmi.RemoteException{
+
+ org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[6].getName());
+ _operationClient.getOptions().setAction("\"\"");
+ _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true);
+
+
+
+ addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&");
+
+
+
+ // create SOAP envelope with that payload
+ org.apache.axiom.soap.SOAPEnvelope env=null;
+ final org.apache.axis2.context.MessageContext _messageContext = new org.apache.axis2.context.MessageContext();
+
+
+ //Style is Doc.
+
+
+ env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()),
+ getBookingTimeByIdRequest11,
+ optimizeContent(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking",
+ "getBookingTimeById")));
+
+ // adding SOAP soap_headers
+ _serviceClient.addHeadersToEnvelope(env);
+ // create message context with that soap envelope
+ _messageContext.setEnvelope(env);
+
+ // add the message context to the operation client
+ _operationClient.addMessageContext(_messageContext);
+
+
+
+ _operationClient.setCallback(new org.apache.axis2.client.async.AxisCallback() {
+ public void onMessage(org.apache.axis2.context.MessageContext resultContext) {
+ try {
+ org.apache.axiom.soap.SOAPEnvelope resultEnv = resultContext.getEnvelope();
+
+ java.lang.Object object = fromOM(resultEnv.getBody().getFirstElement(),
+ com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingTimeByIdResponse.class,
+ getEnvelopeNamespaces(resultEnv));
+ callback.receiveResultgetBookingTimeById(
+ (com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingTimeByIdResponse)object);
+
+ } catch (org.apache.axis2.AxisFault e) {
+ callback.receiveErrorgetBookingTimeById(e);
+ }
+ }
+
+ public void onError(java.lang.Exception error) {
+ if (error instanceof org.apache.axis2.AxisFault) {
+ org.apache.axis2.AxisFault f = (org.apache.axis2.AxisFault) error;
+ org.apache.axiom.om.OMElement faultElt = f.getDetail();
+ if (faultElt!=null){
+ if (faultExceptionNameMap.containsKey(faultElt.getQName())){
+ //make the fault by reflection
+ try{
+ java.lang.String exceptionClassName = (java.lang.String)faultExceptionClassNameMap.get(faultElt.getQName());
+ java.lang.Class exceptionClass = java.lang.Class.forName(exceptionClassName);
+ java.lang.Exception ex=
+ (java.lang.Exception) exceptionClass.newInstance();
+ //message class
+ java.lang.String messageClassName = (java.lang.String)faultMessageMap.get(faultElt.getQName());
+ java.lang.Class messageClass = java.lang.Class.forName(messageClassName);
+ java.lang.Object messageObject = fromOM(faultElt,messageClass,null);
+ java.lang.reflect.Method m = exceptionClass.getMethod("setFaultMessage",
+ new java.lang.Class[]{messageClass});
+ m.invoke(ex,new java.lang.Object[]{messageObject});
+
+
+ callback.receiveErrorgetBookingTimeById(new java.rmi.RemoteException(ex.getMessage(), ex));
+ } catch(java.lang.ClassCastException e){
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetBookingTimeById(f);
+ } catch (java.lang.ClassNotFoundException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetBookingTimeById(f);
+ } catch (java.lang.NoSuchMethodException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetBookingTimeById(f);
+ } catch (java.lang.reflect.InvocationTargetException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetBookingTimeById(f);
+ } catch (java.lang.IllegalAccessException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetBookingTimeById(f);
+ } catch (java.lang.InstantiationException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetBookingTimeById(f);
+ } catch (org.apache.axis2.AxisFault e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetBookingTimeById(f);
+ }
+ } else {
+ callback.receiveErrorgetBookingTimeById(f);
+ }
+ } else {
+ callback.receiveErrorgetBookingTimeById(f);
+ }
+ } else {
+ callback.receiveErrorgetBookingTimeById(error);
+ }
+ }
+
+ public void onFault(org.apache.axis2.context.MessageContext faultContext) {
+ org.apache.axis2.AxisFault fault = org.apache.axis2.util.Utils.getInboundFaultFromMessageContext(faultContext);
+ onError(fault);
+ }
+
+ public void onComplete() {
+ try {
+ _messageContext.getTransportOut().getSender().cleanup(_messageContext);
+ } catch (org.apache.axis2.AxisFault axisFault) {
+ callback.receiveErrorgetBookingTimeById(axisFault);
+ }
+ }
+ });
+
+
+ org.apache.axis2.util.CallbackReceiver _callbackReceiver = null;
+ if ( _operations[6].getMessageReceiver()==null && _operationClient.getOptions().isUseSeparateListener()) {
+ _callbackReceiver = new org.apache.axis2.util.CallbackReceiver();
+ _operations[6].setMessageReceiver(
+ _callbackReceiver);
+ }
+
+ //execute the operation client
+ _operationClient.execute(false);
+
+ }
+
+ /**
+ * Auto generated method signature
+ *
+ * @see com.frentix.olat.vc.provider.vitero.stubs.BookingService#getBookingById
+ * @param getBookingByIdRequest13
+
+ */
+
+
+
+ public com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingByIdResponse getBookingById(
+
+ com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingByIdRequest getBookingByIdRequest13)
+
+
+ throws java.rmi.RemoteException
+
+ {
+ org.apache.axis2.context.MessageContext _messageContext = null;
+ try{
+ org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[7].getName());
+ _operationClient.getOptions().setAction("\"\"");
+ _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true);
+
+
+
+ addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&");
+
+
+ // create a message context
+ _messageContext = new org.apache.axis2.context.MessageContext();
+
+
+
+ // create SOAP envelope with that payload
+ org.apache.axiom.soap.SOAPEnvelope env = null;
+
+
+ env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()),
+ getBookingByIdRequest13,
+ optimizeContent(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking",
+ "getBookingById")));
+
+ //adding SOAP soap_headers
+ _serviceClient.addHeadersToEnvelope(env);
+ // set the message context with that soap envelope
+ _messageContext.setEnvelope(env);
+
+ // add the message contxt to the operation client
+ _operationClient.addMessageContext(_messageContext);
+
+ //execute the operation client
+ _operationClient.execute(true);
+
+
+ org.apache.axis2.context.MessageContext _returnMessageContext = _operationClient.getMessageContext(
+ org.apache.axis2.wsdl.WSDLConstants.MESSAGE_LABEL_IN_VALUE);
+ org.apache.axiom.soap.SOAPEnvelope _returnEnv = _returnMessageContext.getEnvelope();
+
+
+ java.lang.Object object = fromOM(
+ _returnEnv.getBody().getFirstElement() ,
+ com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingByIdResponse.class,
+ getEnvelopeNamespaces(_returnEnv));
+
+
+ return (com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingByIdResponse)object;
+
+ }catch(org.apache.axis2.AxisFault f){
+
+ org.apache.axiom.om.OMElement faultElt = f.getDetail();
+ if (faultElt!=null){
+ if (faultExceptionNameMap.containsKey(faultElt.getQName())){
+ //make the fault by reflection
+ try{
+ java.lang.String exceptionClassName = (java.lang.String)faultExceptionClassNameMap.get(faultElt.getQName());
+ java.lang.Class exceptionClass = java.lang.Class.forName(exceptionClassName);
+ java.lang.Exception ex=
+ (java.lang.Exception) exceptionClass.newInstance();
+ //message class
+ java.lang.String messageClassName = (java.lang.String)faultMessageMap.get(faultElt.getQName());
+ java.lang.Class messageClass = java.lang.Class.forName(messageClassName);
+ java.lang.Object messageObject = fromOM(faultElt,messageClass,null);
+ java.lang.reflect.Method m = exceptionClass.getMethod("setFaultMessage",
+ new java.lang.Class[]{messageClass});
+ m.invoke(ex,new java.lang.Object[]{messageObject});
+
+
+ throw new java.rmi.RemoteException(ex.getMessage(), ex);
+ }catch(java.lang.ClassCastException e){
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.ClassNotFoundException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ }catch (java.lang.NoSuchMethodException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.reflect.InvocationTargetException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.IllegalAccessException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.InstantiationException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ }
+ }else{
+ throw f;
+ }
+ }else{
+ throw f;
+ }
+ } finally {
+ _messageContext.getTransportOut().getSender().cleanup(_messageContext);
+ }
+ }
+
+ /**
+ * Auto generated method signature for Asynchronous Invocations
+ *
+ * @see com.frentix.olat.vc.provider.vitero.stubs.BookingService#startgetBookingById
+ * @param getBookingByIdRequest13
+
+ */
+ public void startgetBookingById(
+
+ com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingByIdRequest getBookingByIdRequest13,
+
+ final com.frentix.olat.vitero.manager.stubs.BookingServiceCallbackHandler callback)
+
+ throws java.rmi.RemoteException{
+
+ org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[7].getName());
+ _operationClient.getOptions().setAction("\"\"");
+ _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true);
+
+
+
+ addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&");
+
+
+
+ // create SOAP envelope with that payload
+ org.apache.axiom.soap.SOAPEnvelope env=null;
+ final org.apache.axis2.context.MessageContext _messageContext = new org.apache.axis2.context.MessageContext();
+
+
+ //Style is Doc.
+
+
+ env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()),
+ getBookingByIdRequest13,
+ optimizeContent(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking",
+ "getBookingById")));
+
+ // adding SOAP soap_headers
+ _serviceClient.addHeadersToEnvelope(env);
+ // create message context with that soap envelope
+ _messageContext.setEnvelope(env);
+
+ // add the message context to the operation client
+ _operationClient.addMessageContext(_messageContext);
+
+
+
+ _operationClient.setCallback(new org.apache.axis2.client.async.AxisCallback() {
+ public void onMessage(org.apache.axis2.context.MessageContext resultContext) {
+ try {
+ org.apache.axiom.soap.SOAPEnvelope resultEnv = resultContext.getEnvelope();
+
+ java.lang.Object object = fromOM(resultEnv.getBody().getFirstElement(),
+ com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingByIdResponse.class,
+ getEnvelopeNamespaces(resultEnv));
+ callback.receiveResultgetBookingById(
+ (com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingByIdResponse)object);
+
+ } catch (org.apache.axis2.AxisFault e) {
+ callback.receiveErrorgetBookingById(e);
+ }
+ }
+
+ public void onError(java.lang.Exception error) {
+ if (error instanceof org.apache.axis2.AxisFault) {
+ org.apache.axis2.AxisFault f = (org.apache.axis2.AxisFault) error;
+ org.apache.axiom.om.OMElement faultElt = f.getDetail();
+ if (faultElt!=null){
+ if (faultExceptionNameMap.containsKey(faultElt.getQName())){
+ //make the fault by reflection
+ try{
+ java.lang.String exceptionClassName = (java.lang.String)faultExceptionClassNameMap.get(faultElt.getQName());
+ java.lang.Class exceptionClass = java.lang.Class.forName(exceptionClassName);
+ java.lang.Exception ex=
+ (java.lang.Exception) exceptionClass.newInstance();
+ //message class
+ java.lang.String messageClassName = (java.lang.String)faultMessageMap.get(faultElt.getQName());
+ java.lang.Class messageClass = java.lang.Class.forName(messageClassName);
+ java.lang.Object messageObject = fromOM(faultElt,messageClass,null);
+ java.lang.reflect.Method m = exceptionClass.getMethod("setFaultMessage",
+ new java.lang.Class[]{messageClass});
+ m.invoke(ex,new java.lang.Object[]{messageObject});
+
+
+ callback.receiveErrorgetBookingById(new java.rmi.RemoteException(ex.getMessage(), ex));
+ } catch(java.lang.ClassCastException e){
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetBookingById(f);
+ } catch (java.lang.ClassNotFoundException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetBookingById(f);
+ } catch (java.lang.NoSuchMethodException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetBookingById(f);
+ } catch (java.lang.reflect.InvocationTargetException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetBookingById(f);
+ } catch (java.lang.IllegalAccessException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetBookingById(f);
+ } catch (java.lang.InstantiationException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetBookingById(f);
+ } catch (org.apache.axis2.AxisFault e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetBookingById(f);
+ }
+ } else {
+ callback.receiveErrorgetBookingById(f);
+ }
+ } else {
+ callback.receiveErrorgetBookingById(f);
+ }
+ } else {
+ callback.receiveErrorgetBookingById(error);
+ }
+ }
+
+ public void onFault(org.apache.axis2.context.MessageContext faultContext) {
+ org.apache.axis2.AxisFault fault = org.apache.axis2.util.Utils.getInboundFaultFromMessageContext(faultContext);
+ onError(fault);
+ }
+
+ public void onComplete() {
+ try {
+ _messageContext.getTransportOut().getSender().cleanup(_messageContext);
+ } catch (org.apache.axis2.AxisFault axisFault) {
+ callback.receiveErrorgetBookingById(axisFault);
+ }
+ }
+ });
+
+
+ org.apache.axis2.util.CallbackReceiver _callbackReceiver = null;
+ if ( _operations[7].getMessageReceiver()==null && _operationClient.getOptions().isUseSeparateListener()) {
+ _callbackReceiver = new org.apache.axis2.util.CallbackReceiver();
+ _operations[7].setMessageReceiver(
+ _callbackReceiver);
+ }
+
+ //execute the operation client
+ _operationClient.execute(false);
+
+ }
+
+ /**
+ * Auto generated method signature
+ *
+ * @see com.frentix.olat.vc.provider.vitero.stubs.BookingService#deleteBooking
+ * @param deleteBookingRequest15
+
+ */
+
+
+
+ public com.frentix.olat.vitero.manager.stubs.BookingServiceStub.DeleteBookingResponse deleteBooking(
+
+ com.frentix.olat.vitero.manager.stubs.BookingServiceStub.DeleteBookingRequest deleteBookingRequest15)
+
+
+ throws java.rmi.RemoteException
+
+ {
+ org.apache.axis2.context.MessageContext _messageContext = null;
+ try{
+ org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[8].getName());
+ _operationClient.getOptions().setAction("\"\"");
+ _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true);
+
+
+
+ addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&");
+
+
+ // create a message context
+ _messageContext = new org.apache.axis2.context.MessageContext();
+
+
+
+ // create SOAP envelope with that payload
+ org.apache.axiom.soap.SOAPEnvelope env = null;
+
+
+ env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()),
+ deleteBookingRequest15,
+ optimizeContent(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking",
+ "deleteBooking")));
+
+ //adding SOAP soap_headers
+ _serviceClient.addHeadersToEnvelope(env);
+ // set the message context with that soap envelope
+ _messageContext.setEnvelope(env);
+
+ // add the message contxt to the operation client
+ _operationClient.addMessageContext(_messageContext);
+
+ //execute the operation client
+ _operationClient.execute(true);
+
+
+ org.apache.axis2.context.MessageContext _returnMessageContext = _operationClient.getMessageContext(
+ org.apache.axis2.wsdl.WSDLConstants.MESSAGE_LABEL_IN_VALUE);
+ org.apache.axiom.soap.SOAPEnvelope _returnEnv = _returnMessageContext.getEnvelope();
+
+
+ java.lang.Object object = fromOM(
+ _returnEnv.getBody().getFirstElement() ,
+ com.frentix.olat.vitero.manager.stubs.BookingServiceStub.DeleteBookingResponse.class,
+ getEnvelopeNamespaces(_returnEnv));
+
+
+ return (com.frentix.olat.vitero.manager.stubs.BookingServiceStub.DeleteBookingResponse)object;
+
+ }catch(org.apache.axis2.AxisFault f){
+
+ org.apache.axiom.om.OMElement faultElt = f.getDetail();
+ if (faultElt!=null){
+ if (faultExceptionNameMap.containsKey(faultElt.getQName())){
+ //make the fault by reflection
+ try{
+ java.lang.String exceptionClassName = (java.lang.String)faultExceptionClassNameMap.get(faultElt.getQName());
+ java.lang.Class exceptionClass = java.lang.Class.forName(exceptionClassName);
+ java.lang.Exception ex=
+ (java.lang.Exception) exceptionClass.newInstance();
+ //message class
+ java.lang.String messageClassName = (java.lang.String)faultMessageMap.get(faultElt.getQName());
+ java.lang.Class messageClass = java.lang.Class.forName(messageClassName);
+ java.lang.Object messageObject = fromOM(faultElt,messageClass,null);
+ java.lang.reflect.Method m = exceptionClass.getMethod("setFaultMessage",
+ new java.lang.Class[]{messageClass});
+ m.invoke(ex,new java.lang.Object[]{messageObject});
+
+
+ throw new java.rmi.RemoteException(ex.getMessage(), ex);
+ }catch(java.lang.ClassCastException e){
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.ClassNotFoundException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ }catch (java.lang.NoSuchMethodException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.reflect.InvocationTargetException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.IllegalAccessException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.InstantiationException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ }
+ }else{
+ throw f;
+ }
+ }else{
+ throw f;
+ }
+ } finally {
+ _messageContext.getTransportOut().getSender().cleanup(_messageContext);
+ }
+ }
+
+ /**
+ * Auto generated method signature for Asynchronous Invocations
+ *
+ * @see com.frentix.olat.vc.provider.vitero.stubs.BookingService#startdeleteBooking
+ * @param deleteBookingRequest15
+
+ */
+ public void startdeleteBooking(
+
+ com.frentix.olat.vitero.manager.stubs.BookingServiceStub.DeleteBookingRequest deleteBookingRequest15,
+
+ final com.frentix.olat.vitero.manager.stubs.BookingServiceCallbackHandler callback)
+
+ throws java.rmi.RemoteException{
+
+ org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[8].getName());
+ _operationClient.getOptions().setAction("\"\"");
+ _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true);
+
+
+
+ addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&");
+
+
+
+ // create SOAP envelope with that payload
+ org.apache.axiom.soap.SOAPEnvelope env=null;
+ final org.apache.axis2.context.MessageContext _messageContext = new org.apache.axis2.context.MessageContext();
+
+
+ //Style is Doc.
+
+
+ env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()),
+ deleteBookingRequest15,
+ optimizeContent(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking",
+ "deleteBooking")));
+
+ // adding SOAP soap_headers
+ _serviceClient.addHeadersToEnvelope(env);
+ // create message context with that soap envelope
+ _messageContext.setEnvelope(env);
+
+ // add the message context to the operation client
+ _operationClient.addMessageContext(_messageContext);
+
+
+
+ _operationClient.setCallback(new org.apache.axis2.client.async.AxisCallback() {
+ public void onMessage(org.apache.axis2.context.MessageContext resultContext) {
+ try {
+ org.apache.axiom.soap.SOAPEnvelope resultEnv = resultContext.getEnvelope();
+
+ java.lang.Object object = fromOM(resultEnv.getBody().getFirstElement(),
+ com.frentix.olat.vitero.manager.stubs.BookingServiceStub.DeleteBookingResponse.class,
+ getEnvelopeNamespaces(resultEnv));
+ callback.receiveResultdeleteBooking(
+ (com.frentix.olat.vitero.manager.stubs.BookingServiceStub.DeleteBookingResponse)object);
+
+ } catch (org.apache.axis2.AxisFault e) {
+ callback.receiveErrordeleteBooking(e);
+ }
+ }
+
+ public void onError(java.lang.Exception error) {
+ if (error instanceof org.apache.axis2.AxisFault) {
+ org.apache.axis2.AxisFault f = (org.apache.axis2.AxisFault) error;
+ org.apache.axiom.om.OMElement faultElt = f.getDetail();
+ if (faultElt!=null){
+ if (faultExceptionNameMap.containsKey(faultElt.getQName())){
+ //make the fault by reflection
+ try{
+ java.lang.String exceptionClassName = (java.lang.String)faultExceptionClassNameMap.get(faultElt.getQName());
+ java.lang.Class exceptionClass = java.lang.Class.forName(exceptionClassName);
+ java.lang.Exception ex=
+ (java.lang.Exception) exceptionClass.newInstance();
+ //message class
+ java.lang.String messageClassName = (java.lang.String)faultMessageMap.get(faultElt.getQName());
+ java.lang.Class messageClass = java.lang.Class.forName(messageClassName);
+ java.lang.Object messageObject = fromOM(faultElt,messageClass,null);
+ java.lang.reflect.Method m = exceptionClass.getMethod("setFaultMessage",
+ new java.lang.Class[]{messageClass});
+ m.invoke(ex,new java.lang.Object[]{messageObject});
+
+
+ callback.receiveErrordeleteBooking(new java.rmi.RemoteException(ex.getMessage(), ex));
+ } catch(java.lang.ClassCastException e){
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrordeleteBooking(f);
+ } catch (java.lang.ClassNotFoundException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrordeleteBooking(f);
+ } catch (java.lang.NoSuchMethodException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrordeleteBooking(f);
+ } catch (java.lang.reflect.InvocationTargetException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrordeleteBooking(f);
+ } catch (java.lang.IllegalAccessException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrordeleteBooking(f);
+ } catch (java.lang.InstantiationException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrordeleteBooking(f);
+ } catch (org.apache.axis2.AxisFault e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrordeleteBooking(f);
+ }
+ } else {
+ callback.receiveErrordeleteBooking(f);
+ }
+ } else {
+ callback.receiveErrordeleteBooking(f);
+ }
+ } else {
+ callback.receiveErrordeleteBooking(error);
+ }
+ }
+
+ public void onFault(org.apache.axis2.context.MessageContext faultContext) {
+ org.apache.axis2.AxisFault fault = org.apache.axis2.util.Utils.getInboundFaultFromMessageContext(faultContext);
+ onError(fault);
+ }
+
+ public void onComplete() {
+ try {
+ _messageContext.getTransportOut().getSender().cleanup(_messageContext);
+ } catch (org.apache.axis2.AxisFault axisFault) {
+ callback.receiveErrordeleteBooking(axisFault);
+ }
+ }
+ });
+
+
+ org.apache.axis2.util.CallbackReceiver _callbackReceiver = null;
+ if ( _operations[8].getMessageReceiver()==null && _operationClient.getOptions().isUseSeparateListener()) {
+ _callbackReceiver = new org.apache.axis2.util.CallbackReceiver();
+ _operations[8].setMessageReceiver(
+ _callbackReceiver);
+ }
+
+ //execute the operation client
+ _operationClient.execute(false);
+
+ }
+
+ /**
+ * Auto generated method signature
+ *
+ * @see com.frentix.olat.vc.provider.vitero.stubs.BookingService#getBookingByBookingTimeId
+ * @param getBookingByBookingTimeIdRequest17
+
+ */
+
+
+
+ public com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingByBookingTimeIdResponse getBookingByBookingTimeId(
+
+ com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingByBookingTimeIdRequest getBookingByBookingTimeIdRequest17)
+
+
+ throws java.rmi.RemoteException
+
+ {
+ org.apache.axis2.context.MessageContext _messageContext = null;
+ try{
+ org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[9].getName());
+ _operationClient.getOptions().setAction("\"\"");
+ _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true);
+
+
+
+ addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&");
+
+
+ // create a message context
+ _messageContext = new org.apache.axis2.context.MessageContext();
+
+
+
+ // create SOAP envelope with that payload
+ org.apache.axiom.soap.SOAPEnvelope env = null;
+
+
+ env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()),
+ getBookingByBookingTimeIdRequest17,
+ optimizeContent(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking",
+ "getBookingByBookingTimeId")));
+
+ //adding SOAP soap_headers
+ _serviceClient.addHeadersToEnvelope(env);
+ // set the message context with that soap envelope
+ _messageContext.setEnvelope(env);
+
+ // add the message contxt to the operation client
+ _operationClient.addMessageContext(_messageContext);
+
+ //execute the operation client
+ _operationClient.execute(true);
+
+
+ org.apache.axis2.context.MessageContext _returnMessageContext = _operationClient.getMessageContext(
+ org.apache.axis2.wsdl.WSDLConstants.MESSAGE_LABEL_IN_VALUE);
+ org.apache.axiom.soap.SOAPEnvelope _returnEnv = _returnMessageContext.getEnvelope();
+
+
+ java.lang.Object object = fromOM(
+ _returnEnv.getBody().getFirstElement() ,
+ com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingByBookingTimeIdResponse.class,
+ getEnvelopeNamespaces(_returnEnv));
+
+
+ return (com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingByBookingTimeIdResponse)object;
+
+ }catch(org.apache.axis2.AxisFault f){
+
+ org.apache.axiom.om.OMElement faultElt = f.getDetail();
+ if (faultElt!=null){
+ if (faultExceptionNameMap.containsKey(faultElt.getQName())){
+ //make the fault by reflection
+ try{
+ java.lang.String exceptionClassName = (java.lang.String)faultExceptionClassNameMap.get(faultElt.getQName());
+ java.lang.Class exceptionClass = java.lang.Class.forName(exceptionClassName);
+ java.lang.Exception ex=
+ (java.lang.Exception) exceptionClass.newInstance();
+ //message class
+ java.lang.String messageClassName = (java.lang.String)faultMessageMap.get(faultElt.getQName());
+ java.lang.Class messageClass = java.lang.Class.forName(messageClassName);
+ java.lang.Object messageObject = fromOM(faultElt,messageClass,null);
+ java.lang.reflect.Method m = exceptionClass.getMethod("setFaultMessage",
+ new java.lang.Class[]{messageClass});
+ m.invoke(ex,new java.lang.Object[]{messageObject});
+
+
+ throw new java.rmi.RemoteException(ex.getMessage(), ex);
+ }catch(java.lang.ClassCastException e){
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.ClassNotFoundException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ }catch (java.lang.NoSuchMethodException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.reflect.InvocationTargetException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.IllegalAccessException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.InstantiationException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ }
+ }else{
+ throw f;
+ }
+ }else{
+ throw f;
+ }
+ } finally {
+ _messageContext.getTransportOut().getSender().cleanup(_messageContext);
+ }
+ }
+
+ /**
+ * Auto generated method signature for Asynchronous Invocations
+ *
+ * @see com.frentix.olat.vc.provider.vitero.stubs.BookingService#startgetBookingByBookingTimeId
+ * @param getBookingByBookingTimeIdRequest17
+
+ */
+ public void startgetBookingByBookingTimeId(
+
+ com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingByBookingTimeIdRequest getBookingByBookingTimeIdRequest17,
+
+ final com.frentix.olat.vitero.manager.stubs.BookingServiceCallbackHandler callback)
+
+ throws java.rmi.RemoteException{
+
+ org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[9].getName());
+ _operationClient.getOptions().setAction("\"\"");
+ _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true);
+
+
+
+ addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&");
+
+
+
+ // create SOAP envelope with that payload
+ org.apache.axiom.soap.SOAPEnvelope env=null;
+ final org.apache.axis2.context.MessageContext _messageContext = new org.apache.axis2.context.MessageContext();
+
+
+ //Style is Doc.
+
+
+ env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()),
+ getBookingByBookingTimeIdRequest17,
+ optimizeContent(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking",
+ "getBookingByBookingTimeId")));
+
+ // adding SOAP soap_headers
+ _serviceClient.addHeadersToEnvelope(env);
+ // create message context with that soap envelope
+ _messageContext.setEnvelope(env);
+
+ // add the message context to the operation client
+ _operationClient.addMessageContext(_messageContext);
+
+
+
+ _operationClient.setCallback(new org.apache.axis2.client.async.AxisCallback() {
+ public void onMessage(org.apache.axis2.context.MessageContext resultContext) {
+ try {
+ org.apache.axiom.soap.SOAPEnvelope resultEnv = resultContext.getEnvelope();
+
+ java.lang.Object object = fromOM(resultEnv.getBody().getFirstElement(),
+ com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingByBookingTimeIdResponse.class,
+ getEnvelopeNamespaces(resultEnv));
+ callback.receiveResultgetBookingByBookingTimeId(
+ (com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingByBookingTimeIdResponse)object);
+
+ } catch (org.apache.axis2.AxisFault e) {
+ callback.receiveErrorgetBookingByBookingTimeId(e);
+ }
+ }
+
+ public void onError(java.lang.Exception error) {
+ if (error instanceof org.apache.axis2.AxisFault) {
+ org.apache.axis2.AxisFault f = (org.apache.axis2.AxisFault) error;
+ org.apache.axiom.om.OMElement faultElt = f.getDetail();
+ if (faultElt!=null){
+ if (faultExceptionNameMap.containsKey(faultElt.getQName())){
+ //make the fault by reflection
+ try{
+ java.lang.String exceptionClassName = (java.lang.String)faultExceptionClassNameMap.get(faultElt.getQName());
+ java.lang.Class exceptionClass = java.lang.Class.forName(exceptionClassName);
+ java.lang.Exception ex=
+ (java.lang.Exception) exceptionClass.newInstance();
+ //message class
+ java.lang.String messageClassName = (java.lang.String)faultMessageMap.get(faultElt.getQName());
+ java.lang.Class messageClass = java.lang.Class.forName(messageClassName);
+ java.lang.Object messageObject = fromOM(faultElt,messageClass,null);
+ java.lang.reflect.Method m = exceptionClass.getMethod("setFaultMessage",
+ new java.lang.Class[]{messageClass});
+ m.invoke(ex,new java.lang.Object[]{messageObject});
+
+
+ callback.receiveErrorgetBookingByBookingTimeId(new java.rmi.RemoteException(ex.getMessage(), ex));
+ } catch(java.lang.ClassCastException e){
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetBookingByBookingTimeId(f);
+ } catch (java.lang.ClassNotFoundException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetBookingByBookingTimeId(f);
+ } catch (java.lang.NoSuchMethodException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetBookingByBookingTimeId(f);
+ } catch (java.lang.reflect.InvocationTargetException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetBookingByBookingTimeId(f);
+ } catch (java.lang.IllegalAccessException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetBookingByBookingTimeId(f);
+ } catch (java.lang.InstantiationException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetBookingByBookingTimeId(f);
+ } catch (org.apache.axis2.AxisFault e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetBookingByBookingTimeId(f);
+ }
+ } else {
+ callback.receiveErrorgetBookingByBookingTimeId(f);
+ }
+ } else {
+ callback.receiveErrorgetBookingByBookingTimeId(f);
+ }
+ } else {
+ callback.receiveErrorgetBookingByBookingTimeId(error);
+ }
+ }
+
+ public void onFault(org.apache.axis2.context.MessageContext faultContext) {
+ org.apache.axis2.AxisFault fault = org.apache.axis2.util.Utils.getInboundFaultFromMessageContext(faultContext);
+ onError(fault);
+ }
+
+ public void onComplete() {
+ try {
+ _messageContext.getTransportOut().getSender().cleanup(_messageContext);
+ } catch (org.apache.axis2.AxisFault axisFault) {
+ callback.receiveErrorgetBookingByBookingTimeId(axisFault);
+ }
+ }
+ });
+
+
+ org.apache.axis2.util.CallbackReceiver _callbackReceiver = null;
+ if ( _operations[9].getMessageReceiver()==null && _operationClient.getOptions().isUseSeparateListener()) {
+ _callbackReceiver = new org.apache.axis2.util.CallbackReceiver();
+ _operations[9].setMessageReceiver(
+ _callbackReceiver);
+ }
+
+ //execute the operation client
+ _operationClient.execute(false);
+
+ }
+
+ /**
+ * Auto generated method signature
+ *
+ * @see com.frentix.olat.vc.provider.vitero.stubs.BookingService#getBookingListByGroupAndDate
+ * @param getBookingListByGroupAndDateRequest19
+
+ */
+
+
+
+ public com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingListByGroupAndDateResponse getBookingListByGroupAndDate(
+
+ com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingListByGroupAndDateRequest getBookingListByGroupAndDateRequest19)
+
+
+ throws java.rmi.RemoteException
+
+ {
+ org.apache.axis2.context.MessageContext _messageContext = null;
+ try{
+ org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[10].getName());
+ _operationClient.getOptions().setAction("\"\"");
+ _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true);
+
+
+
+ addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&");
+
+
+ // create a message context
+ _messageContext = new org.apache.axis2.context.MessageContext();
+
+
+
+ // create SOAP envelope with that payload
+ org.apache.axiom.soap.SOAPEnvelope env = null;
+
+
+ env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()),
+ getBookingListByGroupAndDateRequest19,
+ optimizeContent(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking",
+ "getBookingListByGroupAndDate")));
+
+ //adding SOAP soap_headers
+ _serviceClient.addHeadersToEnvelope(env);
+ // set the message context with that soap envelope
+ _messageContext.setEnvelope(env);
+
+ // add the message contxt to the operation client
+ _operationClient.addMessageContext(_messageContext);
+
+ //execute the operation client
+ _operationClient.execute(true);
+
+
+ org.apache.axis2.context.MessageContext _returnMessageContext = _operationClient.getMessageContext(
+ org.apache.axis2.wsdl.WSDLConstants.MESSAGE_LABEL_IN_VALUE);
+ org.apache.axiom.soap.SOAPEnvelope _returnEnv = _returnMessageContext.getEnvelope();
+
+
+ java.lang.Object object = fromOM(
+ _returnEnv.getBody().getFirstElement() ,
+ com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingListByGroupAndDateResponse.class,
+ getEnvelopeNamespaces(_returnEnv));
+
+
+ return (com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingListByGroupAndDateResponse)object;
+
+ }catch(org.apache.axis2.AxisFault f){
+
+ org.apache.axiom.om.OMElement faultElt = f.getDetail();
+ if (faultElt!=null){
+ if (faultExceptionNameMap.containsKey(faultElt.getQName())){
+ //make the fault by reflection
+ try{
+ java.lang.String exceptionClassName = (java.lang.String)faultExceptionClassNameMap.get(faultElt.getQName());
+ java.lang.Class exceptionClass = java.lang.Class.forName(exceptionClassName);
+ java.lang.Exception ex=
+ (java.lang.Exception) exceptionClass.newInstance();
+ //message class
+ java.lang.String messageClassName = (java.lang.String)faultMessageMap.get(faultElt.getQName());
+ java.lang.Class messageClass = java.lang.Class.forName(messageClassName);
+ java.lang.Object messageObject = fromOM(faultElt,messageClass,null);
+ java.lang.reflect.Method m = exceptionClass.getMethod("setFaultMessage",
+ new java.lang.Class[]{messageClass});
+ m.invoke(ex,new java.lang.Object[]{messageObject});
+
+
+ throw new java.rmi.RemoteException(ex.getMessage(), ex);
+ }catch(java.lang.ClassCastException e){
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.ClassNotFoundException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ }catch (java.lang.NoSuchMethodException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.reflect.InvocationTargetException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.IllegalAccessException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.InstantiationException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ }
+ }else{
+ throw f;
+ }
+ }else{
+ throw f;
+ }
+ } finally {
+ _messageContext.getTransportOut().getSender().cleanup(_messageContext);
+ }
+ }
+
+ /**
+ * Auto generated method signature for Asynchronous Invocations
+ *
+ * @see com.frentix.olat.vc.provider.vitero.stubs.BookingService#startgetBookingListByGroupAndDate
+ * @param getBookingListByGroupAndDateRequest19
+
+ */
+ public void startgetBookingListByGroupAndDate(
+
+ com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingListByGroupAndDateRequest getBookingListByGroupAndDateRequest19,
+
+ final com.frentix.olat.vitero.manager.stubs.BookingServiceCallbackHandler callback)
+
+ throws java.rmi.RemoteException{
+
+ org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[10].getName());
+ _operationClient.getOptions().setAction("\"\"");
+ _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true);
+
+
+
+ addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&");
+
+
+
+ // create SOAP envelope with that payload
+ org.apache.axiom.soap.SOAPEnvelope env=null;
+ final org.apache.axis2.context.MessageContext _messageContext = new org.apache.axis2.context.MessageContext();
+
+
+ //Style is Doc.
+
+
+ env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()),
+ getBookingListByGroupAndDateRequest19,
+ optimizeContent(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking",
+ "getBookingListByGroupAndDate")));
+
+ // adding SOAP soap_headers
+ _serviceClient.addHeadersToEnvelope(env);
+ // create message context with that soap envelope
+ _messageContext.setEnvelope(env);
+
+ // add the message context to the operation client
+ _operationClient.addMessageContext(_messageContext);
+
+
+
+ _operationClient.setCallback(new org.apache.axis2.client.async.AxisCallback() {
+ public void onMessage(org.apache.axis2.context.MessageContext resultContext) {
+ try {
+ org.apache.axiom.soap.SOAPEnvelope resultEnv = resultContext.getEnvelope();
+
+ java.lang.Object object = fromOM(resultEnv.getBody().getFirstElement(),
+ com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingListByGroupAndDateResponse.class,
+ getEnvelopeNamespaces(resultEnv));
+ callback.receiveResultgetBookingListByGroupAndDate(
+ (com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingListByGroupAndDateResponse)object);
+
+ } catch (org.apache.axis2.AxisFault e) {
+ callback.receiveErrorgetBookingListByGroupAndDate(e);
+ }
+ }
+
+ public void onError(java.lang.Exception error) {
+ if (error instanceof org.apache.axis2.AxisFault) {
+ org.apache.axis2.AxisFault f = (org.apache.axis2.AxisFault) error;
+ org.apache.axiom.om.OMElement faultElt = f.getDetail();
+ if (faultElt!=null){
+ if (faultExceptionNameMap.containsKey(faultElt.getQName())){
+ //make the fault by reflection
+ try{
+ java.lang.String exceptionClassName = (java.lang.String)faultExceptionClassNameMap.get(faultElt.getQName());
+ java.lang.Class exceptionClass = java.lang.Class.forName(exceptionClassName);
+ java.lang.Exception ex=
+ (java.lang.Exception) exceptionClass.newInstance();
+ //message class
+ java.lang.String messageClassName = (java.lang.String)faultMessageMap.get(faultElt.getQName());
+ java.lang.Class messageClass = java.lang.Class.forName(messageClassName);
+ java.lang.Object messageObject = fromOM(faultElt,messageClass,null);
+ java.lang.reflect.Method m = exceptionClass.getMethod("setFaultMessage",
+ new java.lang.Class[]{messageClass});
+ m.invoke(ex,new java.lang.Object[]{messageObject});
+
+
+ callback.receiveErrorgetBookingListByGroupAndDate(new java.rmi.RemoteException(ex.getMessage(), ex));
+ } catch(java.lang.ClassCastException e){
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetBookingListByGroupAndDate(f);
+ } catch (java.lang.ClassNotFoundException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetBookingListByGroupAndDate(f);
+ } catch (java.lang.NoSuchMethodException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetBookingListByGroupAndDate(f);
+ } catch (java.lang.reflect.InvocationTargetException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetBookingListByGroupAndDate(f);
+ } catch (java.lang.IllegalAccessException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetBookingListByGroupAndDate(f);
+ } catch (java.lang.InstantiationException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetBookingListByGroupAndDate(f);
+ } catch (org.apache.axis2.AxisFault e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetBookingListByGroupAndDate(f);
+ }
+ } else {
+ callback.receiveErrorgetBookingListByGroupAndDate(f);
+ }
+ } else {
+ callback.receiveErrorgetBookingListByGroupAndDate(f);
+ }
+ } else {
+ callback.receiveErrorgetBookingListByGroupAndDate(error);
+ }
+ }
+
+ public void onFault(org.apache.axis2.context.MessageContext faultContext) {
+ org.apache.axis2.AxisFault fault = org.apache.axis2.util.Utils.getInboundFaultFromMessageContext(faultContext);
+ onError(fault);
+ }
+
+ public void onComplete() {
+ try {
+ _messageContext.getTransportOut().getSender().cleanup(_messageContext);
+ } catch (org.apache.axis2.AxisFault axisFault) {
+ callback.receiveErrorgetBookingListByGroupAndDate(axisFault);
+ }
+ }
+ });
+
+
+ org.apache.axis2.util.CallbackReceiver _callbackReceiver = null;
+ if ( _operations[10].getMessageReceiver()==null && _operationClient.getOptions().isUseSeparateListener()) {
+ _callbackReceiver = new org.apache.axis2.util.CallbackReceiver();
+ _operations[10].setMessageReceiver(
+ _callbackReceiver);
+ }
+
+ //execute the operation client
+ _operationClient.execute(false);
+
+ }
+
+
+
+ /**
+ * A utility method that copies the namepaces from the SOAPEnvelope
+ */
+ private java.util.Map getEnvelopeNamespaces(org.apache.axiom.soap.SOAPEnvelope env){
+ java.util.Map returnMap = new java.util.HashMap();
+ java.util.Iterator namespaceIterator = env.getAllDeclaredNamespaces();
+ while (namespaceIterator.hasNext()) {
+ org.apache.axiom.om.OMNamespace ns = (org.apache.axiom.om.OMNamespace) namespaceIterator.next();
+ returnMap.put(ns.getPrefix(),ns.getNamespaceURI());
+ }
+ return returnMap;
+ }
+
+
+
+ private javax.xml.namespace.QName[] opNameArray = null;
+ private boolean optimizeContent(javax.xml.namespace.QName opName) {
+
+
+ if (opNameArray == null) {
+ return false;
+ }
+ for (int i = 0; i < opNameArray.length; i++) {
+ if (opName.equals(opNameArray[i])) {
+ return true;
+ }
+ }
+ return false;
+ }
+ //http://192.168.1.54:8080/vitero/services/
+ public static class GetBookingListByGroupInFutureRequest
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/booking",
+ "getBookingListByGroupInFutureRequest",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/booking")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for Groupid
+ */
+
+
+ protected int localGroupid ;
+
+
+ /**
+ * Auto generated getter method
+ * @return int
+ */
+ public int getGroupid(){
+ return localGroupid;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Groupid
+ */
+ public void setGroupid(int param){
+
+ this.localGroupid=param;
+
+
+ }
+
+
+ /**
+ * field for Timezone
+ */
+
+
+ protected java.lang.String localTimezone ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localTimezoneTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getTimezone(){
+ return localTimezone;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Timezone
+ */
+ public void setTimezone(java.lang.String param){
+
+ if (param != null){
+ //update the setting tracker
+ localTimezoneTracker = true;
+ } else {
+ localTimezoneTracker = false;
+
+ }
+
+ this.localTimezone=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ GetBookingListByGroupInFutureRequest.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/booking");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":getBookingListByGroupInFutureRequest",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "getBookingListByGroupInFutureRequest",
+ xmlWriter);
+ }
+
+
+ }
+
+ namespace = "http://www.vitero.de/schema/booking";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"groupid", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"groupid");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("groupid");
+ }
+
+ if (localGroupid==java.lang.Integer.MIN_VALUE) {
+
+ throw new org.apache.axis2.databinding.ADBException("groupid cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localGroupid));
+ }
+
+ xmlWriter.writeEndElement();
+ if (localTimezoneTracker){
+ namespace = "http://www.vitero.de/schema/booking";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"timezone", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"timezone");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("timezone");
+ }
+
+
+ if (localTimezone==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("timezone cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localTimezone);
+
+ }
+
+ xmlWriter.writeEndElement();
+ }
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking",
+ "groupid"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localGroupid));
+ if (localTimezoneTracker){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking",
+ "timezone"));
+
+ if (localTimezone != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localTimezone));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("timezone cannot be null!!");
+ }
+ }
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static GetBookingListByGroupInFutureRequest parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ GetBookingListByGroupInFutureRequest object =
+ new GetBookingListByGroupInFutureRequest();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"getBookingListByGroupInFutureRequest".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (GetBookingListByGroupInFutureRequest)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/booking","groupid").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setGroupid(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToInt(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/booking","timezone").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setTimezone(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class Booking
+ implements org.apache.axis2.databinding.ADBBean{
+ /* This type was generated from the piece of schema that had
+ name = booking
+ Namespace URI = http://www.vitero.de/schema/booking
+ Namespace Prefix = ns1
+ */
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/booking")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for Bookingid
+ */
+
+
+ protected int localBookingid ;
+
+
+ /**
+ * Auto generated getter method
+ * @return int
+ */
+ public int getBookingid(){
+ return localBookingid;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Bookingid
+ */
+ public void setBookingid(int param){
+
+ this.localBookingid=param;
+
+
+ }
+
+
+ /**
+ * field for Groupid
+ */
+
+
+ protected int localGroupid ;
+
+
+ /**
+ * Auto generated getter method
+ * @return int
+ */
+ public int getGroupid(){
+ return localGroupid;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Groupid
+ */
+ public void setGroupid(int param){
+
+ this.localGroupid=param;
+
+
+ }
+
+
+ /**
+ * field for Roomsize
+ */
+
+
+ protected int localRoomsize ;
+
+
+ /**
+ * Auto generated getter method
+ * @return int
+ */
+ public int getRoomsize(){
+ return localRoomsize;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Roomsize
+ */
+ public void setRoomsize(int param){
+
+ this.localRoomsize=param;
+
+
+ }
+
+
+ /**
+ * field for Cafe
+ */
+
+
+ protected boolean localCafe ;
+
+
+ /**
+ * Auto generated getter method
+ * @return boolean
+ */
+ public boolean getCafe(){
+ return localCafe;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Cafe
+ */
+ public void setCafe(boolean param){
+
+ this.localCafe=param;
+
+
+ }
+
+
+ /**
+ * field for Capture
+ */
+
+
+ protected boolean localCapture ;
+
+
+ /**
+ * Auto generated getter method
+ * @return boolean
+ */
+ public boolean getCapture(){
+ return localCapture;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Capture
+ */
+ public void setCapture(boolean param){
+
+ this.localCapture=param;
+
+
+ }
+
+
+ /**
+ * field for Phone
+ */
+
+
+ protected Phonetype localPhone ;
+
+
+ /**
+ * Auto generated getter method
+ * @return Phonetype
+ */
+ public Phonetype getPhone(){
+ return localPhone;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Phone
+ */
+ public void setPhone(Phonetype param){
+
+ this.localPhone=param;
+
+
+ }
+
+
+ /**
+ * field for Pcstateokrequired
+ */
+
+
+ protected boolean localPcstateokrequired ;
+
+
+ /**
+ * Auto generated getter method
+ * @return boolean
+ */
+ public boolean getPcstateokrequired(){
+ return localPcstateokrequired;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Pcstateokrequired
+ */
+ public void setPcstateokrequired(boolean param){
+
+ this.localPcstateokrequired=param;
+
+
+ }
+
+
+ /**
+ * field for Start
+ */
+
+
+ protected java.lang.String localStart ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getStart(){
+ return localStart;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Start
+ */
+ public void setStart(java.lang.String param){
+
+ this.localStart=param;
+
+
+ }
+
+
+ /**
+ * field for End
+ */
+
+
+ protected java.lang.String localEnd ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getEnd(){
+ return localEnd;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param End
+ */
+ public void setEnd(java.lang.String param){
+
+ this.localEnd=param;
+
+
+ }
+
+
+ /**
+ * field for Startbuffer
+ */
+
+
+ protected int localStartbuffer ;
+
+
+ /**
+ * Auto generated getter method
+ * @return int
+ */
+ public int getStartbuffer(){
+ return localStartbuffer;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Startbuffer
+ */
+ public void setStartbuffer(int param){
+
+ this.localStartbuffer=param;
+
+
+ }
+
+
+ /**
+ * field for Endbuffer
+ */
+
+
+ protected int localEndbuffer ;
+
+
+ /**
+ * Auto generated getter method
+ * @return int
+ */
+ public int getEndbuffer(){
+ return localEndbuffer;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Endbuffer
+ */
+ public void setEndbuffer(int param){
+
+ this.localEndbuffer=param;
+
+
+ }
+
+
+ /**
+ * field for Repetitionpattern
+ */
+
+
+ protected java.lang.String localRepetitionpattern ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getRepetitionpattern(){
+ return localRepetitionpattern;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Repetitionpattern
+ */
+ public void setRepetitionpattern(java.lang.String param){
+
+ this.localRepetitionpattern=param;
+
+
+ }
+
+
+ /**
+ * field for Repetitionenddate
+ */
+
+
+ protected java.lang.String localRepetitionenddate ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localRepetitionenddateTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getRepetitionenddate(){
+ return localRepetitionenddate;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Repetitionenddate
+ */
+ public void setRepetitionenddate(java.lang.String param){
+
+ if (param != null){
+ //update the setting tracker
+ localRepetitionenddateTracker = true;
+ } else {
+ localRepetitionenddateTracker = false;
+
+ }
+
+ this.localRepetitionenddate=param;
+
+
+ }
+
+
+ /**
+ * field for Addexceptions
+ */
+
+
+ protected Addexceptions_type0 localAddexceptions ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localAddexceptionsTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return Addexceptions_type0
+ */
+ public Addexceptions_type0 getAddexceptions(){
+ return localAddexceptions;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Addexceptions
+ */
+ public void setAddexceptions(Addexceptions_type0 param){
+
+ if (param != null){
+ //update the setting tracker
+ localAddexceptionsTracker = true;
+ } else {
+ localAddexceptionsTracker = false;
+
+ }
+
+ this.localAddexceptions=param;
+
+
+ }
+
+
+ /**
+ * field for Subtractexceptions
+ */
+
+
+ protected Subtractexceptions_type0 localSubtractexceptions ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localSubtractexceptionsTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return Subtractexceptions_type0
+ */
+ public Subtractexceptions_type0 getSubtractexceptions(){
+ return localSubtractexceptions;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Subtractexceptions
+ */
+ public void setSubtractexceptions(Subtractexceptions_type0 param){
+
+ if (param != null){
+ //update the setting tracker
+ localSubtractexceptionsTracker = true;
+ } else {
+ localSubtractexceptionsTracker = false;
+
+ }
+
+ this.localSubtractexceptions=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,parentQName){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ Booking.this.serialize(parentQName,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ parentQName,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/booking");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":booking",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "booking",
+ xmlWriter);
+ }
+
+
+ }
+
+ namespace = "http://www.vitero.de/schema/booking";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"bookingid", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"bookingid");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("bookingid");
+ }
+
+ if (localBookingid==java.lang.Integer.MIN_VALUE) {
+
+ throw new org.apache.axis2.databinding.ADBException("bookingid cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localBookingid));
+ }
+
+ xmlWriter.writeEndElement();
+
+ namespace = "http://www.vitero.de/schema/booking";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"groupid", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"groupid");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("groupid");
+ }
+
+ if (localGroupid==java.lang.Integer.MIN_VALUE) {
+
+ throw new org.apache.axis2.databinding.ADBException("groupid cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localGroupid));
+ }
+
+ xmlWriter.writeEndElement();
+
+ namespace = "http://www.vitero.de/schema/booking";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"roomsize", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"roomsize");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("roomsize");
+ }
+
+ if (localRoomsize==java.lang.Integer.MIN_VALUE) {
+
+ throw new org.apache.axis2.databinding.ADBException("roomsize cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localRoomsize));
+ }
+
+ xmlWriter.writeEndElement();
+
+ namespace = "http://www.vitero.de/schema/booking";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"cafe", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"cafe");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("cafe");
+ }
+
+ if (false) {
+
+ throw new org.apache.axis2.databinding.ADBException("cafe cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localCafe));
+ }
+
+ xmlWriter.writeEndElement();
+
+ namespace = "http://www.vitero.de/schema/booking";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"capture", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"capture");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("capture");
+ }
+
+ if (false) {
+
+ throw new org.apache.axis2.databinding.ADBException("capture cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localCapture));
+ }
+
+ xmlWriter.writeEndElement();
+
+ if (localPhone==null){
+ throw new org.apache.axis2.databinding.ADBException("phone cannot be null!!");
+ }
+ localPhone.serialize(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking","phone"),
+ factory,xmlWriter);
+
+ namespace = "http://www.vitero.de/schema/booking";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"pcstateokrequired", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"pcstateokrequired");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("pcstateokrequired");
+ }
+
+ if (false) {
+
+ throw new org.apache.axis2.databinding.ADBException("pcstateokrequired cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localPcstateokrequired));
+ }
+
+ xmlWriter.writeEndElement();
+
+ namespace = "http://www.vitero.de/schema/booking";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"start", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"start");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("start");
+ }
+
+
+ if (localStart==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("start cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localStart);
+
+ }
+
+ xmlWriter.writeEndElement();
+
+ namespace = "http://www.vitero.de/schema/booking";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"end", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"end");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("end");
+ }
+
+
+ if (localEnd==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("end cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localEnd);
+
+ }
+
+ xmlWriter.writeEndElement();
+
+ namespace = "http://www.vitero.de/schema/booking";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"startbuffer", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"startbuffer");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("startbuffer");
+ }
+
+ if (localStartbuffer==java.lang.Integer.MIN_VALUE) {
+
+ throw new org.apache.axis2.databinding.ADBException("startbuffer cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localStartbuffer));
+ }
+
+ xmlWriter.writeEndElement();
+
+ namespace = "http://www.vitero.de/schema/booking";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"endbuffer", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"endbuffer");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("endbuffer");
+ }
+
+ if (localEndbuffer==java.lang.Integer.MIN_VALUE) {
+
+ throw new org.apache.axis2.databinding.ADBException("endbuffer cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localEndbuffer));
+ }
+
+ xmlWriter.writeEndElement();
+
+ namespace = "http://www.vitero.de/schema/booking";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"repetitionpattern", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"repetitionpattern");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("repetitionpattern");
+ }
+
+
+ if (localRepetitionpattern==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("repetitionpattern cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localRepetitionpattern);
+
+ }
+
+ xmlWriter.writeEndElement();
+ if (localRepetitionenddateTracker){
+ namespace = "http://www.vitero.de/schema/booking";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"repetitionenddate", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"repetitionenddate");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("repetitionenddate");
+ }
+
+
+ if (localRepetitionenddate==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("repetitionenddate cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localRepetitionenddate);
+
+ }
+
+ xmlWriter.writeEndElement();
+ } if (localAddexceptionsTracker){
+ if (localAddexceptions==null){
+ throw new org.apache.axis2.databinding.ADBException("addexceptions cannot be null!!");
+ }
+ localAddexceptions.serialize(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking","addexceptions"),
+ factory,xmlWriter);
+ } if (localSubtractexceptionsTracker){
+ if (localSubtractexceptions==null){
+ throw new org.apache.axis2.databinding.ADBException("subtractexceptions cannot be null!!");
+ }
+ localSubtractexceptions.serialize(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking","subtractexceptions"),
+ factory,xmlWriter);
+ }
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking",
+ "bookingid"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localBookingid));
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking",
+ "groupid"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localGroupid));
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking",
+ "roomsize"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localRoomsize));
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking",
+ "cafe"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localCafe));
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking",
+ "capture"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localCapture));
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking",
+ "phone"));
+
+
+ if (localPhone==null){
+ throw new org.apache.axis2.databinding.ADBException("phone cannot be null!!");
+ }
+ elementList.add(localPhone);
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking",
+ "pcstateokrequired"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localPcstateokrequired));
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking",
+ "start"));
+
+ if (localStart != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localStart));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("start cannot be null!!");
+ }
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking",
+ "end"));
+
+ if (localEnd != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localEnd));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("end cannot be null!!");
+ }
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking",
+ "startbuffer"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localStartbuffer));
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking",
+ "endbuffer"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localEndbuffer));
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking",
+ "repetitionpattern"));
+
+ if (localRepetitionpattern != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localRepetitionpattern));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("repetitionpattern cannot be null!!");
+ }
+ if (localRepetitionenddateTracker){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking",
+ "repetitionenddate"));
+
+ if (localRepetitionenddate != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localRepetitionenddate));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("repetitionenddate cannot be null!!");
+ }
+ } if (localAddexceptionsTracker){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking",
+ "addexceptions"));
+
+
+ if (localAddexceptions==null){
+ throw new org.apache.axis2.databinding.ADBException("addexceptions cannot be null!!");
+ }
+ elementList.add(localAddexceptions);
+ } if (localSubtractexceptionsTracker){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking",
+ "subtractexceptions"));
+
+
+ if (localSubtractexceptions==null){
+ throw new org.apache.axis2.databinding.ADBException("subtractexceptions cannot be null!!");
+ }
+ elementList.add(localSubtractexceptions);
+ }
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static Booking parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ Booking object =
+ new Booking();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"booking".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (Booking)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/booking","bookingid").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setBookingid(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToInt(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/booking","groupid").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setGroupid(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToInt(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/booking","roomsize").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setRoomsize(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToInt(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/booking","cafe").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setCafe(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToBoolean(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/booking","capture").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setCapture(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToBoolean(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/booking","phone").equals(reader.getName())){
+
+ object.setPhone(Phonetype.Factory.parse(reader));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/booking","pcstateokrequired").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setPcstateokrequired(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToBoolean(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/booking","start").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setStart(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/booking","end").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setEnd(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/booking","startbuffer").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setStartbuffer(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToInt(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/booking","endbuffer").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setEndbuffer(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToInt(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/booking","repetitionpattern").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setRepetitionpattern(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/booking","repetitionenddate").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setRepetitionenddate(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/booking","addexceptions").equals(reader.getName())){
+
+ object.setAddexceptions(Addexceptions_type0.Factory.parse(reader));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/booking","subtractexceptions").equals(reader.getName())){
+
+ object.setSubtractexceptions(Subtractexceptions_type0.Factory.parse(reader));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class SuccessResponse
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/booking",
+ "successResponse",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/booking")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for Request
+ */
+
+
+ protected java.lang.String localRequest ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getRequest(){
+ return localRequest;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Request
+ */
+ public void setRequest(java.lang.String param){
+
+ this.localRequest=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ SuccessResponse.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/booking");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":successResponse",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "successResponse",
+ xmlWriter);
+ }
+
+
+ }
+
+ namespace = "http://www.vitero.de/schema/booking";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"request", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"request");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("request");
+ }
+
+
+ if (localRequest==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("request cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localRequest);
+
+ }
+
+ xmlWriter.writeEndElement();
+
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking",
+ "request"));
+
+ if (localRequest != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localRequest));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("request cannot be null!!");
+ }
+
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static SuccessResponse parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ SuccessResponse object =
+ new SuccessResponse();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"successResponse".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (SuccessResponse)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/booking","request").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setRequest(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class CreateBookingResponse
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/booking",
+ "createBookingResponse",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/booking")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for Bookingid
+ */
+
+
+ protected int localBookingid ;
+
+
+ /**
+ * Auto generated getter method
+ * @return int
+ */
+ public int getBookingid(){
+ return localBookingid;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Bookingid
+ */
+ public void setBookingid(int param){
+
+ this.localBookingid=param;
+
+
+ }
+
+
+ /**
+ * field for Bookingcollision
+ */
+
+
+ protected boolean localBookingcollision ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localBookingcollisionTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return boolean
+ */
+ public boolean getBookingcollision(){
+ return localBookingcollision;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Bookingcollision
+ */
+ public void setBookingcollision(boolean param){
+
+ // setting primitive attribute tracker to true
+
+ if (false) {
+ localBookingcollisionTracker = false;
+
+ } else {
+ localBookingcollisionTracker = true;
+ }
+
+ this.localBookingcollision=param;
+
+
+ }
+
+
+ /**
+ * field for Modulecollision
+ */
+
+
+ protected boolean localModulecollision ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localModulecollisionTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return boolean
+ */
+ public boolean getModulecollision(){
+ return localModulecollision;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Modulecollision
+ */
+ public void setModulecollision(boolean param){
+
+ // setting primitive attribute tracker to true
+
+ if (false) {
+ localModulecollisionTracker = false;
+
+ } else {
+ localModulecollisionTracker = true;
+ }
+
+ this.localModulecollision=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ CreateBookingResponse.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/booking");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":createBookingResponse",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "createBookingResponse",
+ xmlWriter);
+ }
+
+
+ }
+
+ namespace = "http://www.vitero.de/schema/booking";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"bookingid", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"bookingid");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("bookingid");
+ }
+
+ if (localBookingid==java.lang.Integer.MIN_VALUE) {
+
+ throw new org.apache.axis2.databinding.ADBException("bookingid cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localBookingid));
+ }
+
+ xmlWriter.writeEndElement();
+ if (localBookingcollisionTracker){
+ namespace = "http://www.vitero.de/schema/booking";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"bookingcollision", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"bookingcollision");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("bookingcollision");
+ }
+
+ if (false) {
+
+ throw new org.apache.axis2.databinding.ADBException("bookingcollision cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localBookingcollision));
+ }
+
+ xmlWriter.writeEndElement();
+ } if (localModulecollisionTracker){
+ namespace = "http://www.vitero.de/schema/booking";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"modulecollision", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"modulecollision");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("modulecollision");
+ }
+
+ if (false) {
+
+ throw new org.apache.axis2.databinding.ADBException("modulecollision cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localModulecollision));
+ }
+
+ xmlWriter.writeEndElement();
+ }
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking",
+ "bookingid"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localBookingid));
+ if (localBookingcollisionTracker){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking",
+ "bookingcollision"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localBookingcollision));
+ } if (localModulecollisionTracker){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking",
+ "modulecollision"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localModulecollision));
+ }
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static CreateBookingResponse parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ CreateBookingResponse object =
+ new CreateBookingResponse();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"createBookingResponse".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (CreateBookingResponse)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/booking","bookingid").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setBookingid(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToInt(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/booking","bookingcollision").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setBookingcollision(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToBoolean(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/booking","modulecollision").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setModulecollision(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToBoolean(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class GetBookingByIdRequest
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/booking",
+ "getBookingByIdRequest",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/booking")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for GetBookingByIdRequest
+ */
+
+
+ protected Bookingid localGetBookingByIdRequest ;
+
+
+ /**
+ * Auto generated getter method
+ * @return Bookingid
+ */
+ public Bookingid getGetBookingByIdRequest(){
+ return localGetBookingByIdRequest;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param GetBookingByIdRequest
+ */
+ public void setGetBookingByIdRequest(Bookingid param){
+
+ this.localGetBookingByIdRequest=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ GetBookingByIdRequest.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+ //We can safely assume an element has only one type associated with it
+
+ if (localGetBookingByIdRequest==null){
+ throw new org.apache.axis2.databinding.ADBException("Property cannot be null!");
+ }
+ localGetBookingByIdRequest.serialize(MY_QNAME,factory,xmlWriter);
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+
+ //We can safely assume an element has only one type associated with it
+ return localGetBookingByIdRequest.getPullParser(MY_QNAME);
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static GetBookingByIdRequest parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ GetBookingByIdRequest object =
+ new GetBookingByIdRequest();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/booking","getBookingByIdRequest").equals(reader.getName())){
+
+ object.setGetBookingByIdRequest(Bookingid.Factory.parse(reader));
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class Bookingtimeid
+ implements org.apache.axis2.databinding.ADBBean{
+ /* This type was generated from the piece of schema that had
+ name = bookingtimeid
+ Namespace URI = http://www.vitero.de/schema/booking
+ Namespace Prefix = ns1
+ */
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/booking")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for Bookingtimeid
+ */
+
+
+ protected int localBookingtimeid ;
+
+
+ /**
+ * Auto generated getter method
+ * @return int
+ */
+ public int getBookingtimeid(){
+ return localBookingtimeid;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Bookingtimeid
+ */
+ public void setBookingtimeid(int param){
+
+ this.localBookingtimeid=param;
+
+
+ }
+
+
+ /**
+ * field for Timezone
+ */
+
+
+ protected java.lang.String localTimezone ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localTimezoneTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getTimezone(){
+ return localTimezone;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Timezone
+ */
+ public void setTimezone(java.lang.String param){
+
+ if (param != null){
+ //update the setting tracker
+ localTimezoneTracker = true;
+ } else {
+ localTimezoneTracker = false;
+
+ }
+
+ this.localTimezone=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,parentQName){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ Bookingtimeid.this.serialize(parentQName,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ parentQName,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/booking");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":bookingtimeid",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "bookingtimeid",
+ xmlWriter);
+ }
+
+
+ }
+
+ namespace = "http://www.vitero.de/schema/booking";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"bookingtimeid", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"bookingtimeid");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("bookingtimeid");
+ }
+
+ if (localBookingtimeid==java.lang.Integer.MIN_VALUE) {
+
+ throw new org.apache.axis2.databinding.ADBException("bookingtimeid cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localBookingtimeid));
+ }
+
+ xmlWriter.writeEndElement();
+ if (localTimezoneTracker){
+ namespace = "http://www.vitero.de/schema/booking";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"timezone", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"timezone");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("timezone");
+ }
+
+
+ if (localTimezone==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("timezone cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localTimezone);
+
+ }
+
+ xmlWriter.writeEndElement();
+ }
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking",
+ "bookingtimeid"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localBookingtimeid));
+ if (localTimezoneTracker){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking",
+ "timezone"));
+
+ if (localTimezone != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localTimezone));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("timezone cannot be null!!");
+ }
+ }
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static Bookingtimeid parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ Bookingtimeid object =
+ new Bookingtimeid();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"bookingtimeid".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (Bookingtimeid)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/booking","bookingtimeid").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setBookingtimeid(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToInt(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/booking","timezone").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setTimezone(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class Bookingtime_type0
+ implements org.apache.axis2.databinding.ADBBean{
+ /* This type was generated from the piece of schema that had
+ name = bookingtime_type0
+ Namespace URI = http://www.vitero.de/schema/booking
+ Namespace Prefix = ns1
+ */
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/booking")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for Bookingtimeid
+ */
+
+
+ protected int localBookingtimeid ;
+
+
+ /**
+ * Auto generated getter method
+ * @return int
+ */
+ public int getBookingtimeid(){
+ return localBookingtimeid;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Bookingtimeid
+ */
+ public void setBookingtimeid(int param){
+
+ this.localBookingtimeid=param;
+
+
+ }
+
+
+ /**
+ * field for Roomsize
+ */
+
+
+ protected int localRoomsize ;
+
+
+ /**
+ * Auto generated getter method
+ * @return int
+ */
+ public int getRoomsize(){
+ return localRoomsize;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Roomsize
+ */
+ public void setRoomsize(int param){
+
+ this.localRoomsize=param;
+
+
+ }
+
+
+ /**
+ * field for Start
+ */
+
+
+ protected java.lang.String localStart ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getStart(){
+ return localStart;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Start
+ */
+ public void setStart(java.lang.String param){
+
+ this.localStart=param;
+
+
+ }
+
+
+ /**
+ * field for End
+ */
+
+
+ protected java.lang.String localEnd ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getEnd(){
+ return localEnd;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param End
+ */
+ public void setEnd(java.lang.String param){
+
+ this.localEnd=param;
+
+
+ }
+
+
+ /**
+ * field for Startbuffer
+ */
+
+
+ protected int localStartbuffer ;
+
+
+ /**
+ * Auto generated getter method
+ * @return int
+ */
+ public int getStartbuffer(){
+ return localStartbuffer;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Startbuffer
+ */
+ public void setStartbuffer(int param){
+
+ this.localStartbuffer=param;
+
+
+ }
+
+
+ /**
+ * field for Endbuffer
+ */
+
+
+ protected int localEndbuffer ;
+
+
+ /**
+ * Auto generated getter method
+ * @return int
+ */
+ public int getEndbuffer(){
+ return localEndbuffer;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Endbuffer
+ */
+ public void setEndbuffer(int param){
+
+ this.localEndbuffer=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,parentQName){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ Bookingtime_type0.this.serialize(parentQName,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ parentQName,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/booking");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":bookingtime_type0",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "bookingtime_type0",
+ xmlWriter);
+ }
+
+
+ }
+
+ namespace = "http://www.vitero.de/schema/booking";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"bookingtimeid", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"bookingtimeid");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("bookingtimeid");
+ }
+
+ if (localBookingtimeid==java.lang.Integer.MIN_VALUE) {
+
+ throw new org.apache.axis2.databinding.ADBException("bookingtimeid cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localBookingtimeid));
+ }
+
+ xmlWriter.writeEndElement();
+
+ namespace = "http://www.vitero.de/schema/booking";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"roomsize", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"roomsize");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("roomsize");
+ }
+
+ if (localRoomsize==java.lang.Integer.MIN_VALUE) {
+
+ throw new org.apache.axis2.databinding.ADBException("roomsize cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localRoomsize));
+ }
+
+ xmlWriter.writeEndElement();
+
+ namespace = "http://www.vitero.de/schema/booking";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"start", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"start");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("start");
+ }
+
+
+ if (localStart==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("start cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localStart);
+
+ }
+
+ xmlWriter.writeEndElement();
+
+ namespace = "http://www.vitero.de/schema/booking";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"end", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"end");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("end");
+ }
+
+
+ if (localEnd==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("end cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localEnd);
+
+ }
+
+ xmlWriter.writeEndElement();
+
+ namespace = "http://www.vitero.de/schema/booking";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"startbuffer", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"startbuffer");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("startbuffer");
+ }
+
+ if (localStartbuffer==java.lang.Integer.MIN_VALUE) {
+
+ throw new org.apache.axis2.databinding.ADBException("startbuffer cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localStartbuffer));
+ }
+
+ xmlWriter.writeEndElement();
+
+ namespace = "http://www.vitero.de/schema/booking";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"endbuffer", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"endbuffer");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("endbuffer");
+ }
+
+ if (localEndbuffer==java.lang.Integer.MIN_VALUE) {
+
+ throw new org.apache.axis2.databinding.ADBException("endbuffer cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localEndbuffer));
+ }
+
+ xmlWriter.writeEndElement();
+
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking",
+ "bookingtimeid"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localBookingtimeid));
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking",
+ "roomsize"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localRoomsize));
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking",
+ "start"));
+
+ if (localStart != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localStart));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("start cannot be null!!");
+ }
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking",
+ "end"));
+
+ if (localEnd != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localEnd));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("end cannot be null!!");
+ }
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking",
+ "startbuffer"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localStartbuffer));
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking",
+ "endbuffer"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localEndbuffer));
+
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static Bookingtime_type0 parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ Bookingtime_type0 object =
+ new Bookingtime_type0();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"bookingtime_type0".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (Bookingtime_type0)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/booking","bookingtimeid").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setBookingtimeid(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToInt(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/booking","roomsize").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setRoomsize(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToInt(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/booking","start").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setStart(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/booking","end").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setEnd(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/booking","startbuffer").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setStartbuffer(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToInt(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/booking","endbuffer").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setEndbuffer(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToInt(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class GetBookingListByUserInFutureRequest
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/booking",
+ "getBookingListByUserInFutureRequest",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/booking")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for Userid
+ */
+
+
+ protected int localUserid ;
+
+
+ /**
+ * Auto generated getter method
+ * @return int
+ */
+ public int getUserid(){
+ return localUserid;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Userid
+ */
+ public void setUserid(int param){
+
+ this.localUserid=param;
+
+
+ }
+
+
+ /**
+ * field for Timezone
+ */
+
+
+ protected java.lang.String localTimezone ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localTimezoneTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getTimezone(){
+ return localTimezone;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Timezone
+ */
+ public void setTimezone(java.lang.String param){
+
+ if (param != null){
+ //update the setting tracker
+ localTimezoneTracker = true;
+ } else {
+ localTimezoneTracker = false;
+
+ }
+
+ this.localTimezone=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ GetBookingListByUserInFutureRequest.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/booking");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":getBookingListByUserInFutureRequest",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "getBookingListByUserInFutureRequest",
+ xmlWriter);
+ }
+
+
+ }
+
+ namespace = "http://www.vitero.de/schema/booking";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"userid", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"userid");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("userid");
+ }
+
+ if (localUserid==java.lang.Integer.MIN_VALUE) {
+
+ throw new org.apache.axis2.databinding.ADBException("userid cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localUserid));
+ }
+
+ xmlWriter.writeEndElement();
+ if (localTimezoneTracker){
+ namespace = "http://www.vitero.de/schema/booking";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"timezone", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"timezone");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("timezone");
+ }
+
+
+ if (localTimezone==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("timezone cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localTimezone);
+
+ }
+
+ xmlWriter.writeEndElement();
+ }
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking",
+ "userid"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localUserid));
+ if (localTimezoneTracker){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking",
+ "timezone"));
+
+ if (localTimezone != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localTimezone));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("timezone cannot be null!!");
+ }
+ }
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static GetBookingListByUserInFutureRequest parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ GetBookingListByUserInFutureRequest object =
+ new GetBookingListByUserInFutureRequest();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"getBookingListByUserInFutureRequest".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (GetBookingListByUserInFutureRequest)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/booking","userid").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setUserid(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToInt(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/booking","timezone").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setTimezone(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class DeleteBookingRequest
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/booking",
+ "deleteBookingRequest",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/booking")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for Bookingid
+ */
+
+
+ protected int localBookingid ;
+
+
+ /**
+ * Auto generated getter method
+ * @return int
+ */
+ public int getBookingid(){
+ return localBookingid;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Bookingid
+ */
+ public void setBookingid(int param){
+
+ this.localBookingid=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ DeleteBookingRequest.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/booking");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":deleteBookingRequest",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "deleteBookingRequest",
+ xmlWriter);
+ }
+
+
+ }
+
+ namespace = "http://www.vitero.de/schema/booking";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"bookingid", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"bookingid");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("bookingid");
+ }
+
+ if (localBookingid==java.lang.Integer.MIN_VALUE) {
+
+ throw new org.apache.axis2.databinding.ADBException("bookingid cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localBookingid));
+ }
+
+ xmlWriter.writeEndElement();
+
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking",
+ "bookingid"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localBookingid));
+
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static DeleteBookingRequest parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ DeleteBookingRequest object =
+ new DeleteBookingRequest();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"deleteBookingRequest".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (DeleteBookingRequest)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/booking","bookingid").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setBookingid(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToInt(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class GetBookingListByUserAndDateRequest
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/booking",
+ "getBookingListByUserAndDateRequest",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/booking")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for Userid
+ */
+
+
+ protected int localUserid ;
+
+
+ /**
+ * Auto generated getter method
+ * @return int
+ */
+ public int getUserid(){
+ return localUserid;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Userid
+ */
+ public void setUserid(int param){
+
+ this.localUserid=param;
+
+
+ }
+
+
+ /**
+ * field for Start
+ */
+
+
+ protected java.lang.String localStart ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getStart(){
+ return localStart;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Start
+ */
+ public void setStart(java.lang.String param){
+
+ this.localStart=param;
+
+
+ }
+
+
+ /**
+ * field for End
+ */
+
+
+ protected java.lang.String localEnd ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getEnd(){
+ return localEnd;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param End
+ */
+ public void setEnd(java.lang.String param){
+
+ this.localEnd=param;
+
+
+ }
+
+
+ /**
+ * field for Timezone
+ */
+
+
+ protected java.lang.String localTimezone ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localTimezoneTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getTimezone(){
+ return localTimezone;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Timezone
+ */
+ public void setTimezone(java.lang.String param){
+
+ if (param != null){
+ //update the setting tracker
+ localTimezoneTracker = true;
+ } else {
+ localTimezoneTracker = false;
+
+ }
+
+ this.localTimezone=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ GetBookingListByUserAndDateRequest.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/booking");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":getBookingListByUserAndDateRequest",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "getBookingListByUserAndDateRequest",
+ xmlWriter);
+ }
+
+
+ }
+
+ namespace = "http://www.vitero.de/schema/booking";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"userid", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"userid");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("userid");
+ }
+
+ if (localUserid==java.lang.Integer.MIN_VALUE) {
+
+ throw new org.apache.axis2.databinding.ADBException("userid cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localUserid));
+ }
+
+ xmlWriter.writeEndElement();
+
+ namespace = "http://www.vitero.de/schema/booking";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"start", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"start");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("start");
+ }
+
+
+ if (localStart==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("start cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localStart);
+
+ }
+
+ xmlWriter.writeEndElement();
+
+ namespace = "http://www.vitero.de/schema/booking";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"end", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"end");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("end");
+ }
+
+
+ if (localEnd==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("end cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localEnd);
+
+ }
+
+ xmlWriter.writeEndElement();
+ if (localTimezoneTracker){
+ namespace = "http://www.vitero.de/schema/booking";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"timezone", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"timezone");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("timezone");
+ }
+
+
+ if (localTimezone==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("timezone cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localTimezone);
+
+ }
+
+ xmlWriter.writeEndElement();
+ }
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking",
+ "userid"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localUserid));
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking",
+ "start"));
+
+ if (localStart != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localStart));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("start cannot be null!!");
+ }
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking",
+ "end"));
+
+ if (localEnd != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localEnd));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("end cannot be null!!");
+ }
+ if (localTimezoneTracker){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking",
+ "timezone"));
+
+ if (localTimezone != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localTimezone));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("timezone cannot be null!!");
+ }
+ }
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static GetBookingListByUserAndDateRequest parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ GetBookingListByUserAndDateRequest object =
+ new GetBookingListByUserAndDateRequest();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"getBookingListByUserAndDateRequest".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (GetBookingListByUserAndDateRequest)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/booking","userid").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setUserid(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToInt(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/booking","start").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setStart(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/booking","end").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setEnd(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/booking","timezone").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setTimezone(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class Bookingtime_type1
+ implements org.apache.axis2.databinding.ADBBean{
+ /* This type was generated from the piece of schema that had
+ name = bookingtime_type1
+ Namespace URI = http://www.vitero.de/schema/booking
+ Namespace Prefix = ns1
+ */
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/booking")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for Start
+ */
+
+
+ protected java.lang.String localStart ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getStart(){
+ return localStart;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Start
+ */
+ public void setStart(java.lang.String param){
+
+ this.localStart=param;
+
+
+ }
+
+
+ /**
+ * field for End
+ */
+
+
+ protected java.lang.String localEnd ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getEnd(){
+ return localEnd;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param End
+ */
+ public void setEnd(java.lang.String param){
+
+ this.localEnd=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,parentQName){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ Bookingtime_type1.this.serialize(parentQName,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ parentQName,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/booking");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":bookingtime_type1",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "bookingtime_type1",
+ xmlWriter);
+ }
+
+
+ }
+
+ namespace = "http://www.vitero.de/schema/booking";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"start", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"start");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("start");
+ }
+
+
+ if (localStart==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("start cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localStart);
+
+ }
+
+ xmlWriter.writeEndElement();
+
+ namespace = "http://www.vitero.de/schema/booking";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"end", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"end");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("end");
+ }
+
+
+ if (localEnd==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("end cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localEnd);
+
+ }
+
+ xmlWriter.writeEndElement();
+
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking",
+ "start"));
+
+ if (localStart != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localStart));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("start cannot be null!!");
+ }
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking",
+ "end"));
+
+ if (localEnd != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localEnd));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("end cannot be null!!");
+ }
+
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static Bookingtime_type1 parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ Bookingtime_type1 object =
+ new Bookingtime_type1();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"bookingtime_type1".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (Bookingtime_type1)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/booking","start").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setStart(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/booking","end").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setEnd(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class GetBookingListByUserAndDateResponse
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/booking",
+ "getBookingListByUserAndDateResponse",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/booking")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for GetBookingListByUserAndDateResponse
+ */
+
+
+ protected Bookinglist localGetBookingListByUserAndDateResponse ;
+
+
+ /**
+ * Auto generated getter method
+ * @return Bookinglist
+ */
+ public Bookinglist getGetBookingListByUserAndDateResponse(){
+ return localGetBookingListByUserAndDateResponse;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param GetBookingListByUserAndDateResponse
+ */
+ public void setGetBookingListByUserAndDateResponse(Bookinglist param){
+
+ this.localGetBookingListByUserAndDateResponse=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ GetBookingListByUserAndDateResponse.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+ //We can safely assume an element has only one type associated with it
+
+ if (localGetBookingListByUserAndDateResponse==null){
+ throw new org.apache.axis2.databinding.ADBException("Property cannot be null!");
+ }
+ localGetBookingListByUserAndDateResponse.serialize(MY_QNAME,factory,xmlWriter);
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+
+ //We can safely assume an element has only one type associated with it
+ return localGetBookingListByUserAndDateResponse.getPullParser(MY_QNAME);
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static GetBookingListByUserAndDateResponse parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ GetBookingListByUserAndDateResponse object =
+ new GetBookingListByUserAndDateResponse();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/booking","getBookingListByUserAndDateResponse").equals(reader.getName())){
+
+ object.setGetBookingListByUserAndDateResponse(Bookinglist.Factory.parse(reader));
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class ExtensionMapper{
+
+ public static java.lang.Object getTypeObject(java.lang.String namespaceURI,
+ java.lang.String typeName,
+ javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+
+
+ if (
+ "http://www.vitero.de/schema/booking".equals(namespaceURI) &&
+ "subtractexceptions_type0".equals(typeName)){
+
+ return Subtractexceptions_type0.Factory.parse(reader);
+
+
+ }
+
+
+ if (
+ "http://www.vitero.de/schema/booking".equals(namespaceURI) &&
+ "addexceptions_type0".equals(typeName)){
+
+ return Addexceptions_type0.Factory.parse(reader);
+
+
+ }
+
+
+ if (
+ "http://www.vitero.de/schema/booking".equals(namespaceURI) &&
+ "booking".equals(typeName)){
+
+ return Booking.Factory.parse(reader);
+
+
+ }
+
+
+ if (
+ "http://www.vitero.de/schema/booking".equals(namespaceURI) &&
+ "bookingid".equals(typeName)){
+
+ return Bookingid.Factory.parse(reader);
+
+
+ }
+
+
+ if (
+ "http://www.vitero.de/schema/booking".equals(namespaceURI) &&
+ "bookingtime_type1".equals(typeName)){
+
+ return Bookingtime_type1.Factory.parse(reader);
+
+
+ }
+
+
+ if (
+ "http://www.vitero.de/schema/booking".equals(namespaceURI) &&
+ "bookingtime_type0".equals(typeName)){
+
+ return Bookingtime_type0.Factory.parse(reader);
+
+
+ }
+
+
+ if (
+ "http://www.vitero.de/schema/booking".equals(namespaceURI) &&
+ "bookinglist".equals(typeName)){
+
+ return Bookinglist.Factory.parse(reader);
+
+
+ }
+
+
+ if (
+ "http://www.vitero.de/schema/booking".equals(namespaceURI) &&
+ "bookingtype".equals(typeName)){
+
+ return Bookingtype.Factory.parse(reader);
+
+
+ }
+
+
+ if (
+ "http://www.vitero.de/schema/booking".equals(namespaceURI) &&
+ "bookingtime".equals(typeName)){
+
+ return Bookingtime.Factory.parse(reader);
+
+
+ }
+
+
+ if (
+ "http://www.vitero.de/schema/booking".equals(namespaceURI) &&
+ "newbookingtype".equals(typeName)){
+
+ return Newbookingtype.Factory.parse(reader);
+
+
+ }
+
+
+ if (
+ "http://www.vitero.de/schema/booking".equals(namespaceURI) &&
+ "bookingtimetype".equals(typeName)){
+
+ return Bookingtimetype.Factory.parse(reader);
+
+
+ }
+
+
+ if (
+ "http://www.vitero.de/schema/booking".equals(namespaceURI) &&
+ "phonetype".equals(typeName)){
+
+ return Phonetype.Factory.parse(reader);
+
+
+ }
+
+
+ if (
+ "http://www.vitero.de/schema/booking".equals(namespaceURI) &&
+ "bookingtimeid".equals(typeName)){
+
+ return Bookingtimeid.Factory.parse(reader);
+
+
+ }
+
+
+ throw new org.apache.axis2.databinding.ADBException("Unsupported type " + namespaceURI + " " + typeName);
+ }
+
+ }
+
+ public static class Bookinglist
+ implements org.apache.axis2.databinding.ADBBean{
+ /* This type was generated from the piece of schema that had
+ name = bookinglist
+ Namespace URI = http://www.vitero.de/schema/booking
+ Namespace Prefix = ns1
+ */
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/booking")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for Booking
+ * This was an Array!
+ */
+
+
+ protected Booking[] localBooking ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localBookingTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return Booking[]
+ */
+ public Booking[] getBooking(){
+ return localBooking;
+ }
+
+
+
+
+
+
+ /**
+ * validate the array for Booking
+ */
+ protected void validateBooking(Booking[] param){
+
+ }
+
+
+ /**
+ * Auto generated setter method
+ * @param param Booking
+ */
+ public void setBooking(Booking[] param){
+
+ validateBooking(param);
+
+
+ if (param != null){
+ //update the setting tracker
+ localBookingTracker = true;
+ } else {
+ localBookingTracker = false;
+
+ }
+
+ this.localBooking=param;
+ }
+
+
+
+ /**
+ * Auto generated add method for the array for convenience
+ * @param param Booking
+ */
+ public void addBooking(Booking param){
+ if (localBooking == null){
+ localBooking = new Booking[]{};
+ }
+
+
+ //update the setting tracker
+ localBookingTracker = true;
+
+
+ java.util.List list =
+ org.apache.axis2.databinding.utils.ConverterUtil.toList(localBooking);
+ list.add(param);
+ this.localBooking =
+ (Booking[])list.toArray(
+ new Booking[list.size()]);
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,parentQName){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ Bookinglist.this.serialize(parentQName,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ parentQName,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/booking");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":bookinglist",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "bookinglist",
+ xmlWriter);
+ }
+
+
+ }
+ if (localBookingTracker){
+ if (localBooking!=null){
+ for (int i = 0;i < localBooking.length;i++){
+ if (localBooking[i] != null){
+ localBooking[i].serialize(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking","booking"),
+ factory,xmlWriter);
+ } else {
+
+ // we don't have to do any thing since minOccures is zero
+
+ }
+
+ }
+ } else {
+
+ throw new org.apache.axis2.databinding.ADBException("booking cannot be null!!");
+
+ }
+ }
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+ if (localBookingTracker){
+ if (localBooking!=null) {
+ for (int i = 0;i < localBooking.length;i++){
+
+ if (localBooking[i] != null){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking",
+ "booking"));
+ elementList.add(localBooking[i]);
+ } else {
+
+ // nothing to do
+
+ }
+
+ }
+ } else {
+
+ throw new org.apache.axis2.databinding.ADBException("booking cannot be null!!");
+
+ }
+
+ }
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static Bookinglist parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ Bookinglist object =
+ new Bookinglist();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"bookinglist".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (Bookinglist)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+ java.util.ArrayList list1 = new java.util.ArrayList();
+
+
+ while (!reader.isStartElement() && !reader.isEndElement()) reader.next();
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/booking","booking").equals(reader.getName())){
+
+
+
+ // Process the array and step past its final element's end.
+ list1.add(Booking.Factory.parse(reader));
+
+ //loop until we find a start element that is not part of this array
+ boolean loopDone1 = false;
+ while(!loopDone1){
+ // We should be at the end element, but make sure
+ while (!reader.isEndElement())
+ reader.next();
+ // Step out of this element
+ reader.next();
+ // Step to next element event.
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+ if (reader.isEndElement()){
+ //two continuous end elements means we are exiting the xml structure
+ loopDone1 = true;
+ } else {
+ if (new javax.xml.namespace.QName("http://www.vitero.de/schema/booking","booking").equals(reader.getName())){
+ list1.add(Booking.Factory.parse(reader));
+
+ }else{
+ loopDone1 = true;
+ }
+ }
+ }
+ // call the converter utility to convert and set the array
+
+ object.setBooking((Booking[])
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToArray(
+ Booking.class,
+ list1));
+
+ } // End of if for expected property start element
+
+ else {
+
+ }
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+ if (reader.isStartElement())
+ // A start element we are not expecting indicates a trailing invalid property
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class Bookingtimetype
+ implements org.apache.axis2.databinding.ADBBean{
+ /* This type was generated from the piece of schema that had
+ name = bookingtimetype
+ Namespace URI = http://www.vitero.de/schema/booking
+ Namespace Prefix = ns1
+ */
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/booking")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for Bookingtime
+ */
+
+
+ protected Bookingtime localBookingtime ;
+
+
+ /**
+ * Auto generated getter method
+ * @return Bookingtime
+ */
+ public Bookingtime getBookingtime(){
+ return localBookingtime;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Bookingtime
+ */
+ public void setBookingtime(Bookingtime param){
+
+ this.localBookingtime=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,parentQName){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ Bookingtimetype.this.serialize(parentQName,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ parentQName,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/booking");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":bookingtimetype",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "bookingtimetype",
+ xmlWriter);
+ }
+
+
+ }
+
+ if (localBookingtime==null){
+ throw new org.apache.axis2.databinding.ADBException("bookingtime cannot be null!!");
+ }
+ localBookingtime.serialize(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking","bookingtime"),
+ factory,xmlWriter);
+
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking",
+ "bookingtime"));
+
+
+ if (localBookingtime==null){
+ throw new org.apache.axis2.databinding.ADBException("bookingtime cannot be null!!");
+ }
+ elementList.add(localBookingtime);
+
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static Bookingtimetype parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ Bookingtimetype object =
+ new Bookingtimetype();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"bookingtimetype".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (Bookingtimetype)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/booking","bookingtime").equals(reader.getName())){
+
+ object.setBookingtime(Bookingtime.Factory.parse(reader));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class Bookingid
+ implements org.apache.axis2.databinding.ADBBean{
+ /* This type was generated from the piece of schema that had
+ name = bookingid
+ Namespace URI = http://www.vitero.de/schema/booking
+ Namespace Prefix = ns1
+ */
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/booking")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for Bookingid
+ */
+
+
+ protected int localBookingid ;
+
+
+ /**
+ * Auto generated getter method
+ * @return int
+ */
+ public int getBookingid(){
+ return localBookingid;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Bookingid
+ */
+ public void setBookingid(int param){
+
+ this.localBookingid=param;
+
+
+ }
+
+
+ /**
+ * field for Timezone
+ */
+
+
+ protected java.lang.String localTimezone ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localTimezoneTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getTimezone(){
+ return localTimezone;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Timezone
+ */
+ public void setTimezone(java.lang.String param){
+
+ if (param != null){
+ //update the setting tracker
+ localTimezoneTracker = true;
+ } else {
+ localTimezoneTracker = false;
+
+ }
+
+ this.localTimezone=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,parentQName){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ Bookingid.this.serialize(parentQName,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ parentQName,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/booking");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":bookingid",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "bookingid",
+ xmlWriter);
+ }
+
+
+ }
+
+ namespace = "http://www.vitero.de/schema/booking";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"bookingid", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"bookingid");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("bookingid");
+ }
+
+ if (localBookingid==java.lang.Integer.MIN_VALUE) {
+
+ throw new org.apache.axis2.databinding.ADBException("bookingid cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localBookingid));
+ }
+
+ xmlWriter.writeEndElement();
+ if (localTimezoneTracker){
+ namespace = "http://www.vitero.de/schema/booking";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"timezone", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"timezone");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("timezone");
+ }
+
+
+ if (localTimezone==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("timezone cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localTimezone);
+
+ }
+
+ xmlWriter.writeEndElement();
+ }
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking",
+ "bookingid"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localBookingid));
+ if (localTimezoneTracker){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking",
+ "timezone"));
+
+ if (localTimezone != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localTimezone));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("timezone cannot be null!!");
+ }
+ }
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static Bookingid parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ Bookingid object =
+ new Bookingid();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"bookingid".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (Bookingid)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/booking","bookingid").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setBookingid(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToInt(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/booking","timezone").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setTimezone(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class Subtractexceptions_type0
+ implements org.apache.axis2.databinding.ADBBean{
+ /* This type was generated from the piece of schema that had
+ name = subtractexceptions_type0
+ Namespace URI = http://www.vitero.de/schema/booking
+ Namespace Prefix = ns1
+ */
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/booking")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for Bookingtime
+ * This was an Array!
+ */
+
+
+ protected Bookingtime_type1[] localBookingtime ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localBookingtimeTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return Bookingtime_type1[]
+ */
+ public Bookingtime_type1[] getBookingtime(){
+ return localBookingtime;
+ }
+
+
+
+
+
+
+ /**
+ * validate the array for Bookingtime
+ */
+ protected void validateBookingtime(Bookingtime_type1[] param){
+
+ }
+
+
+ /**
+ * Auto generated setter method
+ * @param param Bookingtime
+ */
+ public void setBookingtime(Bookingtime_type1[] param){
+
+ validateBookingtime(param);
+
+
+ if (param != null){
+ //update the setting tracker
+ localBookingtimeTracker = true;
+ } else {
+ localBookingtimeTracker = false;
+
+ }
+
+ this.localBookingtime=param;
+ }
+
+
+
+ /**
+ * Auto generated add method for the array for convenience
+ * @param param Bookingtime_type1
+ */
+ public void addBookingtime(Bookingtime_type1 param){
+ if (localBookingtime == null){
+ localBookingtime = new Bookingtime_type1[]{};
+ }
+
+
+ //update the setting tracker
+ localBookingtimeTracker = true;
+
+
+ java.util.List list =
+ org.apache.axis2.databinding.utils.ConverterUtil.toList(localBookingtime);
+ list.add(param);
+ this.localBookingtime =
+ (Bookingtime_type1[])list.toArray(
+ new Bookingtime_type1[list.size()]);
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,parentQName){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ Subtractexceptions_type0.this.serialize(parentQName,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ parentQName,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/booking");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":subtractexceptions_type0",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "subtractexceptions_type0",
+ xmlWriter);
+ }
+
+
+ }
+ if (localBookingtimeTracker){
+ if (localBookingtime!=null){
+ for (int i = 0;i < localBookingtime.length;i++){
+ if (localBookingtime[i] != null){
+ localBookingtime[i].serialize(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking","bookingtime"),
+ factory,xmlWriter);
+ } else {
+
+ // we don't have to do any thing since minOccures is zero
+
+ }
+
+ }
+ } else {
+
+ throw new org.apache.axis2.databinding.ADBException("bookingtime cannot be null!!");
+
+ }
+ }
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+ if (localBookingtimeTracker){
+ if (localBookingtime!=null) {
+ for (int i = 0;i < localBookingtime.length;i++){
+
+ if (localBookingtime[i] != null){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking",
+ "bookingtime"));
+ elementList.add(localBookingtime[i]);
+ } else {
+
+ // nothing to do
+
+ }
+
+ }
+ } else {
+
+ throw new org.apache.axis2.databinding.ADBException("bookingtime cannot be null!!");
+
+ }
+
+ }
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static Subtractexceptions_type0 parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ Subtractexceptions_type0 object =
+ new Subtractexceptions_type0();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"subtractexceptions_type0".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (Subtractexceptions_type0)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+ java.util.ArrayList list1 = new java.util.ArrayList();
+
+
+ while (!reader.isStartElement() && !reader.isEndElement()) reader.next();
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/booking","bookingtime").equals(reader.getName())){
+
+
+
+ // Process the array and step past its final element's end.
+ list1.add(Bookingtime_type1.Factory.parse(reader));
+
+ //loop until we find a start element that is not part of this array
+ boolean loopDone1 = false;
+ while(!loopDone1){
+ // We should be at the end element, but make sure
+ while (!reader.isEndElement())
+ reader.next();
+ // Step out of this element
+ reader.next();
+ // Step to next element event.
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+ if (reader.isEndElement()){
+ //two continuous end elements means we are exiting the xml structure
+ loopDone1 = true;
+ } else {
+ if (new javax.xml.namespace.QName("http://www.vitero.de/schema/booking","bookingtime").equals(reader.getName())){
+ list1.add(Bookingtime_type1.Factory.parse(reader));
+
+ }else{
+ loopDone1 = true;
+ }
+ }
+ }
+ // call the converter utility to convert and set the array
+
+ object.setBookingtime((Bookingtime_type1[])
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToArray(
+ Bookingtime_type1.class,
+ list1));
+
+ } // End of if for expected property start element
+
+ else {
+
+ }
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+ if (reader.isStartElement())
+ // A start element we are not expecting indicates a trailing invalid property
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class GetBookingListByDateRequest
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/booking",
+ "getBookingListByDateRequest",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/booking")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for Start
+ */
+
+
+ protected java.lang.String localStart ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getStart(){
+ return localStart;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Start
+ */
+ public void setStart(java.lang.String param){
+
+ this.localStart=param;
+
+
+ }
+
+
+ /**
+ * field for End
+ */
+
+
+ protected java.lang.String localEnd ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getEnd(){
+ return localEnd;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param End
+ */
+ public void setEnd(java.lang.String param){
+
+ this.localEnd=param;
+
+
+ }
+
+
+ /**
+ * field for Timezone
+ */
+
+
+ protected java.lang.String localTimezone ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localTimezoneTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getTimezone(){
+ return localTimezone;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Timezone
+ */
+ public void setTimezone(java.lang.String param){
+
+ if (param != null){
+ //update the setting tracker
+ localTimezoneTracker = true;
+ } else {
+ localTimezoneTracker = false;
+
+ }
+
+ this.localTimezone=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ GetBookingListByDateRequest.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/booking");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":getBookingListByDateRequest",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "getBookingListByDateRequest",
+ xmlWriter);
+ }
+
+
+ }
+
+ namespace = "http://www.vitero.de/schema/booking";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"start", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"start");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("start");
+ }
+
+
+ if (localStart==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("start cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localStart);
+
+ }
+
+ xmlWriter.writeEndElement();
+
+ namespace = "http://www.vitero.de/schema/booking";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"end", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"end");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("end");
+ }
+
+
+ if (localEnd==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("end cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localEnd);
+
+ }
+
+ xmlWriter.writeEndElement();
+ if (localTimezoneTracker){
+ namespace = "http://www.vitero.de/schema/booking";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"timezone", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"timezone");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("timezone");
+ }
+
+
+ if (localTimezone==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("timezone cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localTimezone);
+
+ }
+
+ xmlWriter.writeEndElement();
+ }
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking",
+ "start"));
+
+ if (localStart != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localStart));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("start cannot be null!!");
+ }
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking",
+ "end"));
+
+ if (localEnd != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localEnd));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("end cannot be null!!");
+ }
+ if (localTimezoneTracker){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking",
+ "timezone"));
+
+ if (localTimezone != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localTimezone));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("timezone cannot be null!!");
+ }
+ }
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static GetBookingListByDateRequest parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ GetBookingListByDateRequest object =
+ new GetBookingListByDateRequest();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"getBookingListByDateRequest".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (GetBookingListByDateRequest)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/booking","start").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setStart(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/booking","end").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setEnd(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/booking","timezone").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setTimezone(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class CreateBookingRequest
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/booking",
+ "createBookingRequest",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/booking")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for Booking
+ */
+
+
+ protected Newbookingtype localBooking ;
+
+
+ /**
+ * Auto generated getter method
+ * @return Newbookingtype
+ */
+ public Newbookingtype getBooking(){
+ return localBooking;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Booking
+ */
+ public void setBooking(Newbookingtype param){
+
+ this.localBooking=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ CreateBookingRequest.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/booking");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":createBookingRequest",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "createBookingRequest",
+ xmlWriter);
+ }
+
+
+ }
+
+ if (localBooking==null){
+ throw new org.apache.axis2.databinding.ADBException("booking cannot be null!!");
+ }
+ localBooking.serialize(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking","booking"),
+ factory,xmlWriter);
+
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking",
+ "booking"));
+
+
+ if (localBooking==null){
+ throw new org.apache.axis2.databinding.ADBException("booking cannot be null!!");
+ }
+ elementList.add(localBooking);
+
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static CreateBookingRequest parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ CreateBookingRequest object =
+ new CreateBookingRequest();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"createBookingRequest".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (CreateBookingRequest)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/booking","booking").equals(reader.getName())){
+
+ object.setBooking(Newbookingtype.Factory.parse(reader));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class Bookingtype
+ implements org.apache.axis2.databinding.ADBBean{
+ /* This type was generated from the piece of schema that had
+ name = bookingtype
+ Namespace URI = http://www.vitero.de/schema/booking
+ Namespace Prefix = ns1
+ */
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/booking")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for Booking
+ */
+
+
+ protected Booking localBooking ;
+
+
+ /**
+ * Auto generated getter method
+ * @return Booking
+ */
+ public Booking getBooking(){
+ return localBooking;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Booking
+ */
+ public void setBooking(Booking param){
+
+ this.localBooking=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,parentQName){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ Bookingtype.this.serialize(parentQName,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ parentQName,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/booking");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":bookingtype",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "bookingtype",
+ xmlWriter);
+ }
+
+
+ }
+
+ if (localBooking==null){
+ throw new org.apache.axis2.databinding.ADBException("booking cannot be null!!");
+ }
+ localBooking.serialize(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking","booking"),
+ factory,xmlWriter);
+
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking",
+ "booking"));
+
+
+ if (localBooking==null){
+ throw new org.apache.axis2.databinding.ADBException("booking cannot be null!!");
+ }
+ elementList.add(localBooking);
+
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static Bookingtype parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ Bookingtype object =
+ new Bookingtype();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"bookingtype".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (Bookingtype)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/booking","booking").equals(reader.getName())){
+
+ object.setBooking(Booking.Factory.parse(reader));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class Bookingtime
+ implements org.apache.axis2.databinding.ADBBean{
+ /* This type was generated from the piece of schema that had
+ name = bookingtime
+ Namespace URI = http://www.vitero.de/schema/booking
+ Namespace Prefix = ns1
+ */
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/booking")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for Bookingtimeid
+ */
+
+
+ protected int localBookingtimeid ;
+
+
+ /**
+ * Auto generated getter method
+ * @return int
+ */
+ public int getBookingtimeid(){
+ return localBookingtimeid;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Bookingtimeid
+ */
+ public void setBookingtimeid(int param){
+
+ this.localBookingtimeid=param;
+
+
+ }
+
+
+ /**
+ * field for Bookingid
+ */
+
+
+ protected int localBookingid ;
+
+
+ /**
+ * Auto generated getter method
+ * @return int
+ */
+ public int getBookingid(){
+ return localBookingid;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Bookingid
+ */
+ public void setBookingid(int param){
+
+ this.localBookingid=param;
+
+
+ }
+
+
+ /**
+ * field for Groupid
+ */
+
+
+ protected int localGroupid ;
+
+
+ /**
+ * Auto generated getter method
+ * @return int
+ */
+ public int getGroupid(){
+ return localGroupid;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Groupid
+ */
+ public void setGroupid(int param){
+
+ this.localGroupid=param;
+
+
+ }
+
+
+ /**
+ * field for Roomsize
+ */
+
+
+ protected int localRoomsize ;
+
+
+ /**
+ * Auto generated getter method
+ * @return int
+ */
+ public int getRoomsize(){
+ return localRoomsize;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Roomsize
+ */
+ public void setRoomsize(int param){
+
+ this.localRoomsize=param;
+
+
+ }
+
+
+ /**
+ * field for Cafe
+ */
+
+
+ protected boolean localCafe ;
+
+
+ /**
+ * Auto generated getter method
+ * @return boolean
+ */
+ public boolean getCafe(){
+ return localCafe;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Cafe
+ */
+ public void setCafe(boolean param){
+
+ this.localCafe=param;
+
+
+ }
+
+
+ /**
+ * field for Capture
+ */
+
+
+ protected boolean localCapture ;
+
+
+ /**
+ * Auto generated getter method
+ * @return boolean
+ */
+ public boolean getCapture(){
+ return localCapture;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Capture
+ */
+ public void setCapture(boolean param){
+
+ this.localCapture=param;
+
+
+ }
+
+
+ /**
+ * field for Phone
+ */
+
+
+ protected Phonetype localPhone ;
+
+
+ /**
+ * Auto generated getter method
+ * @return Phonetype
+ */
+ public Phonetype getPhone(){
+ return localPhone;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Phone
+ */
+ public void setPhone(Phonetype param){
+
+ this.localPhone=param;
+
+
+ }
+
+
+ /**
+ * field for Pcstateokrequired
+ */
+
+
+ protected boolean localPcstateokrequired ;
+
+
+ /**
+ * Auto generated getter method
+ * @return boolean
+ */
+ public boolean getPcstateokrequired(){
+ return localPcstateokrequired;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Pcstateokrequired
+ */
+ public void setPcstateokrequired(boolean param){
+
+ this.localPcstateokrequired=param;
+
+
+ }
+
+
+ /**
+ * field for Start
+ */
+
+
+ protected java.lang.String localStart ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getStart(){
+ return localStart;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Start
+ */
+ public void setStart(java.lang.String param){
+
+ this.localStart=param;
+
+
+ }
+
+
+ /**
+ * field for End
+ */
+
+
+ protected java.lang.String localEnd ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getEnd(){
+ return localEnd;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param End
+ */
+ public void setEnd(java.lang.String param){
+
+ this.localEnd=param;
+
+
+ }
+
+
+ /**
+ * field for Startbuffer
+ */
+
+
+ protected int localStartbuffer ;
+
+
+ /**
+ * Auto generated getter method
+ * @return int
+ */
+ public int getStartbuffer(){
+ return localStartbuffer;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Startbuffer
+ */
+ public void setStartbuffer(int param){
+
+ this.localStartbuffer=param;
+
+
+ }
+
+
+ /**
+ * field for Endbuffer
+ */
+
+
+ protected int localEndbuffer ;
+
+
+ /**
+ * Auto generated getter method
+ * @return int
+ */
+ public int getEndbuffer(){
+ return localEndbuffer;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Endbuffer
+ */
+ public void setEndbuffer(int param){
+
+ this.localEndbuffer=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,parentQName){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ Bookingtime.this.serialize(parentQName,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ parentQName,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/booking");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":bookingtime",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "bookingtime",
+ xmlWriter);
+ }
+
+
+ }
+
+ namespace = "http://www.vitero.de/schema/booking";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"bookingtimeid", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"bookingtimeid");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("bookingtimeid");
+ }
+
+ if (localBookingtimeid==java.lang.Integer.MIN_VALUE) {
+
+ throw new org.apache.axis2.databinding.ADBException("bookingtimeid cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localBookingtimeid));
+ }
+
+ xmlWriter.writeEndElement();
+
+ namespace = "http://www.vitero.de/schema/booking";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"bookingid", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"bookingid");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("bookingid");
+ }
+
+ if (localBookingid==java.lang.Integer.MIN_VALUE) {
+
+ throw new org.apache.axis2.databinding.ADBException("bookingid cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localBookingid));
+ }
+
+ xmlWriter.writeEndElement();
+
+ namespace = "http://www.vitero.de/schema/booking";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"groupid", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"groupid");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("groupid");
+ }
+
+ if (localGroupid==java.lang.Integer.MIN_VALUE) {
+
+ throw new org.apache.axis2.databinding.ADBException("groupid cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localGroupid));
+ }
+
+ xmlWriter.writeEndElement();
+
+ namespace = "http://www.vitero.de/schema/booking";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"roomsize", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"roomsize");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("roomsize");
+ }
+
+ if (localRoomsize==java.lang.Integer.MIN_VALUE) {
+
+ throw new org.apache.axis2.databinding.ADBException("roomsize cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localRoomsize));
+ }
+
+ xmlWriter.writeEndElement();
+
+ namespace = "http://www.vitero.de/schema/booking";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"cafe", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"cafe");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("cafe");
+ }
+
+ if (false) {
+
+ throw new org.apache.axis2.databinding.ADBException("cafe cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localCafe));
+ }
+
+ xmlWriter.writeEndElement();
+
+ namespace = "http://www.vitero.de/schema/booking";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"capture", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"capture");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("capture");
+ }
+
+ if (false) {
+
+ throw new org.apache.axis2.databinding.ADBException("capture cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localCapture));
+ }
+
+ xmlWriter.writeEndElement();
+
+ if (localPhone==null){
+ throw new org.apache.axis2.databinding.ADBException("phone cannot be null!!");
+ }
+ localPhone.serialize(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking","phone"),
+ factory,xmlWriter);
+
+ namespace = "http://www.vitero.de/schema/booking";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"pcstateokrequired", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"pcstateokrequired");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("pcstateokrequired");
+ }
+
+ if (false) {
+
+ throw new org.apache.axis2.databinding.ADBException("pcstateokrequired cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localPcstateokrequired));
+ }
+
+ xmlWriter.writeEndElement();
+
+ namespace = "http://www.vitero.de/schema/booking";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"start", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"start");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("start");
+ }
+
+
+ if (localStart==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("start cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localStart);
+
+ }
+
+ xmlWriter.writeEndElement();
+
+ namespace = "http://www.vitero.de/schema/booking";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"end", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"end");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("end");
+ }
+
+
+ if (localEnd==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("end cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localEnd);
+
+ }
+
+ xmlWriter.writeEndElement();
+
+ namespace = "http://www.vitero.de/schema/booking";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"startbuffer", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"startbuffer");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("startbuffer");
+ }
+
+ if (localStartbuffer==java.lang.Integer.MIN_VALUE) {
+
+ throw new org.apache.axis2.databinding.ADBException("startbuffer cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localStartbuffer));
+ }
+
+ xmlWriter.writeEndElement();
+
+ namespace = "http://www.vitero.de/schema/booking";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"endbuffer", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"endbuffer");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("endbuffer");
+ }
+
+ if (localEndbuffer==java.lang.Integer.MIN_VALUE) {
+
+ throw new org.apache.axis2.databinding.ADBException("endbuffer cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localEndbuffer));
+ }
+
+ xmlWriter.writeEndElement();
+
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking",
+ "bookingtimeid"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localBookingtimeid));
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking",
+ "bookingid"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localBookingid));
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking",
+ "groupid"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localGroupid));
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking",
+ "roomsize"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localRoomsize));
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking",
+ "cafe"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localCafe));
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking",
+ "capture"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localCapture));
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking",
+ "phone"));
+
+
+ if (localPhone==null){
+ throw new org.apache.axis2.databinding.ADBException("phone cannot be null!!");
+ }
+ elementList.add(localPhone);
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking",
+ "pcstateokrequired"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localPcstateokrequired));
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking",
+ "start"));
+
+ if (localStart != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localStart));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("start cannot be null!!");
+ }
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking",
+ "end"));
+
+ if (localEnd != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localEnd));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("end cannot be null!!");
+ }
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking",
+ "startbuffer"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localStartbuffer));
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking",
+ "endbuffer"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localEndbuffer));
+
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static Bookingtime parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ Bookingtime object =
+ new Bookingtime();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"bookingtime".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (Bookingtime)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/booking","bookingtimeid").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setBookingtimeid(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToInt(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/booking","bookingid").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setBookingid(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToInt(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/booking","groupid").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setGroupid(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToInt(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/booking","roomsize").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setRoomsize(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToInt(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/booking","cafe").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setCafe(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToBoolean(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/booking","capture").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setCapture(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToBoolean(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/booking","phone").equals(reader.getName())){
+
+ object.setPhone(Phonetype.Factory.parse(reader));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/booking","pcstateokrequired").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setPcstateokrequired(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToBoolean(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/booking","start").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setStart(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/booking","end").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setEnd(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/booking","startbuffer").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setStartbuffer(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToInt(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/booking","endbuffer").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setEndbuffer(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToInt(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class GetBookingListByGroupInFutureResponse
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/booking",
+ "getBookingListByGroupInFutureResponse",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/booking")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for GetBookingListByGroupInFutureResponse
+ */
+
+
+ protected Bookinglist localGetBookingListByGroupInFutureResponse ;
+
+
+ /**
+ * Auto generated getter method
+ * @return Bookinglist
+ */
+ public Bookinglist getGetBookingListByGroupInFutureResponse(){
+ return localGetBookingListByGroupInFutureResponse;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param GetBookingListByGroupInFutureResponse
+ */
+ public void setGetBookingListByGroupInFutureResponse(Bookinglist param){
+
+ this.localGetBookingListByGroupInFutureResponse=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ GetBookingListByGroupInFutureResponse.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+ //We can safely assume an element has only one type associated with it
+
+ if (localGetBookingListByGroupInFutureResponse==null){
+ throw new org.apache.axis2.databinding.ADBException("Property cannot be null!");
+ }
+ localGetBookingListByGroupInFutureResponse.serialize(MY_QNAME,factory,xmlWriter);
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+
+ //We can safely assume an element has only one type associated with it
+ return localGetBookingListByGroupInFutureResponse.getPullParser(MY_QNAME);
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static GetBookingListByGroupInFutureResponse parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ GetBookingListByGroupInFutureResponse object =
+ new GetBookingListByGroupInFutureResponse();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/booking","getBookingListByGroupInFutureResponse").equals(reader.getName())){
+
+ object.setGetBookingListByGroupInFutureResponse(Bookinglist.Factory.parse(reader));
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class GetBookingByBookingTimeIdRequest
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/booking",
+ "getBookingByBookingTimeIdRequest",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/booking")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for GetBookingByBookingTimeIdRequest
+ */
+
+
+ protected Bookingtimeid localGetBookingByBookingTimeIdRequest ;
+
+
+ /**
+ * Auto generated getter method
+ * @return Bookingtimeid
+ */
+ public Bookingtimeid getGetBookingByBookingTimeIdRequest(){
+ return localGetBookingByBookingTimeIdRequest;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param GetBookingByBookingTimeIdRequest
+ */
+ public void setGetBookingByBookingTimeIdRequest(Bookingtimeid param){
+
+ this.localGetBookingByBookingTimeIdRequest=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ GetBookingByBookingTimeIdRequest.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+ //We can safely assume an element has only one type associated with it
+
+ if (localGetBookingByBookingTimeIdRequest==null){
+ throw new org.apache.axis2.databinding.ADBException("Property cannot be null!");
+ }
+ localGetBookingByBookingTimeIdRequest.serialize(MY_QNAME,factory,xmlWriter);
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+
+ //We can safely assume an element has only one type associated with it
+ return localGetBookingByBookingTimeIdRequest.getPullParser(MY_QNAME);
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static GetBookingByBookingTimeIdRequest parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ GetBookingByBookingTimeIdRequest object =
+ new GetBookingByBookingTimeIdRequest();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/booking","getBookingByBookingTimeIdRequest").equals(reader.getName())){
+
+ object.setGetBookingByBookingTimeIdRequest(Bookingtimeid.Factory.parse(reader));
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class GetBookingByIdResponse
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/booking",
+ "getBookingByIdResponse",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/booking")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for GetBookingByIdResponse
+ */
+
+
+ protected Bookingtype localGetBookingByIdResponse ;
+
+
+ /**
+ * Auto generated getter method
+ * @return Bookingtype
+ */
+ public Bookingtype getGetBookingByIdResponse(){
+ return localGetBookingByIdResponse;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param GetBookingByIdResponse
+ */
+ public void setGetBookingByIdResponse(Bookingtype param){
+
+ this.localGetBookingByIdResponse=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ GetBookingByIdResponse.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+ //We can safely assume an element has only one type associated with it
+
+ if (localGetBookingByIdResponse==null){
+ throw new org.apache.axis2.databinding.ADBException("Property cannot be null!");
+ }
+ localGetBookingByIdResponse.serialize(MY_QNAME,factory,xmlWriter);
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+
+ //We can safely assume an element has only one type associated with it
+ return localGetBookingByIdResponse.getPullParser(MY_QNAME);
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static GetBookingByIdResponse parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ GetBookingByIdResponse object =
+ new GetBookingByIdResponse();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/booking","getBookingByIdResponse").equals(reader.getName())){
+
+ object.setGetBookingByIdResponse(Bookingtype.Factory.parse(reader));
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class DeleteBookingResponse
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/booking",
+ "deleteBookingResponse",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/booking")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for Deletestate
+ */
+
+
+ protected java.math.BigInteger localDeletestate ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.math.BigInteger
+ */
+ public java.math.BigInteger getDeletestate(){
+ return localDeletestate;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Deletestate
+ */
+ public void setDeletestate(java.math.BigInteger param){
+
+ this.localDeletestate=param;
+
+
+ }
+
+
+ /**
+ * field for Eventlocked
+ */
+
+
+ protected boolean localEventlocked ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localEventlockedTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return boolean
+ */
+ public boolean getEventlocked(){
+ return localEventlocked;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Eventlocked
+ */
+ public void setEventlocked(boolean param){
+
+ // setting primitive attribute tracker to true
+
+ if (false) {
+ localEventlockedTracker = false;
+
+ } else {
+ localEventlockedTracker = true;
+ }
+
+ this.localEventlocked=param;
+
+
+ }
+
+
+ /**
+ * field for Eventsinpast
+ */
+
+
+ protected java.math.BigInteger localEventsinpast ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localEventsinpastTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.math.BigInteger
+ */
+ public java.math.BigInteger getEventsinpast(){
+ return localEventsinpast;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Eventsinpast
+ */
+ public void setEventsinpast(java.math.BigInteger param){
+
+ if (param != null){
+ //update the setting tracker
+ localEventsinpastTracker = true;
+ } else {
+ localEventsinpastTracker = false;
+
+ }
+
+ this.localEventsinpast=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ DeleteBookingResponse.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/booking");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":deleteBookingResponse",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "deleteBookingResponse",
+ xmlWriter);
+ }
+
+
+ }
+
+ namespace = "http://www.vitero.de/schema/booking";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"deletestate", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"deletestate");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("deletestate");
+ }
+
+
+ if (localDeletestate==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("deletestate cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localDeletestate));
+
+ }
+
+ xmlWriter.writeEndElement();
+ if (localEventlockedTracker){
+ namespace = "http://www.vitero.de/schema/booking";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"eventlocked", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"eventlocked");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("eventlocked");
+ }
+
+ if (false) {
+
+ throw new org.apache.axis2.databinding.ADBException("eventlocked cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localEventlocked));
+ }
+
+ xmlWriter.writeEndElement();
+ } if (localEventsinpastTracker){
+ namespace = "http://www.vitero.de/schema/booking";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"eventsinpast", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"eventsinpast");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("eventsinpast");
+ }
+
+
+ if (localEventsinpast==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("eventsinpast cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localEventsinpast));
+
+ }
+
+ xmlWriter.writeEndElement();
+ }
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking",
+ "deletestate"));
+
+ if (localDeletestate != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localDeletestate));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("deletestate cannot be null!!");
+ }
+ if (localEventlockedTracker){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking",
+ "eventlocked"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localEventlocked));
+ } if (localEventsinpastTracker){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking",
+ "eventsinpast"));
+
+ if (localEventsinpast != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localEventsinpast));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("eventsinpast cannot be null!!");
+ }
+ }
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static DeleteBookingResponse parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ DeleteBookingResponse object =
+ new DeleteBookingResponse();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"deleteBookingResponse".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (DeleteBookingResponse)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/booking","deletestate").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setDeletestate(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToInteger(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/booking","eventlocked").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setEventlocked(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToBoolean(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/booking","eventsinpast").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setEventsinpast(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToInteger(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class GetBookingListByUserInFutureResponse
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/booking",
+ "getBookingListByUserInFutureResponse",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/booking")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for GetBookingListByUserInFutureResponse
+ */
+
+
+ protected Bookinglist localGetBookingListByUserInFutureResponse ;
+
+
+ /**
+ * Auto generated getter method
+ * @return Bookinglist
+ */
+ public Bookinglist getGetBookingListByUserInFutureResponse(){
+ return localGetBookingListByUserInFutureResponse;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param GetBookingListByUserInFutureResponse
+ */
+ public void setGetBookingListByUserInFutureResponse(Bookinglist param){
+
+ this.localGetBookingListByUserInFutureResponse=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ GetBookingListByUserInFutureResponse.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+ //We can safely assume an element has only one type associated with it
+
+ if (localGetBookingListByUserInFutureResponse==null){
+ throw new org.apache.axis2.databinding.ADBException("Property cannot be null!");
+ }
+ localGetBookingListByUserInFutureResponse.serialize(MY_QNAME,factory,xmlWriter);
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+
+ //We can safely assume an element has only one type associated with it
+ return localGetBookingListByUserInFutureResponse.getPullParser(MY_QNAME);
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static GetBookingListByUserInFutureResponse parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ GetBookingListByUserInFutureResponse object =
+ new GetBookingListByUserInFutureResponse();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/booking","getBookingListByUserInFutureResponse").equals(reader.getName())){
+
+ object.setGetBookingListByUserInFutureResponse(Bookinglist.Factory.parse(reader));
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class Newbookingtype
+ implements org.apache.axis2.databinding.ADBBean{
+ /* This type was generated from the piece of schema that had
+ name = newbookingtype
+ Namespace URI = http://www.vitero.de/schema/booking
+ Namespace Prefix = ns1
+ */
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/booking")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for Start
+ */
+
+
+ protected java.lang.String localStart ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getStart(){
+ return localStart;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Start
+ */
+ public void setStart(java.lang.String param){
+
+ this.localStart=param;
+
+
+ }
+
+
+ /**
+ * field for End
+ */
+
+
+ protected java.lang.String localEnd ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getEnd(){
+ return localEnd;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param End
+ */
+ public void setEnd(java.lang.String param){
+
+ this.localEnd=param;
+
+
+ }
+
+
+ /**
+ * field for Startbuffer
+ */
+
+
+ protected int localStartbuffer ;
+
+
+ /**
+ * Auto generated getter method
+ * @return int
+ */
+ public int getStartbuffer(){
+ return localStartbuffer;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Startbuffer
+ */
+ public void setStartbuffer(int param){
+
+ this.localStartbuffer=param;
+
+
+ }
+
+
+ /**
+ * field for Endbuffer
+ */
+
+
+ protected int localEndbuffer ;
+
+
+ /**
+ * Auto generated getter method
+ * @return int
+ */
+ public int getEndbuffer(){
+ return localEndbuffer;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Endbuffer
+ */
+ public void setEndbuffer(int param){
+
+ this.localEndbuffer=param;
+
+
+ }
+
+
+ /**
+ * field for Groupid
+ */
+
+
+ protected int localGroupid ;
+
+
+ /**
+ * Auto generated getter method
+ * @return int
+ */
+ public int getGroupid(){
+ return localGroupid;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Groupid
+ */
+ public void setGroupid(int param){
+
+ this.localGroupid=param;
+
+
+ }
+
+
+ /**
+ * field for Roomsize
+ */
+
+
+ protected int localRoomsize ;
+
+
+ /**
+ * Auto generated getter method
+ * @return int
+ */
+ public int getRoomsize(){
+ return localRoomsize;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Roomsize
+ */
+ public void setRoomsize(int param){
+
+ this.localRoomsize=param;
+
+
+ }
+
+
+ /**
+ * field for Ignorefaults
+ */
+
+
+ protected boolean localIgnorefaults ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localIgnorefaultsTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return boolean
+ */
+ public boolean getIgnorefaults(){
+ return localIgnorefaults;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Ignorefaults
+ */
+ public void setIgnorefaults(boolean param){
+
+ // setting primitive attribute tracker to true
+
+ if (false) {
+ localIgnorefaultsTracker = false;
+
+ } else {
+ localIgnorefaultsTracker = true;
+ }
+
+ this.localIgnorefaults=param;
+
+
+ }
+
+
+ /**
+ * field for Cafe
+ */
+
+
+ protected boolean localCafe ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localCafeTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return boolean
+ */
+ public boolean getCafe(){
+ return localCafe;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Cafe
+ */
+ public void setCafe(boolean param){
+
+ // setting primitive attribute tracker to true
+
+ if (false) {
+ localCafeTracker = false;
+
+ } else {
+ localCafeTracker = true;
+ }
+
+ this.localCafe=param;
+
+
+ }
+
+
+ /**
+ * field for Capture
+ */
+
+
+ protected boolean localCapture ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localCaptureTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return boolean
+ */
+ public boolean getCapture(){
+ return localCapture;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Capture
+ */
+ public void setCapture(boolean param){
+
+ // setting primitive attribute tracker to true
+
+ if (false) {
+ localCaptureTracker = false;
+
+ } else {
+ localCaptureTracker = true;
+ }
+
+ this.localCapture=param;
+
+
+ }
+
+
+ /**
+ * field for Phone
+ */
+
+
+ protected Phonetype localPhone ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localPhoneTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return Phonetype
+ */
+ public Phonetype getPhone(){
+ return localPhone;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Phone
+ */
+ public void setPhone(Phonetype param){
+
+ if (param != null){
+ //update the setting tracker
+ localPhoneTracker = true;
+ } else {
+ localPhoneTracker = false;
+
+ }
+
+ this.localPhone=param;
+
+
+ }
+
+
+ /**
+ * field for Pcstateokrequired
+ */
+
+
+ protected boolean localPcstateokrequired ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localPcstateokrequiredTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return boolean
+ */
+ public boolean getPcstateokrequired(){
+ return localPcstateokrequired;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Pcstateokrequired
+ */
+ public void setPcstateokrequired(boolean param){
+
+ // setting primitive attribute tracker to true
+
+ if (false) {
+ localPcstateokrequiredTracker = false;
+
+ } else {
+ localPcstateokrequiredTracker = true;
+ }
+
+ this.localPcstateokrequired=param;
+
+
+ }
+
+
+ /**
+ * field for Repetitionpattern
+ */
+
+
+ protected java.lang.String localRepetitionpattern ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localRepetitionpatternTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getRepetitionpattern(){
+ return localRepetitionpattern;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Repetitionpattern
+ */
+ public void setRepetitionpattern(java.lang.String param){
+
+ if (param != null){
+ //update the setting tracker
+ localRepetitionpatternTracker = true;
+ } else {
+ localRepetitionpatternTracker = false;
+
+ }
+
+ this.localRepetitionpattern=param;
+
+
+ }
+
+
+ /**
+ * field for Repetitionenddate
+ */
+
+
+ protected java.lang.String localRepetitionenddate ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localRepetitionenddateTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getRepetitionenddate(){
+ return localRepetitionenddate;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Repetitionenddate
+ */
+ public void setRepetitionenddate(java.lang.String param){
+
+ if (param != null){
+ //update the setting tracker
+ localRepetitionenddateTracker = true;
+ } else {
+ localRepetitionenddateTracker = false;
+
+ }
+
+ this.localRepetitionenddate=param;
+
+
+ }
+
+
+ /**
+ * field for Timezone
+ */
+
+
+ protected java.lang.String localTimezone ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localTimezoneTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getTimezone(){
+ return localTimezone;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Timezone
+ */
+ public void setTimezone(java.lang.String param){
+
+ if (param != null){
+ //update the setting tracker
+ localTimezoneTracker = true;
+ } else {
+ localTimezoneTracker = false;
+
+ }
+
+ this.localTimezone=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,parentQName){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ Newbookingtype.this.serialize(parentQName,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ parentQName,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/booking");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":newbookingtype",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "newbookingtype",
+ xmlWriter);
+ }
+
+
+ }
+
+ namespace = "http://www.vitero.de/schema/booking";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"start", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"start");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("start");
+ }
+
+
+ if (localStart==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("start cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localStart);
+
+ }
+
+ xmlWriter.writeEndElement();
+
+ namespace = "http://www.vitero.de/schema/booking";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"end", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"end");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("end");
+ }
+
+
+ if (localEnd==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("end cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localEnd);
+
+ }
+
+ xmlWriter.writeEndElement();
+
+ namespace = "http://www.vitero.de/schema/booking";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"startbuffer", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"startbuffer");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("startbuffer");
+ }
+
+ if (localStartbuffer==java.lang.Integer.MIN_VALUE) {
+
+ throw new org.apache.axis2.databinding.ADBException("startbuffer cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localStartbuffer));
+ }
+
+ xmlWriter.writeEndElement();
+
+ namespace = "http://www.vitero.de/schema/booking";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"endbuffer", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"endbuffer");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("endbuffer");
+ }
+
+ if (localEndbuffer==java.lang.Integer.MIN_VALUE) {
+
+ throw new org.apache.axis2.databinding.ADBException("endbuffer cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localEndbuffer));
+ }
+
+ xmlWriter.writeEndElement();
+
+ namespace = "http://www.vitero.de/schema/booking";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"groupid", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"groupid");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("groupid");
+ }
+
+ if (localGroupid==java.lang.Integer.MIN_VALUE) {
+
+ throw new org.apache.axis2.databinding.ADBException("groupid cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localGroupid));
+ }
+
+ xmlWriter.writeEndElement();
+
+ namespace = "http://www.vitero.de/schema/booking";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"roomsize", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"roomsize");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("roomsize");
+ }
+
+ if (localRoomsize==java.lang.Integer.MIN_VALUE) {
+
+ throw new org.apache.axis2.databinding.ADBException("roomsize cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localRoomsize));
+ }
+
+ xmlWriter.writeEndElement();
+ if (localIgnorefaultsTracker){
+ namespace = "http://www.vitero.de/schema/booking";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"ignorefaults", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"ignorefaults");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("ignorefaults");
+ }
+
+ if (false) {
+
+ throw new org.apache.axis2.databinding.ADBException("ignorefaults cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localIgnorefaults));
+ }
+
+ xmlWriter.writeEndElement();
+ } if (localCafeTracker){
+ namespace = "http://www.vitero.de/schema/booking";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"cafe", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"cafe");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("cafe");
+ }
+
+ if (false) {
+
+ throw new org.apache.axis2.databinding.ADBException("cafe cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localCafe));
+ }
+
+ xmlWriter.writeEndElement();
+ } if (localCaptureTracker){
+ namespace = "http://www.vitero.de/schema/booking";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"capture", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"capture");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("capture");
+ }
+
+ if (false) {
+
+ throw new org.apache.axis2.databinding.ADBException("capture cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localCapture));
+ }
+
+ xmlWriter.writeEndElement();
+ } if (localPhoneTracker){
+ if (localPhone==null){
+ throw new org.apache.axis2.databinding.ADBException("phone cannot be null!!");
+ }
+ localPhone.serialize(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking","phone"),
+ factory,xmlWriter);
+ } if (localPcstateokrequiredTracker){
+ namespace = "http://www.vitero.de/schema/booking";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"pcstateokrequired", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"pcstateokrequired");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("pcstateokrequired");
+ }
+
+ if (false) {
+
+ throw new org.apache.axis2.databinding.ADBException("pcstateokrequired cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localPcstateokrequired));
+ }
+
+ xmlWriter.writeEndElement();
+ } if (localRepetitionpatternTracker){
+ namespace = "http://www.vitero.de/schema/booking";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"repetitionpattern", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"repetitionpattern");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("repetitionpattern");
+ }
+
+
+ if (localRepetitionpattern==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("repetitionpattern cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localRepetitionpattern);
+
+ }
+
+ xmlWriter.writeEndElement();
+ } if (localRepetitionenddateTracker){
+ namespace = "http://www.vitero.de/schema/booking";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"repetitionenddate", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"repetitionenddate");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("repetitionenddate");
+ }
+
+
+ if (localRepetitionenddate==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("repetitionenddate cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localRepetitionenddate);
+
+ }
+
+ xmlWriter.writeEndElement();
+ } if (localTimezoneTracker){
+ namespace = "http://www.vitero.de/schema/booking";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"timezone", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"timezone");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("timezone");
+ }
+
+
+ if (localTimezone==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("timezone cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localTimezone);
+
+ }
+
+ xmlWriter.writeEndElement();
+ }
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking",
+ "start"));
+
+ if (localStart != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localStart));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("start cannot be null!!");
+ }
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking",
+ "end"));
+
+ if (localEnd != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localEnd));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("end cannot be null!!");
+ }
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking",
+ "startbuffer"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localStartbuffer));
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking",
+ "endbuffer"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localEndbuffer));
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking",
+ "groupid"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localGroupid));
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking",
+ "roomsize"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localRoomsize));
+ if (localIgnorefaultsTracker){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking",
+ "ignorefaults"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localIgnorefaults));
+ } if (localCafeTracker){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking",
+ "cafe"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localCafe));
+ } if (localCaptureTracker){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking",
+ "capture"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localCapture));
+ } if (localPhoneTracker){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking",
+ "phone"));
+
+
+ if (localPhone==null){
+ throw new org.apache.axis2.databinding.ADBException("phone cannot be null!!");
+ }
+ elementList.add(localPhone);
+ } if (localPcstateokrequiredTracker){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking",
+ "pcstateokrequired"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localPcstateokrequired));
+ } if (localRepetitionpatternTracker){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking",
+ "repetitionpattern"));
+
+ if (localRepetitionpattern != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localRepetitionpattern));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("repetitionpattern cannot be null!!");
+ }
+ } if (localRepetitionenddateTracker){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking",
+ "repetitionenddate"));
+
+ if (localRepetitionenddate != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localRepetitionenddate));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("repetitionenddate cannot be null!!");
+ }
+ } if (localTimezoneTracker){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking",
+ "timezone"));
+
+ if (localTimezone != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localTimezone));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("timezone cannot be null!!");
+ }
+ }
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static Newbookingtype parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ Newbookingtype object =
+ new Newbookingtype();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"newbookingtype".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (Newbookingtype)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/booking","start").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setStart(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/booking","end").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setEnd(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/booking","startbuffer").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setStartbuffer(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToInt(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/booking","endbuffer").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setEndbuffer(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToInt(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/booking","groupid").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setGroupid(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToInt(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/booking","roomsize").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setRoomsize(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToInt(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/booking","ignorefaults").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setIgnorefaults(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToBoolean(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/booking","cafe").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setCafe(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToBoolean(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/booking","capture").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setCapture(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToBoolean(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/booking","phone").equals(reader.getName())){
+
+ object.setPhone(Phonetype.Factory.parse(reader));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/booking","pcstateokrequired").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setPcstateokrequired(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToBoolean(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/booking","repetitionpattern").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setRepetitionpattern(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/booking","repetitionenddate").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setRepetitionenddate(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/booking","timezone").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setTimezone(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class GetBookingListByGroupAndDateRequest
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/booking",
+ "getBookingListByGroupAndDateRequest",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/booking")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for Groupid
+ */
+
+
+ protected int localGroupid ;
+
+
+ /**
+ * Auto generated getter method
+ * @return int
+ */
+ public int getGroupid(){
+ return localGroupid;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Groupid
+ */
+ public void setGroupid(int param){
+
+ this.localGroupid=param;
+
+
+ }
+
+
+ /**
+ * field for Start
+ */
+
+
+ protected java.lang.String localStart ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getStart(){
+ return localStart;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Start
+ */
+ public void setStart(java.lang.String param){
+
+ this.localStart=param;
+
+
+ }
+
+
+ /**
+ * field for End
+ */
+
+
+ protected java.lang.String localEnd ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getEnd(){
+ return localEnd;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param End
+ */
+ public void setEnd(java.lang.String param){
+
+ this.localEnd=param;
+
+
+ }
+
+
+ /**
+ * field for Timezone
+ */
+
+
+ protected java.lang.String localTimezone ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localTimezoneTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getTimezone(){
+ return localTimezone;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Timezone
+ */
+ public void setTimezone(java.lang.String param){
+
+ if (param != null){
+ //update the setting tracker
+ localTimezoneTracker = true;
+ } else {
+ localTimezoneTracker = false;
+
+ }
+
+ this.localTimezone=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ GetBookingListByGroupAndDateRequest.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/booking");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":getBookingListByGroupAndDateRequest",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "getBookingListByGroupAndDateRequest",
+ xmlWriter);
+ }
+
+
+ }
+
+ namespace = "http://www.vitero.de/schema/booking";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"groupid", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"groupid");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("groupid");
+ }
+
+ if (localGroupid==java.lang.Integer.MIN_VALUE) {
+
+ throw new org.apache.axis2.databinding.ADBException("groupid cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localGroupid));
+ }
+
+ xmlWriter.writeEndElement();
+
+ namespace = "http://www.vitero.de/schema/booking";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"start", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"start");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("start");
+ }
+
+
+ if (localStart==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("start cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localStart);
+
+ }
+
+ xmlWriter.writeEndElement();
+
+ namespace = "http://www.vitero.de/schema/booking";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"end", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"end");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("end");
+ }
+
+
+ if (localEnd==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("end cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localEnd);
+
+ }
+
+ xmlWriter.writeEndElement();
+ if (localTimezoneTracker){
+ namespace = "http://www.vitero.de/schema/booking";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"timezone", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"timezone");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("timezone");
+ }
+
+
+ if (localTimezone==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("timezone cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localTimezone);
+
+ }
+
+ xmlWriter.writeEndElement();
+ }
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking",
+ "groupid"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localGroupid));
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking",
+ "start"));
+
+ if (localStart != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localStart));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("start cannot be null!!");
+ }
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking",
+ "end"));
+
+ if (localEnd != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localEnd));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("end cannot be null!!");
+ }
+ if (localTimezoneTracker){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking",
+ "timezone"));
+
+ if (localTimezone != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localTimezone));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("timezone cannot be null!!");
+ }
+ }
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static GetBookingListByGroupAndDateRequest parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ GetBookingListByGroupAndDateRequest object =
+ new GetBookingListByGroupAndDateRequest();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"getBookingListByGroupAndDateRequest".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (GetBookingListByGroupAndDateRequest)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/booking","groupid").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setGroupid(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToInt(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/booking","start").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setStart(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/booking","end").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setEnd(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/booking","timezone").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setTimezone(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class GetBookingListByGroupAndDateResponse
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/booking",
+ "getBookingListByGroupAndDateResponse",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/booking")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for GetBookingListByGroupAndDateResponse
+ */
+
+
+ protected Bookinglist localGetBookingListByGroupAndDateResponse ;
+
+
+ /**
+ * Auto generated getter method
+ * @return Bookinglist
+ */
+ public Bookinglist getGetBookingListByGroupAndDateResponse(){
+ return localGetBookingListByGroupAndDateResponse;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param GetBookingListByGroupAndDateResponse
+ */
+ public void setGetBookingListByGroupAndDateResponse(Bookinglist param){
+
+ this.localGetBookingListByGroupAndDateResponse=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ GetBookingListByGroupAndDateResponse.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+ //We can safely assume an element has only one type associated with it
+
+ if (localGetBookingListByGroupAndDateResponse==null){
+ throw new org.apache.axis2.databinding.ADBException("Property cannot be null!");
+ }
+ localGetBookingListByGroupAndDateResponse.serialize(MY_QNAME,factory,xmlWriter);
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+
+ //We can safely assume an element has only one type associated with it
+ return localGetBookingListByGroupAndDateResponse.getPullParser(MY_QNAME);
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static GetBookingListByGroupAndDateResponse parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ GetBookingListByGroupAndDateResponse object =
+ new GetBookingListByGroupAndDateResponse();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/booking","getBookingListByGroupAndDateResponse").equals(reader.getName())){
+
+ object.setGetBookingListByGroupAndDateResponse(Bookinglist.Factory.parse(reader));
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class Addexceptions_type0
+ implements org.apache.axis2.databinding.ADBBean{
+ /* This type was generated from the piece of schema that had
+ name = addexceptions_type0
+ Namespace URI = http://www.vitero.de/schema/booking
+ Namespace Prefix = ns1
+ */
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/booking")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for Bookingtime
+ * This was an Array!
+ */
+
+
+ protected Bookingtime_type0[] localBookingtime ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localBookingtimeTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return Bookingtime_type0[]
+ */
+ public Bookingtime_type0[] getBookingtime(){
+ return localBookingtime;
+ }
+
+
+
+
+
+
+ /**
+ * validate the array for Bookingtime
+ */
+ protected void validateBookingtime(Bookingtime_type0[] param){
+
+ }
+
+
+ /**
+ * Auto generated setter method
+ * @param param Bookingtime
+ */
+ public void setBookingtime(Bookingtime_type0[] param){
+
+ validateBookingtime(param);
+
+
+ if (param != null){
+ //update the setting tracker
+ localBookingtimeTracker = true;
+ } else {
+ localBookingtimeTracker = false;
+
+ }
+
+ this.localBookingtime=param;
+ }
+
+
+
+ /**
+ * Auto generated add method for the array for convenience
+ * @param param Bookingtime_type0
+ */
+ public void addBookingtime(Bookingtime_type0 param){
+ if (localBookingtime == null){
+ localBookingtime = new Bookingtime_type0[]{};
+ }
+
+
+ //update the setting tracker
+ localBookingtimeTracker = true;
+
+
+ java.util.List list =
+ org.apache.axis2.databinding.utils.ConverterUtil.toList(localBookingtime);
+ list.add(param);
+ this.localBookingtime =
+ (Bookingtime_type0[])list.toArray(
+ new Bookingtime_type0[list.size()]);
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,parentQName){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ Addexceptions_type0.this.serialize(parentQName,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ parentQName,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/booking");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":addexceptions_type0",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "addexceptions_type0",
+ xmlWriter);
+ }
+
+
+ }
+ if (localBookingtimeTracker){
+ if (localBookingtime!=null){
+ for (int i = 0;i < localBookingtime.length;i++){
+ if (localBookingtime[i] != null){
+ localBookingtime[i].serialize(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking","bookingtime"),
+ factory,xmlWriter);
+ } else {
+
+ // we don't have to do any thing since minOccures is zero
+
+ }
+
+ }
+ } else {
+
+ throw new org.apache.axis2.databinding.ADBException("bookingtime cannot be null!!");
+
+ }
+ }
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+ if (localBookingtimeTracker){
+ if (localBookingtime!=null) {
+ for (int i = 0;i < localBookingtime.length;i++){
+
+ if (localBookingtime[i] != null){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking",
+ "bookingtime"));
+ elementList.add(localBookingtime[i]);
+ } else {
+
+ // nothing to do
+
+ }
+
+ }
+ } else {
+
+ throw new org.apache.axis2.databinding.ADBException("bookingtime cannot be null!!");
+
+ }
+
+ }
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static Addexceptions_type0 parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ Addexceptions_type0 object =
+ new Addexceptions_type0();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"addexceptions_type0".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (Addexceptions_type0)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+ java.util.ArrayList list1 = new java.util.ArrayList();
+
+
+ while (!reader.isStartElement() && !reader.isEndElement()) reader.next();
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/booking","bookingtime").equals(reader.getName())){
+
+
+
+ // Process the array and step past its final element's end.
+ list1.add(Bookingtime_type0.Factory.parse(reader));
+
+ //loop until we find a start element that is not part of this array
+ boolean loopDone1 = false;
+ while(!loopDone1){
+ // We should be at the end element, but make sure
+ while (!reader.isEndElement())
+ reader.next();
+ // Step out of this element
+ reader.next();
+ // Step to next element event.
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+ if (reader.isEndElement()){
+ //two continuous end elements means we are exiting the xml structure
+ loopDone1 = true;
+ } else {
+ if (new javax.xml.namespace.QName("http://www.vitero.de/schema/booking","bookingtime").equals(reader.getName())){
+ list1.add(Bookingtime_type0.Factory.parse(reader));
+
+ }else{
+ loopDone1 = true;
+ }
+ }
+ }
+ // call the converter utility to convert and set the array
+
+ object.setBookingtime((Bookingtime_type0[])
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToArray(
+ Bookingtime_type0.class,
+ list1));
+
+ } // End of if for expected property start element
+
+ else {
+
+ }
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+ if (reader.isStartElement())
+ // A start element we are not expecting indicates a trailing invalid property
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class GetBookingListByDateResponse
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/booking",
+ "getBookingListByDateResponse",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/booking")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for GetBookingListByDateResponse
+ */
+
+
+ protected Bookinglist localGetBookingListByDateResponse ;
+
+
+ /**
+ * Auto generated getter method
+ * @return Bookinglist
+ */
+ public Bookinglist getGetBookingListByDateResponse(){
+ return localGetBookingListByDateResponse;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param GetBookingListByDateResponse
+ */
+ public void setGetBookingListByDateResponse(Bookinglist param){
+
+ this.localGetBookingListByDateResponse=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ GetBookingListByDateResponse.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+ //We can safely assume an element has only one type associated with it
+
+ if (localGetBookingListByDateResponse==null){
+ throw new org.apache.axis2.databinding.ADBException("Property cannot be null!");
+ }
+ localGetBookingListByDateResponse.serialize(MY_QNAME,factory,xmlWriter);
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+
+ //We can safely assume an element has only one type associated with it
+ return localGetBookingListByDateResponse.getPullParser(MY_QNAME);
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static GetBookingListByDateResponse parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ GetBookingListByDateResponse object =
+ new GetBookingListByDateResponse();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/booking","getBookingListByDateResponse").equals(reader.getName())){
+
+ object.setGetBookingListByDateResponse(Bookinglist.Factory.parse(reader));
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class GetBookingTimeByIdResponse
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/booking",
+ "getBookingTimeByIdResponse",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/booking")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for GetBookingTimeByIdResponse
+ */
+
+
+ protected Bookingtimetype localGetBookingTimeByIdResponse ;
+
+
+ /**
+ * Auto generated getter method
+ * @return Bookingtimetype
+ */
+ public Bookingtimetype getGetBookingTimeByIdResponse(){
+ return localGetBookingTimeByIdResponse;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param GetBookingTimeByIdResponse
+ */
+ public void setGetBookingTimeByIdResponse(Bookingtimetype param){
+
+ this.localGetBookingTimeByIdResponse=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ GetBookingTimeByIdResponse.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+ //We can safely assume an element has only one type associated with it
+
+ if (localGetBookingTimeByIdResponse==null){
+ throw new org.apache.axis2.databinding.ADBException("Property cannot be null!");
+ }
+ localGetBookingTimeByIdResponse.serialize(MY_QNAME,factory,xmlWriter);
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+
+ //We can safely assume an element has only one type associated with it
+ return localGetBookingTimeByIdResponse.getPullParser(MY_QNAME);
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static GetBookingTimeByIdResponse parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ GetBookingTimeByIdResponse object =
+ new GetBookingTimeByIdResponse();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/booking","getBookingTimeByIdResponse").equals(reader.getName())){
+
+ object.setGetBookingTimeByIdResponse(Bookingtimetype.Factory.parse(reader));
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class Phonetype
+ implements org.apache.axis2.databinding.ADBBean{
+ /* This type was generated from the piece of schema that had
+ name = phonetype
+ Namespace URI = http://www.vitero.de/schema/booking
+ Namespace Prefix = ns1
+ */
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/booking")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for Phoneconference
+ */
+
+
+ protected boolean localPhoneconference ;
+
+
+ /**
+ * Auto generated getter method
+ * @return boolean
+ */
+ public boolean getPhoneconference(){
+ return localPhoneconference;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Phoneconference
+ */
+ public void setPhoneconference(boolean param){
+
+ this.localPhoneconference=param;
+
+
+ }
+
+
+ /**
+ * field for Showdialogue
+ */
+
+
+ protected boolean localShowdialogue ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localShowdialogueTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return boolean
+ */
+ public boolean getShowdialogue(){
+ return localShowdialogue;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Showdialogue
+ */
+ public void setShowdialogue(boolean param){
+
+ // setting primitive attribute tracker to true
+
+ if (false) {
+ localShowdialogueTracker = false;
+
+ } else {
+ localShowdialogueTracker = true;
+ }
+
+ this.localShowdialogue=param;
+
+
+ }
+
+
+ /**
+ * field for Dialout
+ */
+
+
+ protected boolean localDialout ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localDialoutTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return boolean
+ */
+ public boolean getDialout(){
+ return localDialout;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Dialout
+ */
+ public void setDialout(boolean param){
+
+ // setting primitive attribute tracker to true
+
+ if (false) {
+ localDialoutTracker = false;
+
+ } else {
+ localDialoutTracker = true;
+ }
+
+ this.localDialout=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,parentQName){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ Phonetype.this.serialize(parentQName,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ parentQName,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/booking");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":phonetype",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "phonetype",
+ xmlWriter);
+ }
+
+
+ }
+
+ namespace = "http://www.vitero.de/schema/booking";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"phoneconference", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"phoneconference");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("phoneconference");
+ }
+
+ if (false) {
+
+ throw new org.apache.axis2.databinding.ADBException("phoneconference cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localPhoneconference));
+ }
+
+ xmlWriter.writeEndElement();
+ if (localShowdialogueTracker){
+ namespace = "http://www.vitero.de/schema/booking";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"showdialogue", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"showdialogue");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("showdialogue");
+ }
+
+ if (false) {
+
+ throw new org.apache.axis2.databinding.ADBException("showdialogue cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localShowdialogue));
+ }
+
+ xmlWriter.writeEndElement();
+ } if (localDialoutTracker){
+ namespace = "http://www.vitero.de/schema/booking";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"dialout", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"dialout");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("dialout");
+ }
+
+ if (false) {
+
+ throw new org.apache.axis2.databinding.ADBException("dialout cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localDialout));
+ }
+
+ xmlWriter.writeEndElement();
+ }
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking",
+ "phoneconference"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localPhoneconference));
+ if (localShowdialogueTracker){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking",
+ "showdialogue"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localShowdialogue));
+ } if (localDialoutTracker){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/booking",
+ "dialout"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localDialout));
+ }
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static Phonetype parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ Phonetype object =
+ new Phonetype();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"phonetype".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (Phonetype)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/booking","phoneconference").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setPhoneconference(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToBoolean(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/booking","showdialogue").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setShowdialogue(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToBoolean(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/booking","dialout").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setDialout(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToBoolean(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class GetBookingByBookingTimeIdResponse
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/booking",
+ "getBookingByBookingTimeIdResponse",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/booking")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for GetBookingByBookingTimeIdResponse
+ */
+
+
+ protected Bookingtype localGetBookingByBookingTimeIdResponse ;
+
+
+ /**
+ * Auto generated getter method
+ * @return Bookingtype
+ */
+ public Bookingtype getGetBookingByBookingTimeIdResponse(){
+ return localGetBookingByBookingTimeIdResponse;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param GetBookingByBookingTimeIdResponse
+ */
+ public void setGetBookingByBookingTimeIdResponse(Bookingtype param){
+
+ this.localGetBookingByBookingTimeIdResponse=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ GetBookingByBookingTimeIdResponse.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+ //We can safely assume an element has only one type associated with it
+
+ if (localGetBookingByBookingTimeIdResponse==null){
+ throw new org.apache.axis2.databinding.ADBException("Property cannot be null!");
+ }
+ localGetBookingByBookingTimeIdResponse.serialize(MY_QNAME,factory,xmlWriter);
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+
+ //We can safely assume an element has only one type associated with it
+ return localGetBookingByBookingTimeIdResponse.getPullParser(MY_QNAME);
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static GetBookingByBookingTimeIdResponse parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ GetBookingByBookingTimeIdResponse object =
+ new GetBookingByBookingTimeIdResponse();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/booking","getBookingByBookingTimeIdResponse").equals(reader.getName())){
+
+ object.setGetBookingByBookingTimeIdResponse(Bookingtype.Factory.parse(reader));
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class GetBookingTimeByIdRequest
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/booking",
+ "getBookingTimeByIdRequest",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/booking")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for GetBookingTimeByIdRequest
+ */
+
+
+ protected Bookingtimeid localGetBookingTimeByIdRequest ;
+
+
+ /**
+ * Auto generated getter method
+ * @return Bookingtimeid
+ */
+ public Bookingtimeid getGetBookingTimeByIdRequest(){
+ return localGetBookingTimeByIdRequest;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param GetBookingTimeByIdRequest
+ */
+ public void setGetBookingTimeByIdRequest(Bookingtimeid param){
+
+ this.localGetBookingTimeByIdRequest=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ GetBookingTimeByIdRequest.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+ //We can safely assume an element has only one type associated with it
+
+ if (localGetBookingTimeByIdRequest==null){
+ throw new org.apache.axis2.databinding.ADBException("Property cannot be null!");
+ }
+ localGetBookingTimeByIdRequest.serialize(MY_QNAME,factory,xmlWriter);
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+
+ //We can safely assume an element has only one type associated with it
+ return localGetBookingTimeByIdRequest.getPullParser(MY_QNAME);
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static GetBookingTimeByIdRequest parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ GetBookingTimeByIdRequest object =
+ new GetBookingTimeByIdRequest();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/booking","getBookingTimeByIdRequest").equals(reader.getName())){
+
+ object.setGetBookingTimeByIdRequest(Bookingtimeid.Factory.parse(reader));
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.BookingServiceStub.SuccessResponse param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.BookingServiceStub.SuccessResponse.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingListByGroupInFutureRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingListByGroupInFutureRequest.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingListByGroupInFutureResponse param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingListByGroupInFutureResponse.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.BookingServiceStub.CreateBookingRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.BookingServiceStub.CreateBookingRequest.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.BookingServiceStub.CreateBookingResponse param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.BookingServiceStub.CreateBookingResponse.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingListByDateRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingListByDateRequest.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingListByDateResponse param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingListByDateResponse.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingListByUserAndDateRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingListByUserAndDateRequest.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingListByUserAndDateResponse param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingListByUserAndDateResponse.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingListByUserInFutureRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingListByUserInFutureRequest.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingListByUserInFutureResponse param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingListByUserInFutureResponse.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingTimeByIdRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingTimeByIdRequest.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingTimeByIdResponse param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingTimeByIdResponse.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingByIdRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingByIdRequest.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingByIdResponse param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingByIdResponse.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.BookingServiceStub.DeleteBookingRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.BookingServiceStub.DeleteBookingRequest.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.BookingServiceStub.DeleteBookingResponse param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.BookingServiceStub.DeleteBookingResponse.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingByBookingTimeIdRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingByBookingTimeIdRequest.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingByBookingTimeIdResponse param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingByBookingTimeIdResponse.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingListByGroupAndDateRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingListByGroupAndDateRequest.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingListByGroupAndDateResponse param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingListByGroupAndDateResponse.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+
+ private org.apache.axiom.soap.SOAPEnvelope toEnvelope(org.apache.axiom.soap.SOAPFactory factory, com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingListByGroupInFutureRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault{
+
+
+ try{
+
+ org.apache.axiom.soap.SOAPEnvelope emptyEnvelope = factory.getDefaultEnvelope();
+ emptyEnvelope.getBody().addChild(param.getOMElement(com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingListByGroupInFutureRequest.MY_QNAME,factory));
+ return emptyEnvelope;
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+
+ /* methods to provide back word compatibility */
+
+
+
+ private org.apache.axiom.soap.SOAPEnvelope toEnvelope(org.apache.axiom.soap.SOAPFactory factory, com.frentix.olat.vitero.manager.stubs.BookingServiceStub.CreateBookingRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault{
+
+
+ try{
+
+ org.apache.axiom.soap.SOAPEnvelope emptyEnvelope = factory.getDefaultEnvelope();
+ emptyEnvelope.getBody().addChild(param.getOMElement(com.frentix.olat.vitero.manager.stubs.BookingServiceStub.CreateBookingRequest.MY_QNAME,factory));
+ return emptyEnvelope;
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+
+ /* methods to provide back word compatibility */
+
+
+
+ private org.apache.axiom.soap.SOAPEnvelope toEnvelope(org.apache.axiom.soap.SOAPFactory factory, com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingListByDateRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault{
+
+
+ try{
+
+ org.apache.axiom.soap.SOAPEnvelope emptyEnvelope = factory.getDefaultEnvelope();
+ emptyEnvelope.getBody().addChild(param.getOMElement(com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingListByDateRequest.MY_QNAME,factory));
+ return emptyEnvelope;
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+
+ /* methods to provide back word compatibility */
+
+
+
+ private org.apache.axiom.soap.SOAPEnvelope toEnvelope(org.apache.axiom.soap.SOAPFactory factory, com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingListByUserAndDateRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault{
+
+
+ try{
+
+ org.apache.axiom.soap.SOAPEnvelope emptyEnvelope = factory.getDefaultEnvelope();
+ emptyEnvelope.getBody().addChild(param.getOMElement(com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingListByUserAndDateRequest.MY_QNAME,factory));
+ return emptyEnvelope;
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+
+ /* methods to provide back word compatibility */
+
+
+
+ private org.apache.axiom.soap.SOAPEnvelope toEnvelope(org.apache.axiom.soap.SOAPFactory factory, com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingListByUserInFutureRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault{
+
+
+ try{
+
+ org.apache.axiom.soap.SOAPEnvelope emptyEnvelope = factory.getDefaultEnvelope();
+ emptyEnvelope.getBody().addChild(param.getOMElement(com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingListByUserInFutureRequest.MY_QNAME,factory));
+ return emptyEnvelope;
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+
+ /* methods to provide back word compatibility */
+
+
+
+ private org.apache.axiom.soap.SOAPEnvelope toEnvelope(org.apache.axiom.soap.SOAPFactory factory, com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingTimeByIdRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault{
+
+
+ try{
+
+ org.apache.axiom.soap.SOAPEnvelope emptyEnvelope = factory.getDefaultEnvelope();
+ emptyEnvelope.getBody().addChild(param.getOMElement(com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingTimeByIdRequest.MY_QNAME,factory));
+ return emptyEnvelope;
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+
+ /* methods to provide back word compatibility */
+
+
+
+ private org.apache.axiom.soap.SOAPEnvelope toEnvelope(org.apache.axiom.soap.SOAPFactory factory, com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingByIdRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault{
+
+
+ try{
+
+ org.apache.axiom.soap.SOAPEnvelope emptyEnvelope = factory.getDefaultEnvelope();
+ emptyEnvelope.getBody().addChild(param.getOMElement(com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingByIdRequest.MY_QNAME,factory));
+ return emptyEnvelope;
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+
+ /* methods to provide back word compatibility */
+
+
+
+ private org.apache.axiom.soap.SOAPEnvelope toEnvelope(org.apache.axiom.soap.SOAPFactory factory, com.frentix.olat.vitero.manager.stubs.BookingServiceStub.DeleteBookingRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault{
+
+
+ try{
+
+ org.apache.axiom.soap.SOAPEnvelope emptyEnvelope = factory.getDefaultEnvelope();
+ emptyEnvelope.getBody().addChild(param.getOMElement(com.frentix.olat.vitero.manager.stubs.BookingServiceStub.DeleteBookingRequest.MY_QNAME,factory));
+ return emptyEnvelope;
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+
+ /* methods to provide back word compatibility */
+
+
+
+ private org.apache.axiom.soap.SOAPEnvelope toEnvelope(org.apache.axiom.soap.SOAPFactory factory, com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingByBookingTimeIdRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault{
+
+
+ try{
+
+ org.apache.axiom.soap.SOAPEnvelope emptyEnvelope = factory.getDefaultEnvelope();
+ emptyEnvelope.getBody().addChild(param.getOMElement(com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingByBookingTimeIdRequest.MY_QNAME,factory));
+ return emptyEnvelope;
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+
+ /* methods to provide back word compatibility */
+
+
+
+ private org.apache.axiom.soap.SOAPEnvelope toEnvelope(org.apache.axiom.soap.SOAPFactory factory, com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingListByGroupAndDateRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault{
+
+
+ try{
+
+ org.apache.axiom.soap.SOAPEnvelope emptyEnvelope = factory.getDefaultEnvelope();
+ emptyEnvelope.getBody().addChild(param.getOMElement(com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingListByGroupAndDateRequest.MY_QNAME,factory));
+ return emptyEnvelope;
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+
+ /* methods to provide back word compatibility */
+
+
+
+
+ /**
+ * get the default envelope
+ */
+ private org.apache.axiom.soap.SOAPEnvelope toEnvelope(org.apache.axiom.soap.SOAPFactory factory){
+ return factory.getDefaultEnvelope();
+ }
+
+
+ private java.lang.Object fromOM(
+ org.apache.axiom.om.OMElement param,
+ java.lang.Class type,
+ java.util.Map extraNamespaces) throws org.apache.axis2.AxisFault{
+
+ try {
+
+ if (com.frentix.olat.vitero.manager.stubs.BookingServiceStub.SuccessResponse.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.BookingServiceStub.SuccessResponse.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ if (com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingListByGroupInFutureRequest.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingListByGroupInFutureRequest.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ if (com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingListByGroupInFutureResponse.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingListByGroupInFutureResponse.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ if (com.frentix.olat.vitero.manager.stubs.BookingServiceStub.CreateBookingRequest.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.BookingServiceStub.CreateBookingRequest.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ if (com.frentix.olat.vitero.manager.stubs.BookingServiceStub.CreateBookingResponse.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.BookingServiceStub.CreateBookingResponse.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ if (com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingListByDateRequest.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingListByDateRequest.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ if (com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingListByDateResponse.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingListByDateResponse.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ if (com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingListByUserAndDateRequest.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingListByUserAndDateRequest.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ if (com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingListByUserAndDateResponse.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingListByUserAndDateResponse.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ if (com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingListByUserInFutureRequest.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingListByUserInFutureRequest.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ if (com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingListByUserInFutureResponse.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingListByUserInFutureResponse.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ if (com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingTimeByIdRequest.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingTimeByIdRequest.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ if (com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingTimeByIdResponse.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingTimeByIdResponse.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ if (com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingByIdRequest.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingByIdRequest.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ if (com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingByIdResponse.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingByIdResponse.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ if (com.frentix.olat.vitero.manager.stubs.BookingServiceStub.DeleteBookingRequest.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.BookingServiceStub.DeleteBookingRequest.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ if (com.frentix.olat.vitero.manager.stubs.BookingServiceStub.DeleteBookingResponse.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.BookingServiceStub.DeleteBookingResponse.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ if (com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingByBookingTimeIdRequest.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingByBookingTimeIdRequest.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ if (com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingByBookingTimeIdResponse.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingByBookingTimeIdResponse.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ if (com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingListByGroupAndDateRequest.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingListByGroupAndDateRequest.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ if (com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingListByGroupAndDateResponse.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.BookingServiceStub.GetBookingListByGroupAndDateResponse.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ } catch (java.lang.Exception e) {
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+ return null;
+ }
+
+
+
+
+ }
+
\ No newline at end of file
diff --git a/src/main/java/com/frentix/olat/vitero/manager/stubs/CmsServiceCallbackHandler.java b/src/main/java/com/frentix/olat/vitero/manager/stubs/CmsServiceCallbackHandler.java
new file mode 100644
index 0000000000000000000000000000000000000000..89b42e9b852117ee4f6161cf1afe87efc5c05d5b
--- /dev/null
+++ b/src/main/java/com/frentix/olat/vitero/manager/stubs/CmsServiceCallbackHandler.java
@@ -0,0 +1,96 @@
+
+/**
+ * CmsServiceCallbackHandler.java
+ *
+ * This file was auto-generated from WSDL
+ * by the Apache Axis2 version: 1.4.1 Built on : Aug 13, 2008 (05:03:35 LKT)
+ */
+
+ package com.frentix.olat.vitero.manager.stubs;
+
+ /**
+ * CmsServiceCallbackHandler Callback class, Users can extend this class and implement
+ * their own receiveResult and receiveError methods.
+ */
+ public abstract class CmsServiceCallbackHandler{
+
+
+
+ protected Object clientData;
+
+ /**
+ * User can pass in any object that needs to be accessed once the NonBlocking
+ * Web service call is finished and appropriate method of this CallBack is called.
+ * @param clientData Object mechanism by which the user can pass in user data
+ * that will be avilable at the time this callback is called.
+ */
+ public CmsServiceCallbackHandler(Object clientData){
+ this.clientData = clientData;
+ }
+
+ /**
+ * Please use this constructor if you don't want to set any clientData
+ */
+ public CmsServiceCallbackHandler(){
+ this.clientData = null;
+ }
+
+ /**
+ * Get the client data
+ */
+
+ public Object getClientData() {
+ return clientData;
+ }
+
+
+ // No methods generated for meps other than in-out
+
+ // No methods generated for meps other than in-out
+
+ // No methods generated for meps other than in-out
+
+ // No methods generated for meps other than in-out
+
+ // No methods generated for meps other than in-out
+
+ // No methods generated for meps other than in-out
+
+ /**
+ * auto generated Axis2 call back method for getCustomerFolder method
+ * override this method for handling normal response from getCustomerFolder operation
+ */
+ public void receiveResultgetCustomerFolder(
+ com.frentix.olat.vitero.manager.stubs.CmsServiceStub.GetCustomerFolderResponse result
+ ) {
+ }
+
+ /**
+ * auto generated Axis2 Error handler
+ * override this method for handling error response from getCustomerFolder operation
+ */
+ public void receiveErrorgetCustomerFolder(java.lang.Exception e) {
+ }
+
+ // No methods generated for meps other than in-out
+
+ /**
+ * auto generated Axis2 call back method for getGroupFolder method
+ * override this method for handling normal response from getGroupFolder operation
+ */
+ public void receiveResultgetGroupFolder(
+ com.frentix.olat.vitero.manager.stubs.CmsServiceStub.GetGroupFolderResponse result
+ ) {
+ }
+
+ /**
+ * auto generated Axis2 Error handler
+ * override this method for handling error response from getGroupFolder operation
+ */
+ public void receiveErrorgetGroupFolder(java.lang.Exception e) {
+ }
+
+
+
+ }
+
\ No newline at end of file
diff --git a/src/main/java/com/frentix/olat/vitero/manager/stubs/CmsServiceStub.java b/src/main/java/com/frentix/olat/vitero/manager/stubs/CmsServiceStub.java
new file mode 100644
index 0000000000000000000000000000000000000000..fca0aa57fd74069fd7ea05067541ff6e1515e693
--- /dev/null
+++ b/src/main/java/com/frentix/olat/vitero/manager/stubs/CmsServiceStub.java
@@ -0,0 +1,9511 @@
+
+/**
+ * CmsServiceStub.java
+ *
+ * This file was auto-generated from WSDL
+ * by the Apache Axis2 version: 1.4.1 Built on : Aug 13, 2008 (05:03:35 LKT)
+ */
+ package com.frentix.olat.vitero.manager.stubs;
+
+
+
+ /*
+ * CmsServiceStub java implementation
+ */
+
+
+ public class CmsServiceStub extends org.apache.axis2.client.Stub
+ {
+ protected org.apache.axis2.description.AxisOperation[] _operations;
+
+ //hashmaps to keep the fault mapping
+ private java.util.HashMap faultExceptionNameMap = new java.util.HashMap();
+ private java.util.HashMap faultExceptionClassNameMap = new java.util.HashMap();
+ private java.util.HashMap faultMessageMap = new java.util.HashMap();
+
+ private static int counter = 0;
+
+ private static synchronized String getUniqueSuffix(){
+ // reset the counter if it is greater than 99999
+ if (counter > 99999){
+ counter = 0;
+ }
+ counter = counter + 1;
+ return Long.toString(System.currentTimeMillis()) + "_" + counter;
+ }
+
+
+ private void populateAxisService() throws org.apache.axis2.AxisFault {
+
+ //creating the Service with a unique name
+ _service = new org.apache.axis2.description.AxisService("CmsService" + getUniqueSuffix());
+ addAnonymousOperations();
+
+ //creating the operations
+ org.apache.axis2.description.AxisOperation __operation;
+
+ _operations = new org.apache.axis2.description.AxisOperation[9];
+
+ __operation = new org.apache.axis2.description.OutOnlyAxisOperation();
+
+
+ __operation.setName(new javax.xml.namespace.QName("http://www.vitero.de/schema/cms", "changeDisplaytype"));
+ _service.addOperation(__operation);
+
+
+
+
+ _operations[0]=__operation;
+
+
+ __operation = new org.apache.axis2.description.OutOnlyAxisOperation();
+
+
+ __operation.setName(new javax.xml.namespace.QName("http://www.vitero.de/schema/cms", "renameNode"));
+ _service.addOperation(__operation);
+
+
+
+
+ _operations[1]=__operation;
+
+
+ __operation = new org.apache.axis2.description.OutOnlyAxisOperation();
+
+
+ __operation.setName(new javax.xml.namespace.QName("http://www.vitero.de/schema/cms", "deleteNode"));
+ _service.addOperation(__operation);
+
+
+
+
+ _operations[2]=__operation;
+
+
+ __operation = new org.apache.axis2.description.OutInAxisOperation();
+
+
+ __operation.setName(new javax.xml.namespace.QName("http://www.vitero.de/schema/cms", "success"));
+ _service.addOperation(__operation);
+
+
+
+
+ _operations[3]=__operation;
+
+
+ __operation = new org.apache.axis2.description.OutOnlyAxisOperation();
+
+
+ __operation.setName(new javax.xml.namespace.QName("http://www.vitero.de/schema/cms", "createFolder"));
+ _service.addOperation(__operation);
+
+
+
+
+ _operations[4]=__operation;
+
+
+ __operation = new org.apache.axis2.description.OutOnlyAxisOperation();
+
+
+ __operation.setName(new javax.xml.namespace.QName("http://www.vitero.de/schema/cms", "moveNode"));
+ _service.addOperation(__operation);
+
+
+
+
+ _operations[5]=__operation;
+
+
+ __operation = new org.apache.axis2.description.OutInAxisOperation();
+
+
+ __operation.setName(new javax.xml.namespace.QName("http://www.vitero.de/schema/cms", "getCustomerFolder"));
+ _service.addOperation(__operation);
+
+
+
+
+ _operations[6]=__operation;
+
+
+ __operation = new org.apache.axis2.description.OutOnlyAxisOperation();
+
+
+ __operation.setName(new javax.xml.namespace.QName("http://www.vitero.de/schema/cms", "copyNode"));
+ _service.addOperation(__operation);
+
+
+
+
+ _operations[7]=__operation;
+
+
+ __operation = new org.apache.axis2.description.OutInAxisOperation();
+
+
+ __operation.setName(new javax.xml.namespace.QName("http://www.vitero.de/schema/cms", "getGroupFolder"));
+ _service.addOperation(__operation);
+
+
+
+
+ _operations[8]=__operation;
+
+
+ }
+
+ //populates the faults
+ private void populateFaults(){
+
+
+
+ }
+
+ /**
+ *Constructor that takes in a configContext
+ */
+
+ public CmsServiceStub(org.apache.axis2.context.ConfigurationContext configurationContext,
+ java.lang.String targetEndpoint)
+ throws org.apache.axis2.AxisFault {
+ this(configurationContext,targetEndpoint,false);
+ }
+
+
+ /**
+ * Constructor that takes in a configContext and useseperate listner
+ */
+ public CmsServiceStub(org.apache.axis2.context.ConfigurationContext configurationContext,
+ java.lang.String targetEndpoint, boolean useSeparateListener)
+ throws org.apache.axis2.AxisFault {
+ //To populate AxisService
+ populateAxisService();
+ populateFaults();
+
+ _serviceClient = new org.apache.axis2.client.ServiceClient(configurationContext,_service);
+
+
+ configurationContext = _serviceClient.getServiceContext().getConfigurationContext();
+
+ _serviceClient.getOptions().setTo(new org.apache.axis2.addressing.EndpointReference(
+ targetEndpoint));
+ _serviceClient.getOptions().setUseSeparateListener(useSeparateListener);
+
+
+ }
+
+ /**
+ * Default Constructor
+ */
+ public CmsServiceStub(org.apache.axis2.context.ConfigurationContext configurationContext) throws org.apache.axis2.AxisFault {
+
+ this(configurationContext,"http://192.168.1.54:8080/vitero/services/" );
+
+ }
+
+ /**
+ * Default Constructor
+ */
+ public CmsServiceStub() throws org.apache.axis2.AxisFault {
+
+ this("http://192.168.1.54:8080/vitero/services/" );
+
+ }
+
+ /**
+ * Constructor taking the target endpoint
+ */
+ public CmsServiceStub(java.lang.String targetEndpoint) throws org.apache.axis2.AxisFault {
+ this(null,targetEndpoint);
+ }
+
+
+
+
+
+ /**
+ * Auto generated method signature
+ *
+ */
+ public void changeDisplaytype(
+ com.frentix.olat.vitero.manager.stubs.CmsServiceStub.ChangeDisplaytypeRequest changeDisplaytypeRequest0
+
+ ) throws java.rmi.RemoteException
+
+
+ {
+ org.apache.axis2.context.MessageContext _messageContext = null;
+
+
+ org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[0].getName());
+ _operationClient.getOptions().setAction("\"\"");
+ _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true);
+
+
+
+ addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&");
+
+ org.apache.axiom.soap.SOAPEnvelope env = null;
+ _messageContext = new org.apache.axis2.context.MessageContext();
+
+
+ //Style is Doc.
+
+
+ env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()),
+ changeDisplaytypeRequest0,
+ optimizeContent(new javax.xml.namespace.QName("http://www.vitero.de/schema/cms",
+ "changeDisplaytype")));
+
+
+ //adding SOAP soap_headers
+ _serviceClient.addHeadersToEnvelope(env);
+ // create message context with that soap envelope
+
+ _messageContext.setEnvelope(env);
+
+ // add the message contxt to the operation client
+ _operationClient.addMessageContext(_messageContext);
+
+ _operationClient.execute(true);
+
+
+ _messageContext.getTransportOut().getSender().cleanup(_messageContext);
+
+ return;
+ }
+
+
+ /**
+ * Auto generated method signature
+ *
+ */
+ public void renameNode(
+ com.frentix.olat.vitero.manager.stubs.CmsServiceStub.RenameNodeRequest renameNodeRequest1
+
+ ) throws java.rmi.RemoteException
+
+
+ {
+ org.apache.axis2.context.MessageContext _messageContext = null;
+
+
+ org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[1].getName());
+ _operationClient.getOptions().setAction("\"\"");
+ _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true);
+
+
+
+ addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&");
+
+ org.apache.axiom.soap.SOAPEnvelope env = null;
+ _messageContext = new org.apache.axis2.context.MessageContext();
+
+
+ //Style is Doc.
+
+
+ env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()),
+ renameNodeRequest1,
+ optimizeContent(new javax.xml.namespace.QName("http://www.vitero.de/schema/cms",
+ "renameNode")));
+
+
+ //adding SOAP soap_headers
+ _serviceClient.addHeadersToEnvelope(env);
+ // create message context with that soap envelope
+
+ _messageContext.setEnvelope(env);
+
+ // add the message contxt to the operation client
+ _operationClient.addMessageContext(_messageContext);
+
+ _operationClient.execute(true);
+
+
+ _messageContext.getTransportOut().getSender().cleanup(_messageContext);
+
+ return;
+ }
+
+
+ /**
+ * Auto generated method signature
+ *
+ */
+ public void deleteNode(
+ com.frentix.olat.vitero.manager.stubs.CmsServiceStub.DeleteNodeRequest deleteNodeRequest2
+
+ ) throws java.rmi.RemoteException
+
+
+ {
+ org.apache.axis2.context.MessageContext _messageContext = null;
+
+
+ org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[2].getName());
+ _operationClient.getOptions().setAction("\"\"");
+ _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true);
+
+
+
+ addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&");
+
+ org.apache.axiom.soap.SOAPEnvelope env = null;
+ _messageContext = new org.apache.axis2.context.MessageContext();
+
+
+ //Style is Doc.
+
+
+ env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()),
+ deleteNodeRequest2,
+ optimizeContent(new javax.xml.namespace.QName("http://www.vitero.de/schema/cms",
+ "deleteNode")));
+
+
+ //adding SOAP soap_headers
+ _serviceClient.addHeadersToEnvelope(env);
+ // create message context with that soap envelope
+
+ _messageContext.setEnvelope(env);
+
+ // add the message contxt to the operation client
+ _operationClient.addMessageContext(_messageContext);
+
+ _operationClient.execute(true);
+
+
+ _messageContext.getTransportOut().getSender().cleanup(_messageContext);
+
+ return;
+ }
+
+
+ /**
+ * Auto generated method signature
+ *
+ */
+ public void createFolder(
+ com.frentix.olat.vitero.manager.stubs.CmsServiceStub.CreateFolderRequest createFolderRequest4
+
+ ) throws java.rmi.RemoteException
+
+
+ {
+ org.apache.axis2.context.MessageContext _messageContext = null;
+
+
+ org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[4].getName());
+ _operationClient.getOptions().setAction("\"\"");
+ _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true);
+
+
+
+ addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&");
+
+ org.apache.axiom.soap.SOAPEnvelope env = null;
+ _messageContext = new org.apache.axis2.context.MessageContext();
+
+
+ //Style is Doc.
+
+
+ env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()),
+ createFolderRequest4,
+ optimizeContent(new javax.xml.namespace.QName("http://www.vitero.de/schema/cms",
+ "createFolder")));
+
+
+ //adding SOAP soap_headers
+ _serviceClient.addHeadersToEnvelope(env);
+ // create message context with that soap envelope
+
+ _messageContext.setEnvelope(env);
+
+ // add the message contxt to the operation client
+ _operationClient.addMessageContext(_messageContext);
+
+ _operationClient.execute(true);
+
+
+ _messageContext.getTransportOut().getSender().cleanup(_messageContext);
+
+ return;
+ }
+
+
+ /**
+ * Auto generated method signature
+ *
+ */
+ public void moveNode(
+ com.frentix.olat.vitero.manager.stubs.CmsServiceStub.MoveNodeRequest moveNodeRequest5
+
+ ) throws java.rmi.RemoteException
+
+
+ {
+ org.apache.axis2.context.MessageContext _messageContext = null;
+
+
+ org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[5].getName());
+ _operationClient.getOptions().setAction("\"\"");
+ _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true);
+
+
+
+ addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&");
+
+ org.apache.axiom.soap.SOAPEnvelope env = null;
+ _messageContext = new org.apache.axis2.context.MessageContext();
+
+
+ //Style is Doc.
+
+
+ env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()),
+ moveNodeRequest5,
+ optimizeContent(new javax.xml.namespace.QName("http://www.vitero.de/schema/cms",
+ "moveNode")));
+
+
+ //adding SOAP soap_headers
+ _serviceClient.addHeadersToEnvelope(env);
+ // create message context with that soap envelope
+
+ _messageContext.setEnvelope(env);
+
+ // add the message contxt to the operation client
+ _operationClient.addMessageContext(_messageContext);
+
+ _operationClient.execute(true);
+
+
+ _messageContext.getTransportOut().getSender().cleanup(_messageContext);
+
+ return;
+ }
+
+ /**
+ * Auto generated method signature
+ *
+ * @see com.frentix.olat.vc.provider.vitero.stubs.CmsService#getCustomerFolder
+ * @param getCustomerFolderRequest6
+
+ */
+
+
+
+ public com.frentix.olat.vitero.manager.stubs.CmsServiceStub.GetCustomerFolderResponse getCustomerFolder(
+
+ com.frentix.olat.vitero.manager.stubs.CmsServiceStub.GetCustomerFolderRequest getCustomerFolderRequest6)
+
+
+ throws java.rmi.RemoteException
+
+ {
+ org.apache.axis2.context.MessageContext _messageContext = null;
+ try{
+ org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[6].getName());
+ _operationClient.getOptions().setAction("\"\"");
+ _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true);
+
+
+
+ addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&");
+
+
+ // create a message context
+ _messageContext = new org.apache.axis2.context.MessageContext();
+
+
+
+ // create SOAP envelope with that payload
+ org.apache.axiom.soap.SOAPEnvelope env = null;
+
+
+ env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()),
+ getCustomerFolderRequest6,
+ optimizeContent(new javax.xml.namespace.QName("http://www.vitero.de/schema/cms",
+ "getCustomerFolder")));
+
+ //adding SOAP soap_headers
+ _serviceClient.addHeadersToEnvelope(env);
+ // set the message context with that soap envelope
+ _messageContext.setEnvelope(env);
+
+ // add the message contxt to the operation client
+ _operationClient.addMessageContext(_messageContext);
+
+ //execute the operation client
+ _operationClient.execute(true);
+
+
+ org.apache.axis2.context.MessageContext _returnMessageContext = _operationClient.getMessageContext(
+ org.apache.axis2.wsdl.WSDLConstants.MESSAGE_LABEL_IN_VALUE);
+ org.apache.axiom.soap.SOAPEnvelope _returnEnv = _returnMessageContext.getEnvelope();
+
+
+ java.lang.Object object = fromOM(
+ _returnEnv.getBody().getFirstElement() ,
+ com.frentix.olat.vitero.manager.stubs.CmsServiceStub.GetCustomerFolderResponse.class,
+ getEnvelopeNamespaces(_returnEnv));
+
+
+ return (com.frentix.olat.vitero.manager.stubs.CmsServiceStub.GetCustomerFolderResponse)object;
+
+ }catch(org.apache.axis2.AxisFault f){
+
+ org.apache.axiom.om.OMElement faultElt = f.getDetail();
+ if (faultElt!=null){
+ if (faultExceptionNameMap.containsKey(faultElt.getQName())){
+ //make the fault by reflection
+ try{
+ java.lang.String exceptionClassName = (java.lang.String)faultExceptionClassNameMap.get(faultElt.getQName());
+ java.lang.Class exceptionClass = java.lang.Class.forName(exceptionClassName);
+ java.lang.Exception ex=
+ (java.lang.Exception) exceptionClass.newInstance();
+ //message class
+ java.lang.String messageClassName = (java.lang.String)faultMessageMap.get(faultElt.getQName());
+ java.lang.Class messageClass = java.lang.Class.forName(messageClassName);
+ java.lang.Object messageObject = fromOM(faultElt,messageClass,null);
+ java.lang.reflect.Method m = exceptionClass.getMethod("setFaultMessage",
+ new java.lang.Class[]{messageClass});
+ m.invoke(ex,new java.lang.Object[]{messageObject});
+
+
+ throw new java.rmi.RemoteException(ex.getMessage(), ex);
+ }catch(java.lang.ClassCastException e){
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.ClassNotFoundException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ }catch (java.lang.NoSuchMethodException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.reflect.InvocationTargetException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.IllegalAccessException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.InstantiationException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ }
+ }else{
+ throw f;
+ }
+ }else{
+ throw f;
+ }
+ } finally {
+ _messageContext.getTransportOut().getSender().cleanup(_messageContext);
+ }
+ }
+
+ /**
+ * Auto generated method signature for Asynchronous Invocations
+ *
+ * @see com.frentix.olat.vc.provider.vitero.stubs.CmsService#startgetCustomerFolder
+ * @param getCustomerFolderRequest6
+
+ */
+ public void startgetCustomerFolder(
+
+ com.frentix.olat.vitero.manager.stubs.CmsServiceStub.GetCustomerFolderRequest getCustomerFolderRequest6,
+
+ final com.frentix.olat.vitero.manager.stubs.CmsServiceCallbackHandler callback)
+
+ throws java.rmi.RemoteException{
+
+ org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[6].getName());
+ _operationClient.getOptions().setAction("\"\"");
+ _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true);
+
+
+
+ addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&");
+
+
+
+ // create SOAP envelope with that payload
+ org.apache.axiom.soap.SOAPEnvelope env=null;
+ final org.apache.axis2.context.MessageContext _messageContext = new org.apache.axis2.context.MessageContext();
+
+
+ //Style is Doc.
+
+
+ env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()),
+ getCustomerFolderRequest6,
+ optimizeContent(new javax.xml.namespace.QName("http://www.vitero.de/schema/cms",
+ "getCustomerFolder")));
+
+ // adding SOAP soap_headers
+ _serviceClient.addHeadersToEnvelope(env);
+ // create message context with that soap envelope
+ _messageContext.setEnvelope(env);
+
+ // add the message context to the operation client
+ _operationClient.addMessageContext(_messageContext);
+
+
+
+ _operationClient.setCallback(new org.apache.axis2.client.async.AxisCallback() {
+ public void onMessage(org.apache.axis2.context.MessageContext resultContext) {
+ try {
+ org.apache.axiom.soap.SOAPEnvelope resultEnv = resultContext.getEnvelope();
+
+ java.lang.Object object = fromOM(resultEnv.getBody().getFirstElement(),
+ com.frentix.olat.vitero.manager.stubs.CmsServiceStub.GetCustomerFolderResponse.class,
+ getEnvelopeNamespaces(resultEnv));
+ callback.receiveResultgetCustomerFolder(
+ (com.frentix.olat.vitero.manager.stubs.CmsServiceStub.GetCustomerFolderResponse)object);
+
+ } catch (org.apache.axis2.AxisFault e) {
+ callback.receiveErrorgetCustomerFolder(e);
+ }
+ }
+
+ public void onError(java.lang.Exception error) {
+ if (error instanceof org.apache.axis2.AxisFault) {
+ org.apache.axis2.AxisFault f = (org.apache.axis2.AxisFault) error;
+ org.apache.axiom.om.OMElement faultElt = f.getDetail();
+ if (faultElt!=null){
+ if (faultExceptionNameMap.containsKey(faultElt.getQName())){
+ //make the fault by reflection
+ try{
+ java.lang.String exceptionClassName = (java.lang.String)faultExceptionClassNameMap.get(faultElt.getQName());
+ java.lang.Class exceptionClass = java.lang.Class.forName(exceptionClassName);
+ java.lang.Exception ex=
+ (java.lang.Exception) exceptionClass.newInstance();
+ //message class
+ java.lang.String messageClassName = (java.lang.String)faultMessageMap.get(faultElt.getQName());
+ java.lang.Class messageClass = java.lang.Class.forName(messageClassName);
+ java.lang.Object messageObject = fromOM(faultElt,messageClass,null);
+ java.lang.reflect.Method m = exceptionClass.getMethod("setFaultMessage",
+ new java.lang.Class[]{messageClass});
+ m.invoke(ex,new java.lang.Object[]{messageObject});
+
+
+ callback.receiveErrorgetCustomerFolder(new java.rmi.RemoteException(ex.getMessage(), ex));
+ } catch(java.lang.ClassCastException e){
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetCustomerFolder(f);
+ } catch (java.lang.ClassNotFoundException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetCustomerFolder(f);
+ } catch (java.lang.NoSuchMethodException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetCustomerFolder(f);
+ } catch (java.lang.reflect.InvocationTargetException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetCustomerFolder(f);
+ } catch (java.lang.IllegalAccessException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetCustomerFolder(f);
+ } catch (java.lang.InstantiationException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetCustomerFolder(f);
+ } catch (org.apache.axis2.AxisFault e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetCustomerFolder(f);
+ }
+ } else {
+ callback.receiveErrorgetCustomerFolder(f);
+ }
+ } else {
+ callback.receiveErrorgetCustomerFolder(f);
+ }
+ } else {
+ callback.receiveErrorgetCustomerFolder(error);
+ }
+ }
+
+ public void onFault(org.apache.axis2.context.MessageContext faultContext) {
+ org.apache.axis2.AxisFault fault = org.apache.axis2.util.Utils.getInboundFaultFromMessageContext(faultContext);
+ onError(fault);
+ }
+
+ public void onComplete() {
+ try {
+ _messageContext.getTransportOut().getSender().cleanup(_messageContext);
+ } catch (org.apache.axis2.AxisFault axisFault) {
+ callback.receiveErrorgetCustomerFolder(axisFault);
+ }
+ }
+ });
+
+
+ org.apache.axis2.util.CallbackReceiver _callbackReceiver = null;
+ if ( _operations[6].getMessageReceiver()==null && _operationClient.getOptions().isUseSeparateListener()) {
+ _callbackReceiver = new org.apache.axis2.util.CallbackReceiver();
+ _operations[6].setMessageReceiver(
+ _callbackReceiver);
+ }
+
+ //execute the operation client
+ _operationClient.execute(false);
+
+ }
+
+
+ /**
+ * Auto generated method signature
+ *
+ */
+ public void copyNode(
+ com.frentix.olat.vitero.manager.stubs.CmsServiceStub.CopyNodeRequest copyNodeRequest8
+
+ ) throws java.rmi.RemoteException
+
+
+ {
+ org.apache.axis2.context.MessageContext _messageContext = null;
+
+
+ org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[7].getName());
+ _operationClient.getOptions().setAction("\"\"");
+ _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true);
+
+
+
+ addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&");
+
+ org.apache.axiom.soap.SOAPEnvelope env = null;
+ _messageContext = new org.apache.axis2.context.MessageContext();
+
+
+ //Style is Doc.
+
+
+ env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()),
+ copyNodeRequest8,
+ optimizeContent(new javax.xml.namespace.QName("http://www.vitero.de/schema/cms",
+ "copyNode")));
+
+
+ //adding SOAP soap_headers
+ _serviceClient.addHeadersToEnvelope(env);
+ // create message context with that soap envelope
+
+ _messageContext.setEnvelope(env);
+
+ // add the message contxt to the operation client
+ _operationClient.addMessageContext(_messageContext);
+
+ _operationClient.execute(true);
+
+
+ _messageContext.getTransportOut().getSender().cleanup(_messageContext);
+
+ return;
+ }
+
+ /**
+ * Auto generated method signature
+ *
+ * @see com.frentix.olat.vc.provider.vitero.stubs.CmsService#getGroupFolder
+ * @param getGroupFolderRequest9
+
+ */
+
+
+
+ public com.frentix.olat.vitero.manager.stubs.CmsServiceStub.GetGroupFolderResponse getGroupFolder(
+
+ com.frentix.olat.vitero.manager.stubs.CmsServiceStub.GetGroupFolderRequest getGroupFolderRequest9)
+
+
+ throws java.rmi.RemoteException
+
+ {
+ org.apache.axis2.context.MessageContext _messageContext = null;
+ try{
+ org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[8].getName());
+ _operationClient.getOptions().setAction("\"\"");
+ _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true);
+
+
+
+ addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&");
+
+
+ // create a message context
+ _messageContext = new org.apache.axis2.context.MessageContext();
+
+
+
+ // create SOAP envelope with that payload
+ org.apache.axiom.soap.SOAPEnvelope env = null;
+
+
+ env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()),
+ getGroupFolderRequest9,
+ optimizeContent(new javax.xml.namespace.QName("http://www.vitero.de/schema/cms",
+ "getGroupFolder")));
+
+ //adding SOAP soap_headers
+ _serviceClient.addHeadersToEnvelope(env);
+ // set the message context with that soap envelope
+ _messageContext.setEnvelope(env);
+
+ // add the message contxt to the operation client
+ _operationClient.addMessageContext(_messageContext);
+
+ //execute the operation client
+ _operationClient.execute(true);
+
+
+ org.apache.axis2.context.MessageContext _returnMessageContext = _operationClient.getMessageContext(
+ org.apache.axis2.wsdl.WSDLConstants.MESSAGE_LABEL_IN_VALUE);
+ org.apache.axiom.soap.SOAPEnvelope _returnEnv = _returnMessageContext.getEnvelope();
+
+
+ java.lang.Object object = fromOM(
+ _returnEnv.getBody().getFirstElement() ,
+ com.frentix.olat.vitero.manager.stubs.CmsServiceStub.GetGroupFolderResponse.class,
+ getEnvelopeNamespaces(_returnEnv));
+
+
+ return (com.frentix.olat.vitero.manager.stubs.CmsServiceStub.GetGroupFolderResponse)object;
+
+ }catch(org.apache.axis2.AxisFault f){
+
+ org.apache.axiom.om.OMElement faultElt = f.getDetail();
+ if (faultElt!=null){
+ if (faultExceptionNameMap.containsKey(faultElt.getQName())){
+ //make the fault by reflection
+ try{
+ java.lang.String exceptionClassName = (java.lang.String)faultExceptionClassNameMap.get(faultElt.getQName());
+ java.lang.Class exceptionClass = java.lang.Class.forName(exceptionClassName);
+ java.lang.Exception ex=
+ (java.lang.Exception) exceptionClass.newInstance();
+ //message class
+ java.lang.String messageClassName = (java.lang.String)faultMessageMap.get(faultElt.getQName());
+ java.lang.Class messageClass = java.lang.Class.forName(messageClassName);
+ java.lang.Object messageObject = fromOM(faultElt,messageClass,null);
+ java.lang.reflect.Method m = exceptionClass.getMethod("setFaultMessage",
+ new java.lang.Class[]{messageClass});
+ m.invoke(ex,new java.lang.Object[]{messageObject});
+
+
+ throw new java.rmi.RemoteException(ex.getMessage(), ex);
+ }catch(java.lang.ClassCastException e){
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.ClassNotFoundException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ }catch (java.lang.NoSuchMethodException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.reflect.InvocationTargetException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.IllegalAccessException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.InstantiationException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ }
+ }else{
+ throw f;
+ }
+ }else{
+ throw f;
+ }
+ } finally {
+ _messageContext.getTransportOut().getSender().cleanup(_messageContext);
+ }
+ }
+
+ /**
+ * Auto generated method signature for Asynchronous Invocations
+ *
+ * @see com.frentix.olat.vc.provider.vitero.stubs.CmsService#startgetGroupFolder
+ * @param getGroupFolderRequest9
+
+ */
+ public void startgetGroupFolder(
+
+ com.frentix.olat.vitero.manager.stubs.CmsServiceStub.GetGroupFolderRequest getGroupFolderRequest9,
+
+ final com.frentix.olat.vitero.manager.stubs.CmsServiceCallbackHandler callback)
+
+ throws java.rmi.RemoteException{
+
+ org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[8].getName());
+ _operationClient.getOptions().setAction("\"\"");
+ _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true);
+
+
+
+ addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&");
+
+
+
+ // create SOAP envelope with that payload
+ org.apache.axiom.soap.SOAPEnvelope env=null;
+ final org.apache.axis2.context.MessageContext _messageContext = new org.apache.axis2.context.MessageContext();
+
+
+ //Style is Doc.
+
+
+ env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()),
+ getGroupFolderRequest9,
+ optimizeContent(new javax.xml.namespace.QName("http://www.vitero.de/schema/cms",
+ "getGroupFolder")));
+
+ // adding SOAP soap_headers
+ _serviceClient.addHeadersToEnvelope(env);
+ // create message context with that soap envelope
+ _messageContext.setEnvelope(env);
+
+ // add the message context to the operation client
+ _operationClient.addMessageContext(_messageContext);
+
+
+
+ _operationClient.setCallback(new org.apache.axis2.client.async.AxisCallback() {
+ public void onMessage(org.apache.axis2.context.MessageContext resultContext) {
+ try {
+ org.apache.axiom.soap.SOAPEnvelope resultEnv = resultContext.getEnvelope();
+
+ java.lang.Object object = fromOM(resultEnv.getBody().getFirstElement(),
+ com.frentix.olat.vitero.manager.stubs.CmsServiceStub.GetGroupFolderResponse.class,
+ getEnvelopeNamespaces(resultEnv));
+ callback.receiveResultgetGroupFolder(
+ (com.frentix.olat.vitero.manager.stubs.CmsServiceStub.GetGroupFolderResponse)object);
+
+ } catch (org.apache.axis2.AxisFault e) {
+ callback.receiveErrorgetGroupFolder(e);
+ }
+ }
+
+ public void onError(java.lang.Exception error) {
+ if (error instanceof org.apache.axis2.AxisFault) {
+ org.apache.axis2.AxisFault f = (org.apache.axis2.AxisFault) error;
+ org.apache.axiom.om.OMElement faultElt = f.getDetail();
+ if (faultElt!=null){
+ if (faultExceptionNameMap.containsKey(faultElt.getQName())){
+ //make the fault by reflection
+ try{
+ java.lang.String exceptionClassName = (java.lang.String)faultExceptionClassNameMap.get(faultElt.getQName());
+ java.lang.Class exceptionClass = java.lang.Class.forName(exceptionClassName);
+ java.lang.Exception ex=
+ (java.lang.Exception) exceptionClass.newInstance();
+ //message class
+ java.lang.String messageClassName = (java.lang.String)faultMessageMap.get(faultElt.getQName());
+ java.lang.Class messageClass = java.lang.Class.forName(messageClassName);
+ java.lang.Object messageObject = fromOM(faultElt,messageClass,null);
+ java.lang.reflect.Method m = exceptionClass.getMethod("setFaultMessage",
+ new java.lang.Class[]{messageClass});
+ m.invoke(ex,new java.lang.Object[]{messageObject});
+
+
+ callback.receiveErrorgetGroupFolder(new java.rmi.RemoteException(ex.getMessage(), ex));
+ } catch(java.lang.ClassCastException e){
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetGroupFolder(f);
+ } catch (java.lang.ClassNotFoundException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetGroupFolder(f);
+ } catch (java.lang.NoSuchMethodException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetGroupFolder(f);
+ } catch (java.lang.reflect.InvocationTargetException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetGroupFolder(f);
+ } catch (java.lang.IllegalAccessException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetGroupFolder(f);
+ } catch (java.lang.InstantiationException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetGroupFolder(f);
+ } catch (org.apache.axis2.AxisFault e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetGroupFolder(f);
+ }
+ } else {
+ callback.receiveErrorgetGroupFolder(f);
+ }
+ } else {
+ callback.receiveErrorgetGroupFolder(f);
+ }
+ } else {
+ callback.receiveErrorgetGroupFolder(error);
+ }
+ }
+
+ public void onFault(org.apache.axis2.context.MessageContext faultContext) {
+ org.apache.axis2.AxisFault fault = org.apache.axis2.util.Utils.getInboundFaultFromMessageContext(faultContext);
+ onError(fault);
+ }
+
+ public void onComplete() {
+ try {
+ _messageContext.getTransportOut().getSender().cleanup(_messageContext);
+ } catch (org.apache.axis2.AxisFault axisFault) {
+ callback.receiveErrorgetGroupFolder(axisFault);
+ }
+ }
+ });
+
+
+ org.apache.axis2.util.CallbackReceiver _callbackReceiver = null;
+ if ( _operations[8].getMessageReceiver()==null && _operationClient.getOptions().isUseSeparateListener()) {
+ _callbackReceiver = new org.apache.axis2.util.CallbackReceiver();
+ _operations[8].setMessageReceiver(
+ _callbackReceiver);
+ }
+
+ //execute the operation client
+ _operationClient.execute(false);
+
+ }
+
+
+
+ /**
+ * A utility method that copies the namepaces from the SOAPEnvelope
+ */
+ private java.util.Map getEnvelopeNamespaces(org.apache.axiom.soap.SOAPEnvelope env){
+ java.util.Map returnMap = new java.util.HashMap();
+ java.util.Iterator namespaceIterator = env.getAllDeclaredNamespaces();
+ while (namespaceIterator.hasNext()) {
+ org.apache.axiom.om.OMNamespace ns = (org.apache.axiom.om.OMNamespace) namespaceIterator.next();
+ returnMap.put(ns.getPrefix(),ns.getNamespaceURI());
+ }
+ return returnMap;
+ }
+
+
+
+ private javax.xml.namespace.QName[] opNameArray = null;
+ private boolean optimizeContent(javax.xml.namespace.QName opName) {
+
+
+ if (opNameArray == null) {
+ return false;
+ }
+ for (int i = 0; i < opNameArray.length; i++) {
+ if (opName.equals(opNameArray[i])) {
+ return true;
+ }
+ }
+ return false;
+ }
+ //http://192.168.1.54:8080/vitero/services/
+ public static class MoveNodeRequest
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/cms",
+ "moveNodeRequest",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/cms")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for MoveNodeRequest
+ */
+
+
+ protected SourceAndDestNodeId localMoveNodeRequest ;
+
+
+ /**
+ * Auto generated getter method
+ * @return SourceAndDestNodeId
+ */
+ public SourceAndDestNodeId getMoveNodeRequest(){
+ return localMoveNodeRequest;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param MoveNodeRequest
+ */
+ public void setMoveNodeRequest(SourceAndDestNodeId param){
+
+ this.localMoveNodeRequest=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ MoveNodeRequest.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+ //We can safely assume an element has only one type associated with it
+
+ if (localMoveNodeRequest==null){
+ throw new org.apache.axis2.databinding.ADBException("Property cannot be null!");
+ }
+ localMoveNodeRequest.serialize(MY_QNAME,factory,xmlWriter);
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+
+ //We can safely assume an element has only one type associated with it
+ return localMoveNodeRequest.getPullParser(MY_QNAME);
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static MoveNodeRequest parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ MoveNodeRequest object =
+ new MoveNodeRequest();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/cms","moveNodeRequest").equals(reader.getName())){
+
+ object.setMoveNodeRequest(SourceAndDestNodeId.Factory.parse(reader));
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class GetCustomerFolderResponse
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/cms",
+ "getCustomerFolderResponse",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/cms")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for GetCustomerFolderResponse
+ */
+
+
+ protected WrappedFolder localGetCustomerFolderResponse ;
+
+
+ /**
+ * Auto generated getter method
+ * @return WrappedFolder
+ */
+ public WrappedFolder getGetCustomerFolderResponse(){
+ return localGetCustomerFolderResponse;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param GetCustomerFolderResponse
+ */
+ public void setGetCustomerFolderResponse(WrappedFolder param){
+
+ this.localGetCustomerFolderResponse=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ GetCustomerFolderResponse.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+ //We can safely assume an element has only one type associated with it
+
+ if (localGetCustomerFolderResponse==null){
+ throw new org.apache.axis2.databinding.ADBException("Property cannot be null!");
+ }
+ localGetCustomerFolderResponse.serialize(MY_QNAME,factory,xmlWriter);
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+
+ //We can safely assume an element has only one type associated with it
+ return localGetCustomerFolderResponse.getPullParser(MY_QNAME);
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static GetCustomerFolderResponse parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ GetCustomerFolderResponse object =
+ new GetCustomerFolderResponse();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/cms","getCustomerFolderResponse").equals(reader.getName())){
+
+ object.setGetCustomerFolderResponse(WrappedFolder.Factory.parse(reader));
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class Folder
+ implements org.apache.axis2.databinding.ADBBean{
+ /* This type was generated from the piece of schema that had
+ name = folder
+ Namespace URI = http://www.vitero.de/schema/cms
+ Namespace Prefix = ns1
+ */
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/cms")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for Nodeid
+ */
+
+
+ protected long localNodeid ;
+
+
+ /**
+ * Auto generated getter method
+ * @return long
+ */
+ public long getNodeid(){
+ return localNodeid;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Nodeid
+ */
+ public void setNodeid(long param){
+
+ this.localNodeid=param;
+
+
+ }
+
+
+ /**
+ * field for Name
+ */
+
+
+ protected java.lang.String localName ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getName(){
+ return localName;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Name
+ */
+ public void setName(java.lang.String param){
+
+ this.localName=param;
+
+
+ }
+
+
+ /**
+ * field for Children
+ */
+
+
+ protected NodeList localChildren ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localChildrenTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return NodeList
+ */
+ public NodeList getChildren(){
+ return localChildren;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Children
+ */
+ public void setChildren(NodeList param){
+
+ if (param != null){
+ //update the setting tracker
+ localChildrenTracker = true;
+ } else {
+ localChildrenTracker = false;
+
+ }
+
+ this.localChildren=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,parentQName){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ Folder.this.serialize(parentQName,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ parentQName,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/cms");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":folder",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "folder",
+ xmlWriter);
+ }
+
+
+ }
+
+ namespace = "http://www.vitero.de/schema/cms";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"nodeid", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"nodeid");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("nodeid");
+ }
+
+ if (localNodeid==java.lang.Long.MIN_VALUE) {
+
+ throw new org.apache.axis2.databinding.ADBException("nodeid cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localNodeid));
+ }
+
+ xmlWriter.writeEndElement();
+
+ namespace = "http://www.vitero.de/schema/cms";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"name", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"name");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("name");
+ }
+
+
+ if (localName==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("name cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localName);
+
+ }
+
+ xmlWriter.writeEndElement();
+ if (localChildrenTracker){
+ if (localChildren==null){
+ throw new org.apache.axis2.databinding.ADBException("children cannot be null!!");
+ }
+ localChildren.serialize(new javax.xml.namespace.QName("http://www.vitero.de/schema/cms","children"),
+ factory,xmlWriter);
+ }
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/cms",
+ "nodeid"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localNodeid));
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/cms",
+ "name"));
+
+ if (localName != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localName));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("name cannot be null!!");
+ }
+ if (localChildrenTracker){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/cms",
+ "children"));
+
+
+ if (localChildren==null){
+ throw new org.apache.axis2.databinding.ADBException("children cannot be null!!");
+ }
+ elementList.add(localChildren);
+ }
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static Folder parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ Folder object =
+ new Folder();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"folder".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (Folder)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+
+ while (!reader.isStartElement() && !reader.isEndElement()) reader.next();
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/cms","nodeid").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setNodeid(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToLong(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+
+ while (!reader.isStartElement() && !reader.isEndElement()) reader.next();
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/cms","name").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setName(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+
+ while (!reader.isStartElement() && !reader.isEndElement()) reader.next();
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/cms","children").equals(reader.getName())){
+
+ object.setChildren(NodeList.Factory.parse(reader));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else {
+
+ }
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+ if (reader.isStartElement())
+ // A start element we are not expecting indicates a trailing invalid property
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class GetGroupFolderResponse
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/cms",
+ "getGroupFolderResponse",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/cms")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for GetGroupFolderResponse
+ */
+
+
+ protected WrappedFolder localGetGroupFolderResponse ;
+
+
+ /**
+ * Auto generated getter method
+ * @return WrappedFolder
+ */
+ public WrappedFolder getGetGroupFolderResponse(){
+ return localGetGroupFolderResponse;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param GetGroupFolderResponse
+ */
+ public void setGetGroupFolderResponse(WrappedFolder param){
+
+ this.localGetGroupFolderResponse=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ GetGroupFolderResponse.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+ //We can safely assume an element has only one type associated with it
+
+ if (localGetGroupFolderResponse==null){
+ throw new org.apache.axis2.databinding.ADBException("Property cannot be null!");
+ }
+ localGetGroupFolderResponse.serialize(MY_QNAME,factory,xmlWriter);
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+
+ //We can safely assume an element has only one type associated with it
+ return localGetGroupFolderResponse.getPullParser(MY_QNAME);
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static GetGroupFolderResponse parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ GetGroupFolderResponse object =
+ new GetGroupFolderResponse();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/cms","getGroupFolderResponse").equals(reader.getName())){
+
+ object.setGetGroupFolderResponse(WrappedFolder.Factory.parse(reader));
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class SuccessResponse
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/cms",
+ "successResponse",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/cms")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for Request
+ */
+
+
+ protected java.lang.String localRequest ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getRequest(){
+ return localRequest;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Request
+ */
+ public void setRequest(java.lang.String param){
+
+ this.localRequest=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ SuccessResponse.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/cms");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":successResponse",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "successResponse",
+ xmlWriter);
+ }
+
+
+ }
+
+ namespace = "http://www.vitero.de/schema/cms";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"request", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"request");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("request");
+ }
+
+
+ if (localRequest==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("request cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localRequest);
+
+ }
+
+ xmlWriter.writeEndElement();
+
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/cms",
+ "request"));
+
+ if (localRequest != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localRequest));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("request cannot be null!!");
+ }
+
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static SuccessResponse parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ SuccessResponse object =
+ new SuccessResponse();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"successResponse".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (SuccessResponse)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/cms","request").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setRequest(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class RenameNodeRequest
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/cms",
+ "renameNodeRequest",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/cms")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for Nodeid
+ */
+
+
+ protected long localNodeid ;
+
+
+ /**
+ * Auto generated getter method
+ * @return long
+ */
+ public long getNodeid(){
+ return localNodeid;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Nodeid
+ */
+ public void setNodeid(long param){
+
+ this.localNodeid=param;
+
+
+ }
+
+
+ /**
+ * field for Name
+ */
+
+
+ protected java.lang.String localName ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getName(){
+ return localName;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Name
+ */
+ public void setName(java.lang.String param){
+
+ this.localName=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ RenameNodeRequest.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/cms");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":renameNodeRequest",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "renameNodeRequest",
+ xmlWriter);
+ }
+
+
+ }
+
+ namespace = "http://www.vitero.de/schema/cms";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"nodeid", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"nodeid");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("nodeid");
+ }
+
+ if (localNodeid==java.lang.Long.MIN_VALUE) {
+
+ throw new org.apache.axis2.databinding.ADBException("nodeid cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localNodeid));
+ }
+
+ xmlWriter.writeEndElement();
+
+ namespace = "http://www.vitero.de/schema/cms";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"name", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"name");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("name");
+ }
+
+
+ if (localName==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("name cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localName);
+
+ }
+
+ xmlWriter.writeEndElement();
+
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/cms",
+ "nodeid"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localNodeid));
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/cms",
+ "name"));
+
+ if (localName != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localName));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("name cannot be null!!");
+ }
+
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static RenameNodeRequest parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ RenameNodeRequest object =
+ new RenameNodeRequest();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"renameNodeRequest".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (RenameNodeRequest)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/cms","nodeid").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setNodeid(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToLong(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/cms","name").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setName(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class File
+ implements org.apache.axis2.databinding.ADBBean{
+ /* This type was generated from the piece of schema that had
+ name = file
+ Namespace URI = http://www.vitero.de/schema/cms
+ Namespace Prefix = ns1
+ */
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/cms")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for Nodeid
+ */
+
+
+ protected long localNodeid ;
+
+
+ /**
+ * Auto generated getter method
+ * @return long
+ */
+ public long getNodeid(){
+ return localNodeid;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Nodeid
+ */
+ public void setNodeid(long param){
+
+ this.localNodeid=param;
+
+
+ }
+
+
+ /**
+ * field for Name
+ */
+
+
+ protected java.lang.String localName ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getName(){
+ return localName;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Name
+ */
+ public void setName(java.lang.String param){
+
+ this.localName=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,parentQName){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ File.this.serialize(parentQName,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ parentQName,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/cms");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":file",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "file",
+ xmlWriter);
+ }
+
+
+ }
+
+ namespace = "http://www.vitero.de/schema/cms";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"nodeid", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"nodeid");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("nodeid");
+ }
+
+ if (localNodeid==java.lang.Long.MIN_VALUE) {
+
+ throw new org.apache.axis2.databinding.ADBException("nodeid cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localNodeid));
+ }
+
+ xmlWriter.writeEndElement();
+
+ namespace = "http://www.vitero.de/schema/cms";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"name", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"name");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("name");
+ }
+
+
+ if (localName==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("name cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localName);
+
+ }
+
+ xmlWriter.writeEndElement();
+
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/cms",
+ "nodeid"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localNodeid));
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/cms",
+ "name"));
+
+ if (localName != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localName));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("name cannot be null!!");
+ }
+
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static File parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ File object =
+ new File();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"file".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (File)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+
+ while (!reader.isStartElement() && !reader.isEndElement()) reader.next();
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/cms","nodeid").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setNodeid(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToLong(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+
+ while (!reader.isStartElement() && !reader.isEndElement()) reader.next();
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/cms","name").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setName(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+ if (reader.isStartElement())
+ // A start element we are not expecting indicates a trailing invalid property
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class WrappedFolder
+ implements org.apache.axis2.databinding.ADBBean{
+ /* This type was generated from the piece of schema that had
+ name = wrappedFolder
+ Namespace URI = http://www.vitero.de/schema/cms
+ Namespace Prefix = ns1
+ */
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/cms")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for Folder
+ */
+
+
+ protected Folder localFolder ;
+
+
+ /**
+ * Auto generated getter method
+ * @return Folder
+ */
+ public Folder getFolder(){
+ return localFolder;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Folder
+ */
+ public void setFolder(Folder param){
+
+ this.localFolder=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,parentQName){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ WrappedFolder.this.serialize(parentQName,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ parentQName,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/cms");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":wrappedFolder",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "wrappedFolder",
+ xmlWriter);
+ }
+
+
+ }
+
+ if (localFolder==null){
+ throw new org.apache.axis2.databinding.ADBException("folder cannot be null!!");
+ }
+ localFolder.serialize(new javax.xml.namespace.QName("http://www.vitero.de/schema/cms","folder"),
+ factory,xmlWriter);
+
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/cms",
+ "folder"));
+
+
+ if (localFolder==null){
+ throw new org.apache.axis2.databinding.ADBException("folder cannot be null!!");
+ }
+ elementList.add(localFolder);
+
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static WrappedFolder parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ WrappedFolder object =
+ new WrappedFolder();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"wrappedFolder".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (WrappedFolder)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/cms","folder").equals(reader.getName())){
+
+ object.setFolder(Folder.Factory.parse(reader));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class CreateFolderRequest
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/cms",
+ "createFolderRequest",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/cms")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for Nodeid
+ */
+
+
+ protected long localNodeid ;
+
+
+ /**
+ * Auto generated getter method
+ * @return long
+ */
+ public long getNodeid(){
+ return localNodeid;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Nodeid
+ */
+ public void setNodeid(long param){
+
+ this.localNodeid=param;
+
+
+ }
+
+
+ /**
+ * field for Name
+ */
+
+
+ protected java.lang.String localName ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getName(){
+ return localName;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Name
+ */
+ public void setName(java.lang.String param){
+
+ this.localName=param;
+
+
+ }
+
+
+ /**
+ * field for Authorid
+ */
+
+
+ protected int localAuthorid ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localAuthoridTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return int
+ */
+ public int getAuthorid(){
+ return localAuthorid;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Authorid
+ */
+ public void setAuthorid(int param){
+
+ // setting primitive attribute tracker to true
+
+ if (param==java.lang.Integer.MIN_VALUE) {
+ localAuthoridTracker = false;
+
+ } else {
+ localAuthoridTracker = true;
+ }
+
+ this.localAuthorid=param;
+
+
+ }
+
+
+ /**
+ * field for Displaytype
+ */
+
+
+ protected int localDisplaytype ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localDisplaytypeTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return int
+ */
+ public int getDisplaytype(){
+ return localDisplaytype;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Displaytype
+ */
+ public void setDisplaytype(int param){
+
+ // setting primitive attribute tracker to true
+
+ if (param==java.lang.Integer.MIN_VALUE) {
+ localDisplaytypeTracker = false;
+
+ } else {
+ localDisplaytypeTracker = true;
+ }
+
+ this.localDisplaytype=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ CreateFolderRequest.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/cms");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":createFolderRequest",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "createFolderRequest",
+ xmlWriter);
+ }
+
+
+ }
+
+ namespace = "http://www.vitero.de/schema/cms";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"nodeid", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"nodeid");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("nodeid");
+ }
+
+ if (localNodeid==java.lang.Long.MIN_VALUE) {
+
+ throw new org.apache.axis2.databinding.ADBException("nodeid cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localNodeid));
+ }
+
+ xmlWriter.writeEndElement();
+
+ namespace = "http://www.vitero.de/schema/cms";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"name", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"name");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("name");
+ }
+
+
+ if (localName==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("name cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localName);
+
+ }
+
+ xmlWriter.writeEndElement();
+ if (localAuthoridTracker){
+ namespace = "http://www.vitero.de/schema/cms";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"authorid", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"authorid");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("authorid");
+ }
+
+ if (localAuthorid==java.lang.Integer.MIN_VALUE) {
+
+ throw new org.apache.axis2.databinding.ADBException("authorid cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localAuthorid));
+ }
+
+ xmlWriter.writeEndElement();
+ } if (localDisplaytypeTracker){
+ namespace = "http://www.vitero.de/schema/cms";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"displaytype", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"displaytype");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("displaytype");
+ }
+
+ if (localDisplaytype==java.lang.Integer.MIN_VALUE) {
+
+ throw new org.apache.axis2.databinding.ADBException("displaytype cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localDisplaytype));
+ }
+
+ xmlWriter.writeEndElement();
+ }
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/cms",
+ "nodeid"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localNodeid));
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/cms",
+ "name"));
+
+ if (localName != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localName));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("name cannot be null!!");
+ }
+ if (localAuthoridTracker){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/cms",
+ "authorid"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localAuthorid));
+ } if (localDisplaytypeTracker){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/cms",
+ "displaytype"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localDisplaytype));
+ }
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static CreateFolderRequest parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ CreateFolderRequest object =
+ new CreateFolderRequest();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"createFolderRequest".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (CreateFolderRequest)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/cms","nodeid").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setNodeid(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToLong(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/cms","name").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setName(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/cms","authorid").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setAuthorid(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToInt(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/cms","displaytype").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setDisplaytype(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToInt(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class CopyNodeRequest
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/cms",
+ "copyNodeRequest",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/cms")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for CopyNodeRequest
+ */
+
+
+ protected SourceAndDestNodeId localCopyNodeRequest ;
+
+
+ /**
+ * Auto generated getter method
+ * @return SourceAndDestNodeId
+ */
+ public SourceAndDestNodeId getCopyNodeRequest(){
+ return localCopyNodeRequest;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param CopyNodeRequest
+ */
+ public void setCopyNodeRequest(SourceAndDestNodeId param){
+
+ this.localCopyNodeRequest=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ CopyNodeRequest.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+ //We can safely assume an element has only one type associated with it
+
+ if (localCopyNodeRequest==null){
+ throw new org.apache.axis2.databinding.ADBException("Property cannot be null!");
+ }
+ localCopyNodeRequest.serialize(MY_QNAME,factory,xmlWriter);
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+
+ //We can safely assume an element has only one type associated with it
+ return localCopyNodeRequest.getPullParser(MY_QNAME);
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static CopyNodeRequest parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ CopyNodeRequest object =
+ new CopyNodeRequest();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/cms","copyNodeRequest").equals(reader.getName())){
+
+ object.setCopyNodeRequest(SourceAndDestNodeId.Factory.parse(reader));
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class GetGroupFolderRequest
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/cms",
+ "getGroupFolderRequest",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/cms")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for Groupid
+ */
+
+
+ protected int localGroupid ;
+
+
+ /**
+ * Auto generated getter method
+ * @return int
+ */
+ public int getGroupid(){
+ return localGroupid;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Groupid
+ */
+ public void setGroupid(int param){
+
+ this.localGroupid=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ GetGroupFolderRequest.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/cms");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":getGroupFolderRequest",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "getGroupFolderRequest",
+ xmlWriter);
+ }
+
+
+ }
+
+ namespace = "http://www.vitero.de/schema/cms";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"groupid", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"groupid");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("groupid");
+ }
+
+ if (localGroupid==java.lang.Integer.MIN_VALUE) {
+
+ throw new org.apache.axis2.databinding.ADBException("groupid cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localGroupid));
+ }
+
+ xmlWriter.writeEndElement();
+
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/cms",
+ "groupid"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localGroupid));
+
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static GetGroupFolderRequest parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ GetGroupFolderRequest object =
+ new GetGroupFolderRequest();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"getGroupFolderRequest".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (GetGroupFolderRequest)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/cms","groupid").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setGroupid(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToInt(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class ExtensionMapper{
+
+ public static java.lang.Object getTypeObject(java.lang.String namespaceURI,
+ java.lang.String typeName,
+ javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+
+
+ if (
+ "http://www.vitero.de/schema/cms".equals(namespaceURI) &&
+ "wrappedFolder".equals(typeName)){
+
+ return WrappedFolder.Factory.parse(reader);
+
+
+ }
+
+
+ if (
+ "http://www.vitero.de/schema/cms".equals(namespaceURI) &&
+ "nodeList".equals(typeName)){
+
+ return NodeList.Factory.parse(reader);
+
+
+ }
+
+
+ if (
+ "http://www.vitero.de/schema/cms".equals(namespaceURI) &&
+ "folder".equals(typeName)){
+
+ return Folder.Factory.parse(reader);
+
+
+ }
+
+
+ if (
+ "http://www.vitero.de/schema/cms".equals(namespaceURI) &&
+ "sourceAndDestNodeId".equals(typeName)){
+
+ return SourceAndDestNodeId.Factory.parse(reader);
+
+
+ }
+
+
+ if (
+ "http://www.vitero.de/schema/cms".equals(namespaceURI) &&
+ "file".equals(typeName)){
+
+ return File.Factory.parse(reader);
+
+
+ }
+
+
+ throw new org.apache.axis2.databinding.ADBException("Unsupported type " + namespaceURI + " " + typeName);
+ }
+
+ }
+
+ public static class NodeList
+ implements org.apache.axis2.databinding.ADBBean{
+ /* This type was generated from the piece of schema that had
+ name = nodeList
+ Namespace URI = http://www.vitero.de/schema/cms
+ Namespace Prefix = ns1
+ */
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/cms")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for Folder
+ * This was an Array!
+ */
+
+
+ protected Folder[] localFolder ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localFolderTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return Folder[]
+ */
+ public Folder[] getFolder(){
+ return localFolder;
+ }
+
+
+
+
+
+
+ /**
+ * validate the array for Folder
+ */
+ protected void validateFolder(Folder[] param){
+
+ }
+
+
+ /**
+ * Auto generated setter method
+ * @param param Folder
+ */
+ public void setFolder(Folder[] param){
+
+ validateFolder(param);
+
+
+ if (param != null){
+ //update the setting tracker
+ localFolderTracker = true;
+ } else {
+ localFolderTracker = false;
+
+ }
+
+ this.localFolder=param;
+ }
+
+
+
+ /**
+ * Auto generated add method for the array for convenience
+ * @param param Folder
+ */
+ public void addFolder(Folder param){
+ if (localFolder == null){
+ localFolder = new Folder[]{};
+ }
+
+
+ //update the setting tracker
+ localFolderTracker = true;
+
+
+ java.util.List list =
+ org.apache.axis2.databinding.utils.ConverterUtil.toList(localFolder);
+ list.add(param);
+ this.localFolder =
+ (Folder[])list.toArray(
+ new Folder[list.size()]);
+
+ }
+
+
+ /**
+ * field for File
+ * This was an Array!
+ */
+
+
+ protected File[] localFile ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localFileTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return File[]
+ */
+ public File[] getFile(){
+ return localFile;
+ }
+
+
+
+
+
+
+ /**
+ * validate the array for File
+ */
+ protected void validateFile(File[] param){
+
+ }
+
+
+ /**
+ * Auto generated setter method
+ * @param param File
+ */
+ public void setFile(File[] param){
+
+ validateFile(param);
+
+
+ if (param != null){
+ //update the setting tracker
+ localFileTracker = true;
+ } else {
+ localFileTracker = false;
+
+ }
+
+ this.localFile=param;
+ }
+
+
+
+ /**
+ * Auto generated add method for the array for convenience
+ * @param param File
+ */
+ public void addFile(File param){
+ if (localFile == null){
+ localFile = new File[]{};
+ }
+
+
+ //update the setting tracker
+ localFileTracker = true;
+
+
+ java.util.List list =
+ org.apache.axis2.databinding.utils.ConverterUtil.toList(localFile);
+ list.add(param);
+ this.localFile =
+ (File[])list.toArray(
+ new File[list.size()]);
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,parentQName){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ NodeList.this.serialize(parentQName,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ parentQName,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/cms");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":nodeList",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "nodeList",
+ xmlWriter);
+ }
+
+
+ }
+ if (localFolderTracker){
+ if (localFolder!=null){
+ for (int i = 0;i < localFolder.length;i++){
+ if (localFolder[i] != null){
+ localFolder[i].serialize(new javax.xml.namespace.QName("http://www.vitero.de/schema/cms","folder"),
+ factory,xmlWriter);
+ } else {
+
+ // we don't have to do any thing since minOccures is zero
+
+ }
+
+ }
+ } else {
+
+ throw new org.apache.axis2.databinding.ADBException("folder cannot be null!!");
+
+ }
+ } if (localFileTracker){
+ if (localFile!=null){
+ for (int i = 0;i < localFile.length;i++){
+ if (localFile[i] != null){
+ localFile[i].serialize(new javax.xml.namespace.QName("http://www.vitero.de/schema/cms","file"),
+ factory,xmlWriter);
+ } else {
+
+ // we don't have to do any thing since minOccures is zero
+
+ }
+
+ }
+ } else {
+
+ throw new org.apache.axis2.databinding.ADBException("file cannot be null!!");
+
+ }
+ }
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+ if (localFolderTracker){
+ if (localFolder!=null) {
+ for (int i = 0;i < localFolder.length;i++){
+
+ if (localFolder[i] != null){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/cms",
+ "folder"));
+ elementList.add(localFolder[i]);
+ } else {
+
+ // nothing to do
+
+ }
+
+ }
+ } else {
+
+ throw new org.apache.axis2.databinding.ADBException("folder cannot be null!!");
+
+ }
+
+ } if (localFileTracker){
+ if (localFile!=null) {
+ for (int i = 0;i < localFile.length;i++){
+
+ if (localFile[i] != null){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/cms",
+ "file"));
+ elementList.add(localFile[i]);
+ } else {
+
+ // nothing to do
+
+ }
+
+ }
+ } else {
+
+ throw new org.apache.axis2.databinding.ADBException("file cannot be null!!");
+
+ }
+
+ }
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static NodeList parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ NodeList object =
+ new NodeList();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"nodeList".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (NodeList)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+ java.util.ArrayList list1 = new java.util.ArrayList();
+
+ java.util.ArrayList list2 = new java.util.ArrayList();
+
+
+ while (!reader.isStartElement() && !reader.isEndElement()) reader.next();
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/cms","folder").equals(reader.getName())){
+
+
+
+ // Process the array and step past its final element's end.
+ list1.add(Folder.Factory.parse(reader));
+
+ //loop until we find a start element that is not part of this array
+ boolean loopDone1 = false;
+ while(!loopDone1){
+ // We should be at the end element, but make sure
+ while (!reader.isEndElement())
+ reader.next();
+ // Step out of this element
+ reader.next();
+ // Step to next element event.
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+ if (reader.isEndElement()){
+ //two continuous end elements means we are exiting the xml structure
+ loopDone1 = true;
+ } else {
+ if (new javax.xml.namespace.QName("http://www.vitero.de/schema/cms","folder").equals(reader.getName())){
+ list1.add(Folder.Factory.parse(reader));
+
+ }else{
+ loopDone1 = true;
+ }
+ }
+ }
+ // call the converter utility to convert and set the array
+
+ object.setFolder((Folder[])
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToArray(
+ Folder.class,
+ list1));
+
+ } // End of if for expected property start element
+
+ else {
+
+ }
+
+
+ while (!reader.isStartElement() && !reader.isEndElement()) reader.next();
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/cms","file").equals(reader.getName())){
+
+
+
+ // Process the array and step past its final element's end.
+ list2.add(File.Factory.parse(reader));
+
+ //loop until we find a start element that is not part of this array
+ boolean loopDone2 = false;
+ while(!loopDone2){
+ // We should be at the end element, but make sure
+ while (!reader.isEndElement())
+ reader.next();
+ // Step out of this element
+ reader.next();
+ // Step to next element event.
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+ if (reader.isEndElement()){
+ //two continuous end elements means we are exiting the xml structure
+ loopDone2 = true;
+ } else {
+ if (new javax.xml.namespace.QName("http://www.vitero.de/schema/cms","file").equals(reader.getName())){
+ list2.add(File.Factory.parse(reader));
+
+ }else{
+ loopDone2 = true;
+ }
+ }
+ }
+ // call the converter utility to convert and set the array
+
+ object.setFile((File[])
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToArray(
+ File.class,
+ list2));
+
+ } // End of if for expected property start element
+
+ else {
+
+ }
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+ if (reader.isStartElement())
+ // A start element we are not expecting indicates a trailing invalid property
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class SourceAndDestNodeId
+ implements org.apache.axis2.databinding.ADBBean{
+ /* This type was generated from the piece of schema that had
+ name = sourceAndDestNodeId
+ Namespace URI = http://www.vitero.de/schema/cms
+ Namespace Prefix = ns1
+ */
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/cms")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for Sourcenodeid
+ */
+
+
+ protected long localSourcenodeid ;
+
+
+ /**
+ * Auto generated getter method
+ * @return long
+ */
+ public long getSourcenodeid(){
+ return localSourcenodeid;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Sourcenodeid
+ */
+ public void setSourcenodeid(long param){
+
+ this.localSourcenodeid=param;
+
+
+ }
+
+
+ /**
+ * field for Destnodeid
+ */
+
+
+ protected long localDestnodeid ;
+
+
+ /**
+ * Auto generated getter method
+ * @return long
+ */
+ public long getDestnodeid(){
+ return localDestnodeid;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Destnodeid
+ */
+ public void setDestnodeid(long param){
+
+ this.localDestnodeid=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,parentQName){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ SourceAndDestNodeId.this.serialize(parentQName,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ parentQName,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/cms");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":sourceAndDestNodeId",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "sourceAndDestNodeId",
+ xmlWriter);
+ }
+
+
+ }
+
+ namespace = "http://www.vitero.de/schema/cms";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"sourcenodeid", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"sourcenodeid");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("sourcenodeid");
+ }
+
+ if (localSourcenodeid==java.lang.Long.MIN_VALUE) {
+
+ throw new org.apache.axis2.databinding.ADBException("sourcenodeid cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localSourcenodeid));
+ }
+
+ xmlWriter.writeEndElement();
+
+ namespace = "http://www.vitero.de/schema/cms";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"destnodeid", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"destnodeid");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("destnodeid");
+ }
+
+ if (localDestnodeid==java.lang.Long.MIN_VALUE) {
+
+ throw new org.apache.axis2.databinding.ADBException("destnodeid cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localDestnodeid));
+ }
+
+ xmlWriter.writeEndElement();
+
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/cms",
+ "sourcenodeid"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localSourcenodeid));
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/cms",
+ "destnodeid"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localDestnodeid));
+
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static SourceAndDestNodeId parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ SourceAndDestNodeId object =
+ new SourceAndDestNodeId();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"sourceAndDestNodeId".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (SourceAndDestNodeId)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/cms","sourcenodeid").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setSourcenodeid(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToLong(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/cms","destnodeid").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setDestnodeid(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToLong(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class DeleteNodeRequest
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/cms",
+ "deleteNodeRequest",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/cms")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for Nodeid
+ */
+
+
+ protected long localNodeid ;
+
+
+ /**
+ * Auto generated getter method
+ * @return long
+ */
+ public long getNodeid(){
+ return localNodeid;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Nodeid
+ */
+ public void setNodeid(long param){
+
+ this.localNodeid=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ DeleteNodeRequest.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/cms");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":deleteNodeRequest",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "deleteNodeRequest",
+ xmlWriter);
+ }
+
+
+ }
+
+ namespace = "http://www.vitero.de/schema/cms";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"nodeid", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"nodeid");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("nodeid");
+ }
+
+ if (localNodeid==java.lang.Long.MIN_VALUE) {
+
+ throw new org.apache.axis2.databinding.ADBException("nodeid cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localNodeid));
+ }
+
+ xmlWriter.writeEndElement();
+
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/cms",
+ "nodeid"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localNodeid));
+
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static DeleteNodeRequest parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ DeleteNodeRequest object =
+ new DeleteNodeRequest();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"deleteNodeRequest".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (DeleteNodeRequest)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/cms","nodeid").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setNodeid(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToLong(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class GetCustomerFolderRequest
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/cms",
+ "getCustomerFolderRequest",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/cms")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for Customerid
+ */
+
+
+ protected int localCustomerid ;
+
+
+ /**
+ * Auto generated getter method
+ * @return int
+ */
+ public int getCustomerid(){
+ return localCustomerid;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Customerid
+ */
+ public void setCustomerid(int param){
+
+ this.localCustomerid=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ GetCustomerFolderRequest.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/cms");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":getCustomerFolderRequest",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "getCustomerFolderRequest",
+ xmlWriter);
+ }
+
+
+ }
+
+ namespace = "http://www.vitero.de/schema/cms";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"customerid", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"customerid");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("customerid");
+ }
+
+ if (localCustomerid==java.lang.Integer.MIN_VALUE) {
+
+ throw new org.apache.axis2.databinding.ADBException("customerid cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localCustomerid));
+ }
+
+ xmlWriter.writeEndElement();
+
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/cms",
+ "customerid"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localCustomerid));
+
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static GetCustomerFolderRequest parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ GetCustomerFolderRequest object =
+ new GetCustomerFolderRequest();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"getCustomerFolderRequest".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (GetCustomerFolderRequest)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/cms","customerid").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setCustomerid(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToInt(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class ChangeDisplaytypeRequest
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/cms",
+ "changeDisplaytypeRequest",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/cms")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for Nodeid
+ */
+
+
+ protected long localNodeid ;
+
+
+ /**
+ * Auto generated getter method
+ * @return long
+ */
+ public long getNodeid(){
+ return localNodeid;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Nodeid
+ */
+ public void setNodeid(long param){
+
+ this.localNodeid=param;
+
+
+ }
+
+
+ /**
+ * field for Displaytype
+ */
+
+
+ protected int localDisplaytype ;
+
+
+ /**
+ * Auto generated getter method
+ * @return int
+ */
+ public int getDisplaytype(){
+ return localDisplaytype;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Displaytype
+ */
+ public void setDisplaytype(int param){
+
+ this.localDisplaytype=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ ChangeDisplaytypeRequest.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/cms");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":changeDisplaytypeRequest",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "changeDisplaytypeRequest",
+ xmlWriter);
+ }
+
+
+ }
+
+ namespace = "http://www.vitero.de/schema/cms";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"nodeid", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"nodeid");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("nodeid");
+ }
+
+ if (localNodeid==java.lang.Long.MIN_VALUE) {
+
+ throw new org.apache.axis2.databinding.ADBException("nodeid cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localNodeid));
+ }
+
+ xmlWriter.writeEndElement();
+
+ namespace = "http://www.vitero.de/schema/cms";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"displaytype", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"displaytype");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("displaytype");
+ }
+
+ if (localDisplaytype==java.lang.Integer.MIN_VALUE) {
+
+ throw new org.apache.axis2.databinding.ADBException("displaytype cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localDisplaytype));
+ }
+
+ xmlWriter.writeEndElement();
+
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/cms",
+ "nodeid"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localNodeid));
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/cms",
+ "displaytype"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localDisplaytype));
+
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static ChangeDisplaytypeRequest parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ ChangeDisplaytypeRequest object =
+ new ChangeDisplaytypeRequest();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"changeDisplaytypeRequest".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (ChangeDisplaytypeRequest)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+
+ while (!reader.isStartElement() && !reader.isEndElement()) reader.next();
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/cms","nodeid").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setNodeid(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToLong(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+
+ while (!reader.isStartElement() && !reader.isEndElement()) reader.next();
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/cms","displaytype").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setDisplaytype(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToInt(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+ if (reader.isStartElement())
+ // A start element we are not expecting indicates a trailing invalid property
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.CmsServiceStub.ChangeDisplaytypeRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.CmsServiceStub.ChangeDisplaytypeRequest.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.CmsServiceStub.RenameNodeRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.CmsServiceStub.RenameNodeRequest.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.CmsServiceStub.DeleteNodeRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.CmsServiceStub.DeleteNodeRequest.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.CmsServiceStub.SuccessResponse param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.CmsServiceStub.SuccessResponse.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.CmsServiceStub.CreateFolderRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.CmsServiceStub.CreateFolderRequest.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.CmsServiceStub.MoveNodeRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.CmsServiceStub.MoveNodeRequest.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.CmsServiceStub.GetCustomerFolderRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.CmsServiceStub.GetCustomerFolderRequest.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.CmsServiceStub.GetCustomerFolderResponse param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.CmsServiceStub.GetCustomerFolderResponse.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.CmsServiceStub.CopyNodeRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.CmsServiceStub.CopyNodeRequest.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.CmsServiceStub.GetGroupFolderRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.CmsServiceStub.GetGroupFolderRequest.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.CmsServiceStub.GetGroupFolderResponse param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.CmsServiceStub.GetGroupFolderResponse.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+
+ private org.apache.axiom.soap.SOAPEnvelope toEnvelope(org.apache.axiom.soap.SOAPFactory factory, com.frentix.olat.vitero.manager.stubs.CmsServiceStub.ChangeDisplaytypeRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault{
+
+
+ try{
+
+ org.apache.axiom.soap.SOAPEnvelope emptyEnvelope = factory.getDefaultEnvelope();
+ emptyEnvelope.getBody().addChild(param.getOMElement(com.frentix.olat.vitero.manager.stubs.CmsServiceStub.ChangeDisplaytypeRequest.MY_QNAME,factory));
+ return emptyEnvelope;
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+
+ /* methods to provide back word compatibility */
+
+
+
+ private org.apache.axiom.soap.SOAPEnvelope toEnvelope(org.apache.axiom.soap.SOAPFactory factory, com.frentix.olat.vitero.manager.stubs.CmsServiceStub.RenameNodeRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault{
+
+
+ try{
+
+ org.apache.axiom.soap.SOAPEnvelope emptyEnvelope = factory.getDefaultEnvelope();
+ emptyEnvelope.getBody().addChild(param.getOMElement(com.frentix.olat.vitero.manager.stubs.CmsServiceStub.RenameNodeRequest.MY_QNAME,factory));
+ return emptyEnvelope;
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+
+ /* methods to provide back word compatibility */
+
+
+
+ private org.apache.axiom.soap.SOAPEnvelope toEnvelope(org.apache.axiom.soap.SOAPFactory factory, com.frentix.olat.vitero.manager.stubs.CmsServiceStub.DeleteNodeRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault{
+
+
+ try{
+
+ org.apache.axiom.soap.SOAPEnvelope emptyEnvelope = factory.getDefaultEnvelope();
+ emptyEnvelope.getBody().addChild(param.getOMElement(com.frentix.olat.vitero.manager.stubs.CmsServiceStub.DeleteNodeRequest.MY_QNAME,factory));
+ return emptyEnvelope;
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+
+ /* methods to provide back word compatibility */
+
+
+
+ private org.apache.axiom.soap.SOAPEnvelope toEnvelope(org.apache.axiom.soap.SOAPFactory factory, com.frentix.olat.vitero.manager.stubs.CmsServiceStub.CreateFolderRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault{
+
+
+ try{
+
+ org.apache.axiom.soap.SOAPEnvelope emptyEnvelope = factory.getDefaultEnvelope();
+ emptyEnvelope.getBody().addChild(param.getOMElement(com.frentix.olat.vitero.manager.stubs.CmsServiceStub.CreateFolderRequest.MY_QNAME,factory));
+ return emptyEnvelope;
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+
+ /* methods to provide back word compatibility */
+
+
+
+ private org.apache.axiom.soap.SOAPEnvelope toEnvelope(org.apache.axiom.soap.SOAPFactory factory, com.frentix.olat.vitero.manager.stubs.CmsServiceStub.MoveNodeRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault{
+
+
+ try{
+
+ org.apache.axiom.soap.SOAPEnvelope emptyEnvelope = factory.getDefaultEnvelope();
+ emptyEnvelope.getBody().addChild(param.getOMElement(com.frentix.olat.vitero.manager.stubs.CmsServiceStub.MoveNodeRequest.MY_QNAME,factory));
+ return emptyEnvelope;
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+
+ /* methods to provide back word compatibility */
+
+
+
+ private org.apache.axiom.soap.SOAPEnvelope toEnvelope(org.apache.axiom.soap.SOAPFactory factory, com.frentix.olat.vitero.manager.stubs.CmsServiceStub.GetCustomerFolderRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault{
+
+
+ try{
+
+ org.apache.axiom.soap.SOAPEnvelope emptyEnvelope = factory.getDefaultEnvelope();
+ emptyEnvelope.getBody().addChild(param.getOMElement(com.frentix.olat.vitero.manager.stubs.CmsServiceStub.GetCustomerFolderRequest.MY_QNAME,factory));
+ return emptyEnvelope;
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+
+ /* methods to provide back word compatibility */
+
+
+
+ private org.apache.axiom.soap.SOAPEnvelope toEnvelope(org.apache.axiom.soap.SOAPFactory factory, com.frentix.olat.vitero.manager.stubs.CmsServiceStub.CopyNodeRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault{
+
+
+ try{
+
+ org.apache.axiom.soap.SOAPEnvelope emptyEnvelope = factory.getDefaultEnvelope();
+ emptyEnvelope.getBody().addChild(param.getOMElement(com.frentix.olat.vitero.manager.stubs.CmsServiceStub.CopyNodeRequest.MY_QNAME,factory));
+ return emptyEnvelope;
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+
+ /* methods to provide back word compatibility */
+
+
+
+ private org.apache.axiom.soap.SOAPEnvelope toEnvelope(org.apache.axiom.soap.SOAPFactory factory, com.frentix.olat.vitero.manager.stubs.CmsServiceStub.GetGroupFolderRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault{
+
+
+ try{
+
+ org.apache.axiom.soap.SOAPEnvelope emptyEnvelope = factory.getDefaultEnvelope();
+ emptyEnvelope.getBody().addChild(param.getOMElement(com.frentix.olat.vitero.manager.stubs.CmsServiceStub.GetGroupFolderRequest.MY_QNAME,factory));
+ return emptyEnvelope;
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+
+ /* methods to provide back word compatibility */
+
+
+
+
+ /**
+ * get the default envelope
+ */
+ private org.apache.axiom.soap.SOAPEnvelope toEnvelope(org.apache.axiom.soap.SOAPFactory factory){
+ return factory.getDefaultEnvelope();
+ }
+
+
+ private java.lang.Object fromOM(
+ org.apache.axiom.om.OMElement param,
+ java.lang.Class type,
+ java.util.Map extraNamespaces) throws org.apache.axis2.AxisFault{
+
+ try {
+
+ if (com.frentix.olat.vitero.manager.stubs.CmsServiceStub.ChangeDisplaytypeRequest.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.CmsServiceStub.ChangeDisplaytypeRequest.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ if (com.frentix.olat.vitero.manager.stubs.CmsServiceStub.RenameNodeRequest.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.CmsServiceStub.RenameNodeRequest.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ if (com.frentix.olat.vitero.manager.stubs.CmsServiceStub.DeleteNodeRequest.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.CmsServiceStub.DeleteNodeRequest.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ if (com.frentix.olat.vitero.manager.stubs.CmsServiceStub.SuccessResponse.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.CmsServiceStub.SuccessResponse.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ if (com.frentix.olat.vitero.manager.stubs.CmsServiceStub.CreateFolderRequest.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.CmsServiceStub.CreateFolderRequest.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ if (com.frentix.olat.vitero.manager.stubs.CmsServiceStub.MoveNodeRequest.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.CmsServiceStub.MoveNodeRequest.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ if (com.frentix.olat.vitero.manager.stubs.CmsServiceStub.GetCustomerFolderRequest.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.CmsServiceStub.GetCustomerFolderRequest.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ if (com.frentix.olat.vitero.manager.stubs.CmsServiceStub.GetCustomerFolderResponse.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.CmsServiceStub.GetCustomerFolderResponse.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ if (com.frentix.olat.vitero.manager.stubs.CmsServiceStub.CopyNodeRequest.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.CmsServiceStub.CopyNodeRequest.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ if (com.frentix.olat.vitero.manager.stubs.CmsServiceStub.GetGroupFolderRequest.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.CmsServiceStub.GetGroupFolderRequest.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ if (com.frentix.olat.vitero.manager.stubs.CmsServiceStub.GetGroupFolderResponse.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.CmsServiceStub.GetGroupFolderResponse.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ } catch (java.lang.Exception e) {
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+ return null;
+ }
+
+
+
+
+ }
+
\ No newline at end of file
diff --git a/src/main/java/com/frentix/olat/vitero/manager/stubs/CustomerServiceCallbackHandler.java b/src/main/java/com/frentix/olat/vitero/manager/stubs/CustomerServiceCallbackHandler.java
new file mode 100644
index 0000000000000000000000000000000000000000..70789aaad8407cadd70b43ffb5a37dbad8a4a28e
--- /dev/null
+++ b/src/main/java/com/frentix/olat/vitero/manager/stubs/CustomerServiceCallbackHandler.java
@@ -0,0 +1,128 @@
+
+/**
+ * CustomerServiceCallbackHandler.java
+ *
+ * This file was auto-generated from WSDL
+ * by the Apache Axis2 version: 1.4.1 Built on : Aug 13, 2008 (05:03:35 LKT)
+ */
+
+ package com.frentix.olat.vitero.manager.stubs;
+
+ /**
+ * CustomerServiceCallbackHandler Callback class, Users can extend this class and implement
+ * their own receiveResult and receiveError methods.
+ */
+ public abstract class CustomerServiceCallbackHandler{
+
+
+
+ protected Object clientData;
+
+ /**
+ * User can pass in any object that needs to be accessed once the NonBlocking
+ * Web service call is finished and appropriate method of this CallBack is called.
+ * @param clientData Object mechanism by which the user can pass in user data
+ * that will be avilable at the time this callback is called.
+ */
+ public CustomerServiceCallbackHandler(Object clientData){
+ this.clientData = clientData;
+ }
+
+ /**
+ * Please use this constructor if you don't want to set any clientData
+ */
+ public CustomerServiceCallbackHandler(){
+ this.clientData = null;
+ }
+
+ /**
+ * Get the client data
+ */
+
+ public Object getClientData() {
+ return clientData;
+ }
+
+
+ /**
+ * auto generated Axis2 call back method for getCustomerByName method
+ * override this method for handling normal response from getCustomerByName operation
+ */
+ public void receiveResultgetCustomerByName(
+ com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.GetCustomerByNameResponse result
+ ) {
+ }
+
+ /**
+ * auto generated Axis2 Error handler
+ * override this method for handling error response from getCustomerByName operation
+ */
+ public void receiveErrorgetCustomerByName(java.lang.Exception e) {
+ }
+
+ /**
+ * auto generated Axis2 call back method for getCustomerList method
+ * override this method for handling normal response from getCustomerList operation
+ */
+ public void receiveResultgetCustomerList(
+ com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.GetCustomerListResponse result
+ ) {
+ }
+
+ /**
+ * auto generated Axis2 Error handler
+ * override this method for handling error response from getCustomerList operation
+ */
+ public void receiveErrorgetCustomerList(java.lang.Exception e) {
+ }
+
+ // No methods generated for meps other than in-out
+
+ // No methods generated for meps other than in-out
+
+ // No methods generated for meps other than in-out
+
+ // No methods generated for meps other than in-out
+
+ /**
+ * auto generated Axis2 call back method for createCustomer method
+ * override this method for handling normal response from createCustomer operation
+ */
+ public void receiveResultcreateCustomer(
+ com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.CreateCustomerResponse result
+ ) {
+ }
+
+ /**
+ * auto generated Axis2 Error handler
+ * override this method for handling error response from createCustomer operation
+ */
+ public void receiveErrorcreateCustomer(java.lang.Exception e) {
+ }
+
+ // No methods generated for meps other than in-out
+
+ // No methods generated for meps other than in-out
+
+ /**
+ * auto generated Axis2 call back method for getCustomer method
+ * override this method for handling normal response from getCustomer operation
+ */
+ public void receiveResultgetCustomer(
+ com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.GetCustomerResponse result
+ ) {
+ }
+
+ /**
+ * auto generated Axis2 Error handler
+ * override this method for handling error response from getCustomer operation
+ */
+ public void receiveErrorgetCustomer(java.lang.Exception e) {
+ }
+
+ // No methods generated for meps other than in-out
+
+
+
+ }
+
\ No newline at end of file
diff --git a/src/main/java/com/frentix/olat/vitero/manager/stubs/CustomerServiceStub.java b/src/main/java/com/frentix/olat/vitero/manager/stubs/CustomerServiceStub.java
new file mode 100644
index 0000000000000000000000000000000000000000..d5f43960532dceac12bc51ac7459d31cdea60d5e
--- /dev/null
+++ b/src/main/java/com/frentix/olat/vitero/manager/stubs/CustomerServiceStub.java
@@ -0,0 +1,13070 @@
+
+/**
+ * CustomerServiceStub.java
+ *
+ * This file was auto-generated from WSDL
+ * by the Apache Axis2 version: 1.4.1 Built on : Aug 13, 2008 (05:03:35 LKT)
+ */
+ package com.frentix.olat.vitero.manager.stubs;
+
+
+
+ /*
+ * CustomerServiceStub java implementation
+ */
+
+
+ public class CustomerServiceStub extends org.apache.axis2.client.Stub
+ {
+ protected org.apache.axis2.description.AxisOperation[] _operations;
+
+ //hashmaps to keep the fault mapping
+ private java.util.HashMap faultExceptionNameMap = new java.util.HashMap();
+ private java.util.HashMap faultExceptionClassNameMap = new java.util.HashMap();
+ private java.util.HashMap faultMessageMap = new java.util.HashMap();
+
+ private static int counter = 0;
+
+ private static synchronized String getUniqueSuffix(){
+ // reset the counter if it is greater than 99999
+ if (counter > 99999){
+ counter = 0;
+ }
+ counter = counter + 1;
+ return Long.toString(System.currentTimeMillis()) + "_" + counter;
+ }
+
+
+ private void populateAxisService() throws org.apache.axis2.AxisFault {
+
+ //creating the Service with a unique name
+ _service = new org.apache.axis2.description.AxisService("CustomerService" + getUniqueSuffix());
+ addAnonymousOperations();
+
+ //creating the operations
+ org.apache.axis2.description.AxisOperation __operation;
+
+ _operations = new org.apache.axis2.description.AxisOperation[11];
+
+ __operation = new org.apache.axis2.description.OutInAxisOperation();
+
+
+ __operation.setName(new javax.xml.namespace.QName("http://www.vitero.de/schema/customer", "getCustomerByName"));
+ _service.addOperation(__operation);
+
+
+
+
+ _operations[0]=__operation;
+
+
+ __operation = new org.apache.axis2.description.OutInAxisOperation();
+
+
+ __operation.setName(new javax.xml.namespace.QName("http://www.vitero.de/schema/customer", "getCustomerList"));
+ _service.addOperation(__operation);
+
+
+
+
+ _operations[1]=__operation;
+
+
+ __operation = new org.apache.axis2.description.OutInAxisOperation();
+
+
+ __operation.setName(new javax.xml.namespace.QName("http://www.vitero.de/schema/customer", "success"));
+ _service.addOperation(__operation);
+
+
+
+
+ _operations[2]=__operation;
+
+
+ __operation = new org.apache.axis2.description.OutOnlyAxisOperation();
+
+
+ __operation.setName(new javax.xml.namespace.QName("http://www.vitero.de/schema/customer", "moveAllUsersToCustomer"));
+ _service.addOperation(__operation);
+
+
+
+
+ _operations[3]=__operation;
+
+
+ __operation = new org.apache.axis2.description.OutOnlyAxisOperation();
+
+
+ __operation.setName(new javax.xml.namespace.QName("http://www.vitero.de/schema/customer", "addUserToCustomer"));
+ _service.addOperation(__operation);
+
+
+
+
+ _operations[4]=__operation;
+
+
+ __operation = new org.apache.axis2.description.OutOnlyAxisOperation();
+
+
+ __operation.setName(new javax.xml.namespace.QName("http://www.vitero.de/schema/customer", "deleteCustomer"));
+ _service.addOperation(__operation);
+
+
+
+
+ _operations[5]=__operation;
+
+
+ __operation = new org.apache.axis2.description.OutInAxisOperation();
+
+
+ __operation.setName(new javax.xml.namespace.QName("http://www.vitero.de/schema/customer", "createCustomer"));
+ _service.addOperation(__operation);
+
+
+
+
+ _operations[6]=__operation;
+
+
+ __operation = new org.apache.axis2.description.OutOnlyAxisOperation();
+
+
+ __operation.setName(new javax.xml.namespace.QName("http://www.vitero.de/schema/customer", "moveUserToCustomer"));
+ _service.addOperation(__operation);
+
+
+
+
+ _operations[7]=__operation;
+
+
+ __operation = new org.apache.axis2.description.OutOnlyAxisOperation();
+
+
+ __operation.setName(new javax.xml.namespace.QName("http://www.vitero.de/schema/customer", "updateCustomer"));
+ _service.addOperation(__operation);
+
+
+
+
+ _operations[8]=__operation;
+
+
+ __operation = new org.apache.axis2.description.OutInAxisOperation();
+
+
+ __operation.setName(new javax.xml.namespace.QName("http://www.vitero.de/schema/customer", "getCustomer"));
+ _service.addOperation(__operation);
+
+
+
+
+ _operations[9]=__operation;
+
+
+ __operation = new org.apache.axis2.description.OutOnlyAxisOperation();
+
+
+ __operation.setName(new javax.xml.namespace.QName("http://www.vitero.de/schema/customer", "removeUserFromCustomer"));
+ _service.addOperation(__operation);
+
+
+
+
+ _operations[10]=__operation;
+
+
+ }
+
+ //populates the faults
+ private void populateFaults(){
+
+
+
+ }
+
+ /**
+ *Constructor that takes in a configContext
+ */
+
+ public CustomerServiceStub(org.apache.axis2.context.ConfigurationContext configurationContext,
+ java.lang.String targetEndpoint)
+ throws org.apache.axis2.AxisFault {
+ this(configurationContext,targetEndpoint,false);
+ }
+
+
+ /**
+ * Constructor that takes in a configContext and useseperate listner
+ */
+ public CustomerServiceStub(org.apache.axis2.context.ConfigurationContext configurationContext,
+ java.lang.String targetEndpoint, boolean useSeparateListener)
+ throws org.apache.axis2.AxisFault {
+ //To populate AxisService
+ populateAxisService();
+ populateFaults();
+
+ _serviceClient = new org.apache.axis2.client.ServiceClient(configurationContext,_service);
+
+
+ configurationContext = _serviceClient.getServiceContext().getConfigurationContext();
+
+ _serviceClient.getOptions().setTo(new org.apache.axis2.addressing.EndpointReference(
+ targetEndpoint));
+ _serviceClient.getOptions().setUseSeparateListener(useSeparateListener);
+
+
+ }
+
+ /**
+ * Default Constructor
+ */
+ public CustomerServiceStub(org.apache.axis2.context.ConfigurationContext configurationContext) throws org.apache.axis2.AxisFault {
+
+ this(configurationContext,"http://192.168.1.54:8080/vitero/services/" );
+
+ }
+
+ /**
+ * Default Constructor
+ */
+ public CustomerServiceStub() throws org.apache.axis2.AxisFault {
+
+ this("http://192.168.1.54:8080/vitero/services/" );
+
+ }
+
+ /**
+ * Constructor taking the target endpoint
+ */
+ public CustomerServiceStub(java.lang.String targetEndpoint) throws org.apache.axis2.AxisFault {
+ this(null,targetEndpoint);
+ }
+
+
+
+
+ /**
+ * Auto generated method signature
+ *
+ * @see com.frentix.olat.vc.provider.vitero.stubs.CustomerService#getCustomerByName
+ * @param getCustomerByNameRequest0
+
+ */
+
+
+
+ public com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.GetCustomerByNameResponse getCustomerByName(
+
+ com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.GetCustomerByNameRequest getCustomerByNameRequest0)
+
+
+ throws java.rmi.RemoteException
+
+ {
+ org.apache.axis2.context.MessageContext _messageContext = null;
+ try{
+ org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[0].getName());
+ _operationClient.getOptions().setAction("\"\"");
+ _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true);
+
+
+
+ addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&");
+
+
+ // create a message context
+ _messageContext = new org.apache.axis2.context.MessageContext();
+
+
+
+ // create SOAP envelope with that payload
+ org.apache.axiom.soap.SOAPEnvelope env = null;
+
+
+ env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()),
+ getCustomerByNameRequest0,
+ optimizeContent(new javax.xml.namespace.QName("http://www.vitero.de/schema/customer",
+ "getCustomerByName")));
+
+ //adding SOAP soap_headers
+ _serviceClient.addHeadersToEnvelope(env);
+ // set the message context with that soap envelope
+ _messageContext.setEnvelope(env);
+
+ // add the message contxt to the operation client
+ _operationClient.addMessageContext(_messageContext);
+
+ //execute the operation client
+ _operationClient.execute(true);
+
+
+ org.apache.axis2.context.MessageContext _returnMessageContext = _operationClient.getMessageContext(
+ org.apache.axis2.wsdl.WSDLConstants.MESSAGE_LABEL_IN_VALUE);
+ org.apache.axiom.soap.SOAPEnvelope _returnEnv = _returnMessageContext.getEnvelope();
+
+
+ java.lang.Object object = fromOM(
+ _returnEnv.getBody().getFirstElement() ,
+ com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.GetCustomerByNameResponse.class,
+ getEnvelopeNamespaces(_returnEnv));
+
+
+ return (com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.GetCustomerByNameResponse)object;
+
+ }catch(org.apache.axis2.AxisFault f){
+
+ org.apache.axiom.om.OMElement faultElt = f.getDetail();
+ if (faultElt!=null){
+ if (faultExceptionNameMap.containsKey(faultElt.getQName())){
+ //make the fault by reflection
+ try{
+ java.lang.String exceptionClassName = (java.lang.String)faultExceptionClassNameMap.get(faultElt.getQName());
+ java.lang.Class exceptionClass = java.lang.Class.forName(exceptionClassName);
+ java.lang.Exception ex=
+ (java.lang.Exception) exceptionClass.newInstance();
+ //message class
+ java.lang.String messageClassName = (java.lang.String)faultMessageMap.get(faultElt.getQName());
+ java.lang.Class messageClass = java.lang.Class.forName(messageClassName);
+ java.lang.Object messageObject = fromOM(faultElt,messageClass,null);
+ java.lang.reflect.Method m = exceptionClass.getMethod("setFaultMessage",
+ new java.lang.Class[]{messageClass});
+ m.invoke(ex,new java.lang.Object[]{messageObject});
+
+
+ throw new java.rmi.RemoteException(ex.getMessage(), ex);
+ }catch(java.lang.ClassCastException e){
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.ClassNotFoundException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ }catch (java.lang.NoSuchMethodException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.reflect.InvocationTargetException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.IllegalAccessException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.InstantiationException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ }
+ }else{
+ throw f;
+ }
+ }else{
+ throw f;
+ }
+ } finally {
+ _messageContext.getTransportOut().getSender().cleanup(_messageContext);
+ }
+ }
+
+ /**
+ * Auto generated method signature for Asynchronous Invocations
+ *
+ * @see com.frentix.olat.vc.provider.vitero.stubs.CustomerService#startgetCustomerByName
+ * @param getCustomerByNameRequest0
+
+ */
+ public void startgetCustomerByName(
+
+ com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.GetCustomerByNameRequest getCustomerByNameRequest0,
+
+ final com.frentix.olat.vitero.manager.stubs.CustomerServiceCallbackHandler callback)
+
+ throws java.rmi.RemoteException{
+
+ org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[0].getName());
+ _operationClient.getOptions().setAction("\"\"");
+ _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true);
+
+
+
+ addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&");
+
+
+
+ // create SOAP envelope with that payload
+ org.apache.axiom.soap.SOAPEnvelope env=null;
+ final org.apache.axis2.context.MessageContext _messageContext = new org.apache.axis2.context.MessageContext();
+
+
+ //Style is Doc.
+
+
+ env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()),
+ getCustomerByNameRequest0,
+ optimizeContent(new javax.xml.namespace.QName("http://www.vitero.de/schema/customer",
+ "getCustomerByName")));
+
+ // adding SOAP soap_headers
+ _serviceClient.addHeadersToEnvelope(env);
+ // create message context with that soap envelope
+ _messageContext.setEnvelope(env);
+
+ // add the message context to the operation client
+ _operationClient.addMessageContext(_messageContext);
+
+
+
+ _operationClient.setCallback(new org.apache.axis2.client.async.AxisCallback() {
+ public void onMessage(org.apache.axis2.context.MessageContext resultContext) {
+ try {
+ org.apache.axiom.soap.SOAPEnvelope resultEnv = resultContext.getEnvelope();
+
+ java.lang.Object object = fromOM(resultEnv.getBody().getFirstElement(),
+ com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.GetCustomerByNameResponse.class,
+ getEnvelopeNamespaces(resultEnv));
+ callback.receiveResultgetCustomerByName(
+ (com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.GetCustomerByNameResponse)object);
+
+ } catch (org.apache.axis2.AxisFault e) {
+ callback.receiveErrorgetCustomerByName(e);
+ }
+ }
+
+ public void onError(java.lang.Exception error) {
+ if (error instanceof org.apache.axis2.AxisFault) {
+ org.apache.axis2.AxisFault f = (org.apache.axis2.AxisFault) error;
+ org.apache.axiom.om.OMElement faultElt = f.getDetail();
+ if (faultElt!=null){
+ if (faultExceptionNameMap.containsKey(faultElt.getQName())){
+ //make the fault by reflection
+ try{
+ java.lang.String exceptionClassName = (java.lang.String)faultExceptionClassNameMap.get(faultElt.getQName());
+ java.lang.Class exceptionClass = java.lang.Class.forName(exceptionClassName);
+ java.lang.Exception ex=
+ (java.lang.Exception) exceptionClass.newInstance();
+ //message class
+ java.lang.String messageClassName = (java.lang.String)faultMessageMap.get(faultElt.getQName());
+ java.lang.Class messageClass = java.lang.Class.forName(messageClassName);
+ java.lang.Object messageObject = fromOM(faultElt,messageClass,null);
+ java.lang.reflect.Method m = exceptionClass.getMethod("setFaultMessage",
+ new java.lang.Class[]{messageClass});
+ m.invoke(ex,new java.lang.Object[]{messageObject});
+
+
+ callback.receiveErrorgetCustomerByName(new java.rmi.RemoteException(ex.getMessage(), ex));
+ } catch(java.lang.ClassCastException e){
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetCustomerByName(f);
+ } catch (java.lang.ClassNotFoundException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetCustomerByName(f);
+ } catch (java.lang.NoSuchMethodException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetCustomerByName(f);
+ } catch (java.lang.reflect.InvocationTargetException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetCustomerByName(f);
+ } catch (java.lang.IllegalAccessException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetCustomerByName(f);
+ } catch (java.lang.InstantiationException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetCustomerByName(f);
+ } catch (org.apache.axis2.AxisFault e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetCustomerByName(f);
+ }
+ } else {
+ callback.receiveErrorgetCustomerByName(f);
+ }
+ } else {
+ callback.receiveErrorgetCustomerByName(f);
+ }
+ } else {
+ callback.receiveErrorgetCustomerByName(error);
+ }
+ }
+
+ public void onFault(org.apache.axis2.context.MessageContext faultContext) {
+ org.apache.axis2.AxisFault fault = org.apache.axis2.util.Utils.getInboundFaultFromMessageContext(faultContext);
+ onError(fault);
+ }
+
+ public void onComplete() {
+ try {
+ _messageContext.getTransportOut().getSender().cleanup(_messageContext);
+ } catch (org.apache.axis2.AxisFault axisFault) {
+ callback.receiveErrorgetCustomerByName(axisFault);
+ }
+ }
+ });
+
+
+ org.apache.axis2.util.CallbackReceiver _callbackReceiver = null;
+ if ( _operations[0].getMessageReceiver()==null && _operationClient.getOptions().isUseSeparateListener()) {
+ _callbackReceiver = new org.apache.axis2.util.CallbackReceiver();
+ _operations[0].setMessageReceiver(
+ _callbackReceiver);
+ }
+
+ //execute the operation client
+ _operationClient.execute(false);
+
+ }
+
+ /**
+ * Auto generated method signature
+ *
+ * @see com.frentix.olat.vc.provider.vitero.stubs.CustomerService#getCustomerList
+ * @param getCustomerListRequest2
+
+ */
+
+
+
+ public com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.GetCustomerListResponse getCustomerList(
+
+ com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.GetCustomerListRequest getCustomerListRequest2)
+
+
+ throws java.rmi.RemoteException
+
+ {
+ org.apache.axis2.context.MessageContext _messageContext = null;
+ try{
+ org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[1].getName());
+ _operationClient.getOptions().setAction("\"\"");
+ _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true);
+
+
+
+ addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&");
+
+
+ // create a message context
+ _messageContext = new org.apache.axis2.context.MessageContext();
+
+
+
+ // create SOAP envelope with that payload
+ org.apache.axiom.soap.SOAPEnvelope env = null;
+
+
+ env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()),
+ getCustomerListRequest2,
+ optimizeContent(new javax.xml.namespace.QName("http://www.vitero.de/schema/customer",
+ "getCustomerList")));
+
+ //adding SOAP soap_headers
+ _serviceClient.addHeadersToEnvelope(env);
+ // set the message context with that soap envelope
+ _messageContext.setEnvelope(env);
+
+ // add the message contxt to the operation client
+ _operationClient.addMessageContext(_messageContext);
+
+ //execute the operation client
+ _operationClient.execute(true);
+
+
+ org.apache.axis2.context.MessageContext _returnMessageContext = _operationClient.getMessageContext(
+ org.apache.axis2.wsdl.WSDLConstants.MESSAGE_LABEL_IN_VALUE);
+ org.apache.axiom.soap.SOAPEnvelope _returnEnv = _returnMessageContext.getEnvelope();
+
+
+ java.lang.Object object = fromOM(
+ _returnEnv.getBody().getFirstElement() ,
+ com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.GetCustomerListResponse.class,
+ getEnvelopeNamespaces(_returnEnv));
+
+
+ return (com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.GetCustomerListResponse)object;
+
+ }catch(org.apache.axis2.AxisFault f){
+
+ org.apache.axiom.om.OMElement faultElt = f.getDetail();
+ if (faultElt!=null){
+ if (faultExceptionNameMap.containsKey(faultElt.getQName())){
+ //make the fault by reflection
+ try{
+ java.lang.String exceptionClassName = (java.lang.String)faultExceptionClassNameMap.get(faultElt.getQName());
+ java.lang.Class exceptionClass = java.lang.Class.forName(exceptionClassName);
+ java.lang.Exception ex=
+ (java.lang.Exception) exceptionClass.newInstance();
+ //message class
+ java.lang.String messageClassName = (java.lang.String)faultMessageMap.get(faultElt.getQName());
+ java.lang.Class messageClass = java.lang.Class.forName(messageClassName);
+ java.lang.Object messageObject = fromOM(faultElt,messageClass,null);
+ java.lang.reflect.Method m = exceptionClass.getMethod("setFaultMessage",
+ new java.lang.Class[]{messageClass});
+ m.invoke(ex,new java.lang.Object[]{messageObject});
+
+
+ throw new java.rmi.RemoteException(ex.getMessage(), ex);
+ }catch(java.lang.ClassCastException e){
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.ClassNotFoundException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ }catch (java.lang.NoSuchMethodException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.reflect.InvocationTargetException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.IllegalAccessException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.InstantiationException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ }
+ }else{
+ throw f;
+ }
+ }else{
+ throw f;
+ }
+ } finally {
+ _messageContext.getTransportOut().getSender().cleanup(_messageContext);
+ }
+ }
+
+ /**
+ * Auto generated method signature for Asynchronous Invocations
+ *
+ * @see com.frentix.olat.vc.provider.vitero.stubs.CustomerService#startgetCustomerList
+ * @param getCustomerListRequest2
+
+ */
+ public void startgetCustomerList(
+
+ com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.GetCustomerListRequest getCustomerListRequest2,
+
+ final com.frentix.olat.vitero.manager.stubs.CustomerServiceCallbackHandler callback)
+
+ throws java.rmi.RemoteException{
+
+ org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[1].getName());
+ _operationClient.getOptions().setAction("\"\"");
+ _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true);
+
+
+
+ addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&");
+
+
+
+ // create SOAP envelope with that payload
+ org.apache.axiom.soap.SOAPEnvelope env=null;
+ final org.apache.axis2.context.MessageContext _messageContext = new org.apache.axis2.context.MessageContext();
+
+
+ //Style is Doc.
+
+
+ env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()),
+ getCustomerListRequest2,
+ optimizeContent(new javax.xml.namespace.QName("http://www.vitero.de/schema/customer",
+ "getCustomerList")));
+
+ // adding SOAP soap_headers
+ _serviceClient.addHeadersToEnvelope(env);
+ // create message context with that soap envelope
+ _messageContext.setEnvelope(env);
+
+ // add the message context to the operation client
+ _operationClient.addMessageContext(_messageContext);
+
+
+
+ _operationClient.setCallback(new org.apache.axis2.client.async.AxisCallback() {
+ public void onMessage(org.apache.axis2.context.MessageContext resultContext) {
+ try {
+ org.apache.axiom.soap.SOAPEnvelope resultEnv = resultContext.getEnvelope();
+
+ java.lang.Object object = fromOM(resultEnv.getBody().getFirstElement(),
+ com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.GetCustomerListResponse.class,
+ getEnvelopeNamespaces(resultEnv));
+ callback.receiveResultgetCustomerList(
+ (com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.GetCustomerListResponse)object);
+
+ } catch (org.apache.axis2.AxisFault e) {
+ callback.receiveErrorgetCustomerList(e);
+ }
+ }
+
+ public void onError(java.lang.Exception error) {
+ if (error instanceof org.apache.axis2.AxisFault) {
+ org.apache.axis2.AxisFault f = (org.apache.axis2.AxisFault) error;
+ org.apache.axiom.om.OMElement faultElt = f.getDetail();
+ if (faultElt!=null){
+ if (faultExceptionNameMap.containsKey(faultElt.getQName())){
+ //make the fault by reflection
+ try{
+ java.lang.String exceptionClassName = (java.lang.String)faultExceptionClassNameMap.get(faultElt.getQName());
+ java.lang.Class exceptionClass = java.lang.Class.forName(exceptionClassName);
+ java.lang.Exception ex=
+ (java.lang.Exception) exceptionClass.newInstance();
+ //message class
+ java.lang.String messageClassName = (java.lang.String)faultMessageMap.get(faultElt.getQName());
+ java.lang.Class messageClass = java.lang.Class.forName(messageClassName);
+ java.lang.Object messageObject = fromOM(faultElt,messageClass,null);
+ java.lang.reflect.Method m = exceptionClass.getMethod("setFaultMessage",
+ new java.lang.Class[]{messageClass});
+ m.invoke(ex,new java.lang.Object[]{messageObject});
+
+
+ callback.receiveErrorgetCustomerList(new java.rmi.RemoteException(ex.getMessage(), ex));
+ } catch(java.lang.ClassCastException e){
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetCustomerList(f);
+ } catch (java.lang.ClassNotFoundException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetCustomerList(f);
+ } catch (java.lang.NoSuchMethodException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetCustomerList(f);
+ } catch (java.lang.reflect.InvocationTargetException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetCustomerList(f);
+ } catch (java.lang.IllegalAccessException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetCustomerList(f);
+ } catch (java.lang.InstantiationException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetCustomerList(f);
+ } catch (org.apache.axis2.AxisFault e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetCustomerList(f);
+ }
+ } else {
+ callback.receiveErrorgetCustomerList(f);
+ }
+ } else {
+ callback.receiveErrorgetCustomerList(f);
+ }
+ } else {
+ callback.receiveErrorgetCustomerList(error);
+ }
+ }
+
+ public void onFault(org.apache.axis2.context.MessageContext faultContext) {
+ org.apache.axis2.AxisFault fault = org.apache.axis2.util.Utils.getInboundFaultFromMessageContext(faultContext);
+ onError(fault);
+ }
+
+ public void onComplete() {
+ try {
+ _messageContext.getTransportOut().getSender().cleanup(_messageContext);
+ } catch (org.apache.axis2.AxisFault axisFault) {
+ callback.receiveErrorgetCustomerList(axisFault);
+ }
+ }
+ });
+
+
+ org.apache.axis2.util.CallbackReceiver _callbackReceiver = null;
+ if ( _operations[1].getMessageReceiver()==null && _operationClient.getOptions().isUseSeparateListener()) {
+ _callbackReceiver = new org.apache.axis2.util.CallbackReceiver();
+ _operations[1].setMessageReceiver(
+ _callbackReceiver);
+ }
+
+ //execute the operation client
+ _operationClient.execute(false);
+
+ }
+
+
+ /**
+ * Auto generated method signature
+ *
+ */
+ public void moveAllUsersToCustomer(
+ com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.MoveAllUsersToCustomerRequest moveAllUsersToCustomerRequest5
+
+ ) throws java.rmi.RemoteException
+
+
+ {
+ org.apache.axis2.context.MessageContext _messageContext = null;
+
+
+ org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[3].getName());
+ _operationClient.getOptions().setAction("\"\"");
+ _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true);
+
+
+
+ addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&");
+
+ org.apache.axiom.soap.SOAPEnvelope env = null;
+ _messageContext = new org.apache.axis2.context.MessageContext();
+
+
+ //Style is Doc.
+
+
+ env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()),
+ moveAllUsersToCustomerRequest5,
+ optimizeContent(new javax.xml.namespace.QName("http://www.vitero.de/schema/customer",
+ "moveAllUsersToCustomer")));
+
+
+ //adding SOAP soap_headers
+ _serviceClient.addHeadersToEnvelope(env);
+ // create message context with that soap envelope
+
+ _messageContext.setEnvelope(env);
+
+ // add the message contxt to the operation client
+ _operationClient.addMessageContext(_messageContext);
+
+ _operationClient.execute(true);
+
+
+ _messageContext.getTransportOut().getSender().cleanup(_messageContext);
+
+ return;
+ }
+
+
+ /**
+ * Auto generated method signature
+ *
+ */
+ public void addUserToCustomer(
+ com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.AddUserToCustomerRequest addUserToCustomerRequest6
+
+ ) throws java.rmi.RemoteException
+
+
+ {
+ org.apache.axis2.context.MessageContext _messageContext = null;
+
+
+ org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[4].getName());
+ _operationClient.getOptions().setAction("\"\"");
+ _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true);
+
+
+
+ addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&");
+
+ org.apache.axiom.soap.SOAPEnvelope env = null;
+ _messageContext = new org.apache.axis2.context.MessageContext();
+
+
+ //Style is Doc.
+
+
+ env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()),
+ addUserToCustomerRequest6,
+ optimizeContent(new javax.xml.namespace.QName("http://www.vitero.de/schema/customer",
+ "addUserToCustomer")));
+
+
+ //adding SOAP soap_headers
+ _serviceClient.addHeadersToEnvelope(env);
+ // create message context with that soap envelope
+
+ _messageContext.setEnvelope(env);
+
+ // add the message contxt to the operation client
+ _operationClient.addMessageContext(_messageContext);
+
+ _operationClient.execute(true);
+
+
+ _messageContext.getTransportOut().getSender().cleanup(_messageContext);
+
+ return;
+ }
+
+
+ /**
+ * Auto generated method signature
+ *
+ */
+ public void deleteCustomer(
+ com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.DeleteCustomerRequest deleteCustomerRequest7
+
+ ) throws java.rmi.RemoteException
+
+
+ {
+ org.apache.axis2.context.MessageContext _messageContext = null;
+
+
+ org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[5].getName());
+ _operationClient.getOptions().setAction("\"\"");
+ _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true);
+
+
+
+ addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&");
+
+ org.apache.axiom.soap.SOAPEnvelope env = null;
+ _messageContext = new org.apache.axis2.context.MessageContext();
+
+
+ //Style is Doc.
+
+
+ env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()),
+ deleteCustomerRequest7,
+ optimizeContent(new javax.xml.namespace.QName("http://www.vitero.de/schema/customer",
+ "deleteCustomer")));
+
+
+ //adding SOAP soap_headers
+ _serviceClient.addHeadersToEnvelope(env);
+ // create message context with that soap envelope
+
+ _messageContext.setEnvelope(env);
+
+ // add the message contxt to the operation client
+ _operationClient.addMessageContext(_messageContext);
+
+ _operationClient.execute(true);
+
+
+ _messageContext.getTransportOut().getSender().cleanup(_messageContext);
+
+ return;
+ }
+
+ /**
+ * Auto generated method signature
+ *
+ * @see com.frentix.olat.vc.provider.vitero.stubs.CustomerService#createCustomer
+ * @param createCustomerRequest8
+
+ */
+
+
+
+ public com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.CreateCustomerResponse createCustomer(
+
+ com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.CreateCustomerRequest createCustomerRequest8)
+
+
+ throws java.rmi.RemoteException
+
+ {
+ org.apache.axis2.context.MessageContext _messageContext = null;
+ try{
+ org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[6].getName());
+ _operationClient.getOptions().setAction("\"\"");
+ _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true);
+
+
+
+ addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&");
+
+
+ // create a message context
+ _messageContext = new org.apache.axis2.context.MessageContext();
+
+
+
+ // create SOAP envelope with that payload
+ org.apache.axiom.soap.SOAPEnvelope env = null;
+
+
+ env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()),
+ createCustomerRequest8,
+ optimizeContent(new javax.xml.namespace.QName("http://www.vitero.de/schema/customer",
+ "createCustomer")));
+
+ //adding SOAP soap_headers
+ _serviceClient.addHeadersToEnvelope(env);
+ // set the message context with that soap envelope
+ _messageContext.setEnvelope(env);
+
+ // add the message contxt to the operation client
+ _operationClient.addMessageContext(_messageContext);
+
+ //execute the operation client
+ _operationClient.execute(true);
+
+
+ org.apache.axis2.context.MessageContext _returnMessageContext = _operationClient.getMessageContext(
+ org.apache.axis2.wsdl.WSDLConstants.MESSAGE_LABEL_IN_VALUE);
+ org.apache.axiom.soap.SOAPEnvelope _returnEnv = _returnMessageContext.getEnvelope();
+
+
+ java.lang.Object object = fromOM(
+ _returnEnv.getBody().getFirstElement() ,
+ com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.CreateCustomerResponse.class,
+ getEnvelopeNamespaces(_returnEnv));
+
+
+ return (com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.CreateCustomerResponse)object;
+
+ }catch(org.apache.axis2.AxisFault f){
+
+ org.apache.axiom.om.OMElement faultElt = f.getDetail();
+ if (faultElt!=null){
+ if (faultExceptionNameMap.containsKey(faultElt.getQName())){
+ //make the fault by reflection
+ try{
+ java.lang.String exceptionClassName = (java.lang.String)faultExceptionClassNameMap.get(faultElt.getQName());
+ java.lang.Class exceptionClass = java.lang.Class.forName(exceptionClassName);
+ java.lang.Exception ex=
+ (java.lang.Exception) exceptionClass.newInstance();
+ //message class
+ java.lang.String messageClassName = (java.lang.String)faultMessageMap.get(faultElt.getQName());
+ java.lang.Class messageClass = java.lang.Class.forName(messageClassName);
+ java.lang.Object messageObject = fromOM(faultElt,messageClass,null);
+ java.lang.reflect.Method m = exceptionClass.getMethod("setFaultMessage",
+ new java.lang.Class[]{messageClass});
+ m.invoke(ex,new java.lang.Object[]{messageObject});
+
+
+ throw new java.rmi.RemoteException(ex.getMessage(), ex);
+ }catch(java.lang.ClassCastException e){
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.ClassNotFoundException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ }catch (java.lang.NoSuchMethodException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.reflect.InvocationTargetException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.IllegalAccessException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.InstantiationException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ }
+ }else{
+ throw f;
+ }
+ }else{
+ throw f;
+ }
+ } finally {
+ _messageContext.getTransportOut().getSender().cleanup(_messageContext);
+ }
+ }
+
+ /**
+ * Auto generated method signature for Asynchronous Invocations
+ *
+ * @see com.frentix.olat.vc.provider.vitero.stubs.CustomerService#startcreateCustomer
+ * @param createCustomerRequest8
+
+ */
+ public void startcreateCustomer(
+
+ com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.CreateCustomerRequest createCustomerRequest8,
+
+ final com.frentix.olat.vitero.manager.stubs.CustomerServiceCallbackHandler callback)
+
+ throws java.rmi.RemoteException{
+
+ org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[6].getName());
+ _operationClient.getOptions().setAction("\"\"");
+ _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true);
+
+
+
+ addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&");
+
+
+
+ // create SOAP envelope with that payload
+ org.apache.axiom.soap.SOAPEnvelope env=null;
+ final org.apache.axis2.context.MessageContext _messageContext = new org.apache.axis2.context.MessageContext();
+
+
+ //Style is Doc.
+
+
+ env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()),
+ createCustomerRequest8,
+ optimizeContent(new javax.xml.namespace.QName("http://www.vitero.de/schema/customer",
+ "createCustomer")));
+
+ // adding SOAP soap_headers
+ _serviceClient.addHeadersToEnvelope(env);
+ // create message context with that soap envelope
+ _messageContext.setEnvelope(env);
+
+ // add the message context to the operation client
+ _operationClient.addMessageContext(_messageContext);
+
+
+
+ _operationClient.setCallback(new org.apache.axis2.client.async.AxisCallback() {
+ public void onMessage(org.apache.axis2.context.MessageContext resultContext) {
+ try {
+ org.apache.axiom.soap.SOAPEnvelope resultEnv = resultContext.getEnvelope();
+
+ java.lang.Object object = fromOM(resultEnv.getBody().getFirstElement(),
+ com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.CreateCustomerResponse.class,
+ getEnvelopeNamespaces(resultEnv));
+ callback.receiveResultcreateCustomer(
+ (com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.CreateCustomerResponse)object);
+
+ } catch (org.apache.axis2.AxisFault e) {
+ callback.receiveErrorcreateCustomer(e);
+ }
+ }
+
+ public void onError(java.lang.Exception error) {
+ if (error instanceof org.apache.axis2.AxisFault) {
+ org.apache.axis2.AxisFault f = (org.apache.axis2.AxisFault) error;
+ org.apache.axiom.om.OMElement faultElt = f.getDetail();
+ if (faultElt!=null){
+ if (faultExceptionNameMap.containsKey(faultElt.getQName())){
+ //make the fault by reflection
+ try{
+ java.lang.String exceptionClassName = (java.lang.String)faultExceptionClassNameMap.get(faultElt.getQName());
+ java.lang.Class exceptionClass = java.lang.Class.forName(exceptionClassName);
+ java.lang.Exception ex=
+ (java.lang.Exception) exceptionClass.newInstance();
+ //message class
+ java.lang.String messageClassName = (java.lang.String)faultMessageMap.get(faultElt.getQName());
+ java.lang.Class messageClass = java.lang.Class.forName(messageClassName);
+ java.lang.Object messageObject = fromOM(faultElt,messageClass,null);
+ java.lang.reflect.Method m = exceptionClass.getMethod("setFaultMessage",
+ new java.lang.Class[]{messageClass});
+ m.invoke(ex,new java.lang.Object[]{messageObject});
+
+
+ callback.receiveErrorcreateCustomer(new java.rmi.RemoteException(ex.getMessage(), ex));
+ } catch(java.lang.ClassCastException e){
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorcreateCustomer(f);
+ } catch (java.lang.ClassNotFoundException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorcreateCustomer(f);
+ } catch (java.lang.NoSuchMethodException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorcreateCustomer(f);
+ } catch (java.lang.reflect.InvocationTargetException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorcreateCustomer(f);
+ } catch (java.lang.IllegalAccessException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorcreateCustomer(f);
+ } catch (java.lang.InstantiationException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorcreateCustomer(f);
+ } catch (org.apache.axis2.AxisFault e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorcreateCustomer(f);
+ }
+ } else {
+ callback.receiveErrorcreateCustomer(f);
+ }
+ } else {
+ callback.receiveErrorcreateCustomer(f);
+ }
+ } else {
+ callback.receiveErrorcreateCustomer(error);
+ }
+ }
+
+ public void onFault(org.apache.axis2.context.MessageContext faultContext) {
+ org.apache.axis2.AxisFault fault = org.apache.axis2.util.Utils.getInboundFaultFromMessageContext(faultContext);
+ onError(fault);
+ }
+
+ public void onComplete() {
+ try {
+ _messageContext.getTransportOut().getSender().cleanup(_messageContext);
+ } catch (org.apache.axis2.AxisFault axisFault) {
+ callback.receiveErrorcreateCustomer(axisFault);
+ }
+ }
+ });
+
+
+ org.apache.axis2.util.CallbackReceiver _callbackReceiver = null;
+ if ( _operations[6].getMessageReceiver()==null && _operationClient.getOptions().isUseSeparateListener()) {
+ _callbackReceiver = new org.apache.axis2.util.CallbackReceiver();
+ _operations[6].setMessageReceiver(
+ _callbackReceiver);
+ }
+
+ //execute the operation client
+ _operationClient.execute(false);
+
+ }
+
+
+ /**
+ * Auto generated method signature
+ *
+ */
+ public void moveUserToCustomer(
+ com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.MoveUserToCustomerRequest moveUserToCustomerRequest10
+
+ ) throws java.rmi.RemoteException
+
+
+ {
+ org.apache.axis2.context.MessageContext _messageContext = null;
+
+
+ org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[7].getName());
+ _operationClient.getOptions().setAction("\"\"");
+ _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true);
+
+
+
+ addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&");
+
+ org.apache.axiom.soap.SOAPEnvelope env = null;
+ _messageContext = new org.apache.axis2.context.MessageContext();
+
+
+ //Style is Doc.
+
+
+ env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()),
+ moveUserToCustomerRequest10,
+ optimizeContent(new javax.xml.namespace.QName("http://www.vitero.de/schema/customer",
+ "moveUserToCustomer")));
+
+
+ //adding SOAP soap_headers
+ _serviceClient.addHeadersToEnvelope(env);
+ // create message context with that soap envelope
+
+ _messageContext.setEnvelope(env);
+
+ // add the message contxt to the operation client
+ _operationClient.addMessageContext(_messageContext);
+
+ _operationClient.execute(true);
+
+
+ _messageContext.getTransportOut().getSender().cleanup(_messageContext);
+
+ return;
+ }
+
+
+ /**
+ * Auto generated method signature
+ *
+ */
+ public void updateCustomer(
+ com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.UpdateCustomerRequest updateCustomerRequest11
+
+ ) throws java.rmi.RemoteException
+
+
+ {
+ org.apache.axis2.context.MessageContext _messageContext = null;
+
+
+ org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[8].getName());
+ _operationClient.getOptions().setAction("\"\"");
+ _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true);
+
+
+
+ addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&");
+
+ org.apache.axiom.soap.SOAPEnvelope env = null;
+ _messageContext = new org.apache.axis2.context.MessageContext();
+
+
+ //Style is Doc.
+
+
+ env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()),
+ updateCustomerRequest11,
+ optimizeContent(new javax.xml.namespace.QName("http://www.vitero.de/schema/customer",
+ "updateCustomer")));
+
+
+ //adding SOAP soap_headers
+ _serviceClient.addHeadersToEnvelope(env);
+ // create message context with that soap envelope
+
+ _messageContext.setEnvelope(env);
+
+ // add the message contxt to the operation client
+ _operationClient.addMessageContext(_messageContext);
+
+ _operationClient.execute(true);
+
+
+ _messageContext.getTransportOut().getSender().cleanup(_messageContext);
+
+ return;
+ }
+
+ /**
+ * Auto generated method signature
+ *
+ * @see com.frentix.olat.vc.provider.vitero.stubs.CustomerService#getCustomer
+ * @param getCustomerRequest12
+
+ */
+
+
+
+ public com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.GetCustomerResponse getCustomer(
+
+ com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.GetCustomerRequest getCustomerRequest12)
+
+
+ throws java.rmi.RemoteException
+
+ {
+ org.apache.axis2.context.MessageContext _messageContext = null;
+ try{
+ org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[9].getName());
+ _operationClient.getOptions().setAction("\"\"");
+ _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true);
+
+
+
+ addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&");
+
+
+ // create a message context
+ _messageContext = new org.apache.axis2.context.MessageContext();
+
+
+
+ // create SOAP envelope with that payload
+ org.apache.axiom.soap.SOAPEnvelope env = null;
+
+
+ env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()),
+ getCustomerRequest12,
+ optimizeContent(new javax.xml.namespace.QName("http://www.vitero.de/schema/customer",
+ "getCustomer")));
+
+ //adding SOAP soap_headers
+ _serviceClient.addHeadersToEnvelope(env);
+ // set the message context with that soap envelope
+ _messageContext.setEnvelope(env);
+
+ // add the message contxt to the operation client
+ _operationClient.addMessageContext(_messageContext);
+
+ //execute the operation client
+ _operationClient.execute(true);
+
+
+ org.apache.axis2.context.MessageContext _returnMessageContext = _operationClient.getMessageContext(
+ org.apache.axis2.wsdl.WSDLConstants.MESSAGE_LABEL_IN_VALUE);
+ org.apache.axiom.soap.SOAPEnvelope _returnEnv = _returnMessageContext.getEnvelope();
+
+
+ java.lang.Object object = fromOM(
+ _returnEnv.getBody().getFirstElement() ,
+ com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.GetCustomerResponse.class,
+ getEnvelopeNamespaces(_returnEnv));
+
+
+ return (com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.GetCustomerResponse)object;
+
+ }catch(org.apache.axis2.AxisFault f){
+
+ org.apache.axiom.om.OMElement faultElt = f.getDetail();
+ if (faultElt!=null){
+ if (faultExceptionNameMap.containsKey(faultElt.getQName())){
+ //make the fault by reflection
+ try{
+ java.lang.String exceptionClassName = (java.lang.String)faultExceptionClassNameMap.get(faultElt.getQName());
+ java.lang.Class exceptionClass = java.lang.Class.forName(exceptionClassName);
+ java.lang.Exception ex=
+ (java.lang.Exception) exceptionClass.newInstance();
+ //message class
+ java.lang.String messageClassName = (java.lang.String)faultMessageMap.get(faultElt.getQName());
+ java.lang.Class messageClass = java.lang.Class.forName(messageClassName);
+ java.lang.Object messageObject = fromOM(faultElt,messageClass,null);
+ java.lang.reflect.Method m = exceptionClass.getMethod("setFaultMessage",
+ new java.lang.Class[]{messageClass});
+ m.invoke(ex,new java.lang.Object[]{messageObject});
+
+
+ throw new java.rmi.RemoteException(ex.getMessage(), ex);
+ }catch(java.lang.ClassCastException e){
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.ClassNotFoundException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ }catch (java.lang.NoSuchMethodException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.reflect.InvocationTargetException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.IllegalAccessException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.InstantiationException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ }
+ }else{
+ throw f;
+ }
+ }else{
+ throw f;
+ }
+ } finally {
+ _messageContext.getTransportOut().getSender().cleanup(_messageContext);
+ }
+ }
+
+ /**
+ * Auto generated method signature for Asynchronous Invocations
+ *
+ * @see com.frentix.olat.vc.provider.vitero.stubs.CustomerService#startgetCustomer
+ * @param getCustomerRequest12
+
+ */
+ public void startgetCustomer(
+
+ com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.GetCustomerRequest getCustomerRequest12,
+
+ final com.frentix.olat.vitero.manager.stubs.CustomerServiceCallbackHandler callback)
+
+ throws java.rmi.RemoteException{
+
+ org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[9].getName());
+ _operationClient.getOptions().setAction("\"\"");
+ _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true);
+
+
+
+ addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&");
+
+
+
+ // create SOAP envelope with that payload
+ org.apache.axiom.soap.SOAPEnvelope env=null;
+ final org.apache.axis2.context.MessageContext _messageContext = new org.apache.axis2.context.MessageContext();
+
+
+ //Style is Doc.
+
+
+ env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()),
+ getCustomerRequest12,
+ optimizeContent(new javax.xml.namespace.QName("http://www.vitero.de/schema/customer",
+ "getCustomer")));
+
+ // adding SOAP soap_headers
+ _serviceClient.addHeadersToEnvelope(env);
+ // create message context with that soap envelope
+ _messageContext.setEnvelope(env);
+
+ // add the message context to the operation client
+ _operationClient.addMessageContext(_messageContext);
+
+
+
+ _operationClient.setCallback(new org.apache.axis2.client.async.AxisCallback() {
+ public void onMessage(org.apache.axis2.context.MessageContext resultContext) {
+ try {
+ org.apache.axiom.soap.SOAPEnvelope resultEnv = resultContext.getEnvelope();
+
+ java.lang.Object object = fromOM(resultEnv.getBody().getFirstElement(),
+ com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.GetCustomerResponse.class,
+ getEnvelopeNamespaces(resultEnv));
+ callback.receiveResultgetCustomer(
+ (com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.GetCustomerResponse)object);
+
+ } catch (org.apache.axis2.AxisFault e) {
+ callback.receiveErrorgetCustomer(e);
+ }
+ }
+
+ public void onError(java.lang.Exception error) {
+ if (error instanceof org.apache.axis2.AxisFault) {
+ org.apache.axis2.AxisFault f = (org.apache.axis2.AxisFault) error;
+ org.apache.axiom.om.OMElement faultElt = f.getDetail();
+ if (faultElt!=null){
+ if (faultExceptionNameMap.containsKey(faultElt.getQName())){
+ //make the fault by reflection
+ try{
+ java.lang.String exceptionClassName = (java.lang.String)faultExceptionClassNameMap.get(faultElt.getQName());
+ java.lang.Class exceptionClass = java.lang.Class.forName(exceptionClassName);
+ java.lang.Exception ex=
+ (java.lang.Exception) exceptionClass.newInstance();
+ //message class
+ java.lang.String messageClassName = (java.lang.String)faultMessageMap.get(faultElt.getQName());
+ java.lang.Class messageClass = java.lang.Class.forName(messageClassName);
+ java.lang.Object messageObject = fromOM(faultElt,messageClass,null);
+ java.lang.reflect.Method m = exceptionClass.getMethod("setFaultMessage",
+ new java.lang.Class[]{messageClass});
+ m.invoke(ex,new java.lang.Object[]{messageObject});
+
+
+ callback.receiveErrorgetCustomer(new java.rmi.RemoteException(ex.getMessage(), ex));
+ } catch(java.lang.ClassCastException e){
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetCustomer(f);
+ } catch (java.lang.ClassNotFoundException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetCustomer(f);
+ } catch (java.lang.NoSuchMethodException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetCustomer(f);
+ } catch (java.lang.reflect.InvocationTargetException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetCustomer(f);
+ } catch (java.lang.IllegalAccessException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetCustomer(f);
+ } catch (java.lang.InstantiationException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetCustomer(f);
+ } catch (org.apache.axis2.AxisFault e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetCustomer(f);
+ }
+ } else {
+ callback.receiveErrorgetCustomer(f);
+ }
+ } else {
+ callback.receiveErrorgetCustomer(f);
+ }
+ } else {
+ callback.receiveErrorgetCustomer(error);
+ }
+ }
+
+ public void onFault(org.apache.axis2.context.MessageContext faultContext) {
+ org.apache.axis2.AxisFault fault = org.apache.axis2.util.Utils.getInboundFaultFromMessageContext(faultContext);
+ onError(fault);
+ }
+
+ public void onComplete() {
+ try {
+ _messageContext.getTransportOut().getSender().cleanup(_messageContext);
+ } catch (org.apache.axis2.AxisFault axisFault) {
+ callback.receiveErrorgetCustomer(axisFault);
+ }
+ }
+ });
+
+
+ org.apache.axis2.util.CallbackReceiver _callbackReceiver = null;
+ if ( _operations[9].getMessageReceiver()==null && _operationClient.getOptions().isUseSeparateListener()) {
+ _callbackReceiver = new org.apache.axis2.util.CallbackReceiver();
+ _operations[9].setMessageReceiver(
+ _callbackReceiver);
+ }
+
+ //execute the operation client
+ _operationClient.execute(false);
+
+ }
+
+
+ /**
+ * Auto generated method signature
+ *
+ */
+ public void removeUserFromCustomer(
+ com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.RemoveUserFromCustomerRequest removeUserFromCustomerRequest14
+
+ ) throws java.rmi.RemoteException
+
+
+ {
+ org.apache.axis2.context.MessageContext _messageContext = null;
+
+
+ org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[10].getName());
+ _operationClient.getOptions().setAction("\"\"");
+ _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true);
+
+
+
+ addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&");
+
+ org.apache.axiom.soap.SOAPEnvelope env = null;
+ _messageContext = new org.apache.axis2.context.MessageContext();
+
+
+ //Style is Doc.
+
+
+ env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()),
+ removeUserFromCustomerRequest14,
+ optimizeContent(new javax.xml.namespace.QName("http://www.vitero.de/schema/customer",
+ "removeUserFromCustomer")));
+
+
+ //adding SOAP soap_headers
+ _serviceClient.addHeadersToEnvelope(env);
+ // create message context with that soap envelope
+
+ _messageContext.setEnvelope(env);
+
+ // add the message contxt to the operation client
+ _operationClient.addMessageContext(_messageContext);
+
+ _operationClient.execute(true);
+
+
+ _messageContext.getTransportOut().getSender().cleanup(_messageContext);
+
+ return;
+ }
+
+
+
+ /**
+ * A utility method that copies the namepaces from the SOAPEnvelope
+ */
+ private java.util.Map getEnvelopeNamespaces(org.apache.axiom.soap.SOAPEnvelope env){
+ java.util.Map returnMap = new java.util.HashMap();
+ java.util.Iterator namespaceIterator = env.getAllDeclaredNamespaces();
+ while (namespaceIterator.hasNext()) {
+ org.apache.axiom.om.OMNamespace ns = (org.apache.axiom.om.OMNamespace) namespaceIterator.next();
+ returnMap.put(ns.getPrefix(),ns.getNamespaceURI());
+ }
+ return returnMap;
+ }
+
+
+
+ private javax.xml.namespace.QName[] opNameArray = null;
+ private boolean optimizeContent(javax.xml.namespace.QName opName) {
+
+
+ if (opNameArray == null) {
+ return false;
+ }
+ for (int i = 0; i < opNameArray.length; i++) {
+ if (opName.equals(opNameArray[i])) {
+ return true;
+ }
+ }
+ return false;
+ }
+ //http://192.168.1.54:8080/vitero/services/
+ public static class Customer
+ implements org.apache.axis2.databinding.ADBBean{
+ /* This type was generated from the piece of schema that had
+ name = customer
+ Namespace URI = http://www.vitero.de/schema/customer
+ Namespace Prefix = ns1
+ */
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/customer")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for Customer
+ */
+
+
+ protected Customertype localCustomer ;
+
+
+ /**
+ * Auto generated getter method
+ * @return Customertype
+ */
+ public Customertype getCustomer(){
+ return localCustomer;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Customer
+ */
+ public void setCustomer(Customertype param){
+
+ this.localCustomer=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,parentQName){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ Customer.this.serialize(parentQName,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ parentQName,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/customer");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":customer",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "customer",
+ xmlWriter);
+ }
+
+
+ }
+
+ if (localCustomer==null){
+ throw new org.apache.axis2.databinding.ADBException("customer cannot be null!!");
+ }
+ localCustomer.serialize(new javax.xml.namespace.QName("http://www.vitero.de/schema/customer","customer"),
+ factory,xmlWriter);
+
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/customer",
+ "customer"));
+
+
+ if (localCustomer==null){
+ throw new org.apache.axis2.databinding.ADBException("customer cannot be null!!");
+ }
+ elementList.add(localCustomer);
+
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static Customer parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ Customer object =
+ new Customer();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"customer".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (Customer)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/customer","customer").equals(reader.getName())){
+
+ object.setCustomer(Customertype.Factory.parse(reader));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class DeleteCustomerRequest
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/customer",
+ "deleteCustomerRequest",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/customer")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for DeleteCustomerRequest
+ */
+
+
+ protected Customerid localDeleteCustomerRequest ;
+
+
+ /**
+ * Auto generated getter method
+ * @return Customerid
+ */
+ public Customerid getDeleteCustomerRequest(){
+ return localDeleteCustomerRequest;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param DeleteCustomerRequest
+ */
+ public void setDeleteCustomerRequest(Customerid param){
+
+ this.localDeleteCustomerRequest=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ DeleteCustomerRequest.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+ //We can safely assume an element has only one type associated with it
+
+ if (localDeleteCustomerRequest==null){
+ throw new org.apache.axis2.databinding.ADBException("Property cannot be null!");
+ }
+ localDeleteCustomerRequest.serialize(MY_QNAME,factory,xmlWriter);
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+
+ //We can safely assume an element has only one type associated with it
+ return localDeleteCustomerRequest.getPullParser(MY_QNAME);
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static DeleteCustomerRequest parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ DeleteCustomerRequest object =
+ new DeleteCustomerRequest();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/customer","deleteCustomerRequest").equals(reader.getName())){
+
+ object.setDeleteCustomerRequest(Customerid.Factory.parse(reader));
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class GetCustomerListResponse
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/customer",
+ "getCustomerListResponse",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/customer")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for Customer
+ * This was an Array!
+ */
+
+
+ protected Customertype[] localCustomer ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localCustomerTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return Customertype[]
+ */
+ public Customertype[] getCustomer(){
+ return localCustomer;
+ }
+
+
+
+
+
+
+ /**
+ * validate the array for Customer
+ */
+ protected void validateCustomer(Customertype[] param){
+
+ }
+
+
+ /**
+ * Auto generated setter method
+ * @param param Customer
+ */
+ public void setCustomer(Customertype[] param){
+
+ validateCustomer(param);
+
+
+ if (param != null){
+ //update the setting tracker
+ localCustomerTracker = true;
+ } else {
+ localCustomerTracker = false;
+
+ }
+
+ this.localCustomer=param;
+ }
+
+
+
+ /**
+ * Auto generated add method for the array for convenience
+ * @param param Customertype
+ */
+ public void addCustomer(Customertype param){
+ if (localCustomer == null){
+ localCustomer = new Customertype[]{};
+ }
+
+
+ //update the setting tracker
+ localCustomerTracker = true;
+
+
+ java.util.List list =
+ org.apache.axis2.databinding.utils.ConverterUtil.toList(localCustomer);
+ list.add(param);
+ this.localCustomer =
+ (Customertype[])list.toArray(
+ new Customertype[list.size()]);
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ GetCustomerListResponse.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/customer");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":getCustomerListResponse",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "getCustomerListResponse",
+ xmlWriter);
+ }
+
+
+ }
+ if (localCustomerTracker){
+ if (localCustomer!=null){
+ for (int i = 0;i < localCustomer.length;i++){
+ if (localCustomer[i] != null){
+ localCustomer[i].serialize(new javax.xml.namespace.QName("http://www.vitero.de/schema/customer","customer"),
+ factory,xmlWriter);
+ } else {
+
+ // we don't have to do any thing since minOccures is zero
+
+ }
+
+ }
+ } else {
+
+ throw new org.apache.axis2.databinding.ADBException("customer cannot be null!!");
+
+ }
+ }
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+ if (localCustomerTracker){
+ if (localCustomer!=null) {
+ for (int i = 0;i < localCustomer.length;i++){
+
+ if (localCustomer[i] != null){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/customer",
+ "customer"));
+ elementList.add(localCustomer[i]);
+ } else {
+
+ // nothing to do
+
+ }
+
+ }
+ } else {
+
+ throw new org.apache.axis2.databinding.ADBException("customer cannot be null!!");
+
+ }
+
+ }
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static GetCustomerListResponse parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ GetCustomerListResponse object =
+ new GetCustomerListResponse();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"getCustomerListResponse".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (GetCustomerListResponse)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+ java.util.ArrayList list1 = new java.util.ArrayList();
+
+
+ while (!reader.isStartElement() && !reader.isEndElement()) reader.next();
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/customer","customer").equals(reader.getName())){
+
+
+
+ // Process the array and step past its final element's end.
+ list1.add(Customertype.Factory.parse(reader));
+
+ //loop until we find a start element that is not part of this array
+ boolean loopDone1 = false;
+ while(!loopDone1){
+ // We should be at the end element, but make sure
+ while (!reader.isEndElement())
+ reader.next();
+ // Step out of this element
+ reader.next();
+ // Step to next element event.
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+ if (reader.isEndElement()){
+ //two continuous end elements means we are exiting the xml structure
+ loopDone1 = true;
+ } else {
+ if (new javax.xml.namespace.QName("http://www.vitero.de/schema/customer","customer").equals(reader.getName())){
+ list1.add(Customertype.Factory.parse(reader));
+
+ }else{
+ loopDone1 = true;
+ }
+ }
+ }
+ // call the converter utility to convert and set the array
+
+ object.setCustomer((Customertype[])
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToArray(
+ Customertype.class,
+ list1));
+
+ } // End of if for expected property start element
+
+ else {
+
+ }
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+ if (reader.isStartElement())
+ // A start element we are not expecting indicates a trailing invalid property
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class UpdateCustomerRequest
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/customer",
+ "updateCustomerRequest",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/customer")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for Customer
+ */
+
+
+ protected Customer_type0 localCustomer ;
+
+
+ /**
+ * Auto generated getter method
+ * @return Customer_type0
+ */
+ public Customer_type0 getCustomer(){
+ return localCustomer;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Customer
+ */
+ public void setCustomer(Customer_type0 param){
+
+ this.localCustomer=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ UpdateCustomerRequest.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/customer");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":updateCustomerRequest",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "updateCustomerRequest",
+ xmlWriter);
+ }
+
+
+ }
+
+ if (localCustomer==null){
+ throw new org.apache.axis2.databinding.ADBException("customer cannot be null!!");
+ }
+ localCustomer.serialize(new javax.xml.namespace.QName("http://www.vitero.de/schema/customer","customer"),
+ factory,xmlWriter);
+
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/customer",
+ "customer"));
+
+
+ if (localCustomer==null){
+ throw new org.apache.axis2.databinding.ADBException("customer cannot be null!!");
+ }
+ elementList.add(localCustomer);
+
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static UpdateCustomerRequest parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ UpdateCustomerRequest object =
+ new UpdateCustomerRequest();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"updateCustomerRequest".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (UpdateCustomerRequest)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/customer","customer").equals(reader.getName())){
+
+ object.setCustomer(Customer_type0.Factory.parse(reader));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class Customertype
+ implements org.apache.axis2.databinding.ADBBean{
+ /* This type was generated from the piece of schema that had
+ name = customertype
+ Namespace URI = http://www.vitero.de/schema/customer
+ Namespace Prefix = ns1
+ */
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/customer")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for Id
+ */
+
+
+ protected int localId ;
+
+
+ /**
+ * Auto generated getter method
+ * @return int
+ */
+ public int getId(){
+ return localId;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Id
+ */
+ public void setId(int param){
+
+ this.localId=param;
+
+
+ }
+
+
+ /**
+ * field for Shortname
+ */
+
+
+ protected java.lang.String localShortname ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getShortname(){
+ return localShortname;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Shortname
+ */
+ public void setShortname(java.lang.String param){
+
+ this.localShortname=param;
+
+
+ }
+
+
+ /**
+ * field for Displayname
+ */
+
+
+ protected java.lang.String localDisplayname ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getDisplayname(){
+ return localDisplayname;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Displayname
+ */
+ public void setDisplayname(java.lang.String param){
+
+ this.localDisplayname=param;
+
+
+ }
+
+
+ /**
+ * field for Groupidlist
+ */
+
+
+ protected Idlist localGroupidlist ;
+
+
+ /**
+ * Auto generated getter method
+ * @return Idlist
+ */
+ public Idlist getGroupidlist(){
+ return localGroupidlist;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Groupidlist
+ */
+ public void setGroupidlist(Idlist param){
+
+ this.localGroupidlist=param;
+
+
+ }
+
+
+ /**
+ * field for User
+ * This was an Array!
+ */
+
+
+ protected User_type0[] localUser ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localUserTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return User_type0[]
+ */
+ public User_type0[] getUser(){
+ return localUser;
+ }
+
+
+
+
+
+
+ /**
+ * validate the array for User
+ */
+ protected void validateUser(User_type0[] param){
+
+ }
+
+
+ /**
+ * Auto generated setter method
+ * @param param User
+ */
+ public void setUser(User_type0[] param){
+
+ validateUser(param);
+
+
+ if (param != null){
+ //update the setting tracker
+ localUserTracker = true;
+ } else {
+ localUserTracker = false;
+
+ }
+
+ this.localUser=param;
+ }
+
+
+
+ /**
+ * Auto generated add method for the array for convenience
+ * @param param User_type0
+ */
+ public void addUser(User_type0 param){
+ if (localUser == null){
+ localUser = new User_type0[]{};
+ }
+
+
+ //update the setting tracker
+ localUserTracker = true;
+
+
+ java.util.List list =
+ org.apache.axis2.databinding.utils.ConverterUtil.toList(localUser);
+ list.add(param);
+ this.localUser =
+ (User_type0[])list.toArray(
+ new User_type0[list.size()]);
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,parentQName){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ Customertype.this.serialize(parentQName,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ parentQName,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/customer");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":customertype",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "customertype",
+ xmlWriter);
+ }
+
+
+ }
+
+ namespace = "http://www.vitero.de/schema/customer";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"id", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"id");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("id");
+ }
+
+ if (localId==java.lang.Integer.MIN_VALUE) {
+
+ throw new org.apache.axis2.databinding.ADBException("id cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localId));
+ }
+
+ xmlWriter.writeEndElement();
+
+ namespace = "http://www.vitero.de/schema/customer";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"shortname", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"shortname");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("shortname");
+ }
+
+
+ if (localShortname==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("shortname cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localShortname);
+
+ }
+
+ xmlWriter.writeEndElement();
+
+ namespace = "http://www.vitero.de/schema/customer";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"displayname", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"displayname");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("displayname");
+ }
+
+
+ if (localDisplayname==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("displayname cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localDisplayname);
+
+ }
+
+ xmlWriter.writeEndElement();
+
+ if (localGroupidlist==null){
+ throw new org.apache.axis2.databinding.ADBException("groupidlist cannot be null!!");
+ }
+ localGroupidlist.serialize(new javax.xml.namespace.QName("http://www.vitero.de/schema/customer","groupidlist"),
+ factory,xmlWriter);
+ if (localUserTracker){
+ if (localUser!=null){
+ for (int i = 0;i < localUser.length;i++){
+ if (localUser[i] != null){
+ localUser[i].serialize(new javax.xml.namespace.QName("http://www.vitero.de/schema/customer","user"),
+ factory,xmlWriter);
+ } else {
+
+ // we don't have to do any thing since minOccures is zero
+
+ }
+
+ }
+ } else {
+
+ throw new org.apache.axis2.databinding.ADBException("user cannot be null!!");
+
+ }
+ }
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/customer",
+ "id"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localId));
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/customer",
+ "shortname"));
+
+ if (localShortname != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localShortname));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("shortname cannot be null!!");
+ }
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/customer",
+ "displayname"));
+
+ if (localDisplayname != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localDisplayname));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("displayname cannot be null!!");
+ }
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/customer",
+ "groupidlist"));
+
+
+ if (localGroupidlist==null){
+ throw new org.apache.axis2.databinding.ADBException("groupidlist cannot be null!!");
+ }
+ elementList.add(localGroupidlist);
+ if (localUserTracker){
+ if (localUser!=null) {
+ for (int i = 0;i < localUser.length;i++){
+
+ if (localUser[i] != null){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/customer",
+ "user"));
+ elementList.add(localUser[i]);
+ } else {
+
+ // nothing to do
+
+ }
+
+ }
+ } else {
+
+ throw new org.apache.axis2.databinding.ADBException("user cannot be null!!");
+
+ }
+
+ }
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static Customertype parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ Customertype object =
+ new Customertype();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"customertype".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (Customertype)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+ java.util.ArrayList list5 = new java.util.ArrayList();
+
+
+ while (!reader.isStartElement() && !reader.isEndElement()) reader.next();
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/customer","id").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setId(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToInt(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+
+ while (!reader.isStartElement() && !reader.isEndElement()) reader.next();
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/customer","shortname").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setShortname(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+
+ while (!reader.isStartElement() && !reader.isEndElement()) reader.next();
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/customer","displayname").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setDisplayname(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+
+ while (!reader.isStartElement() && !reader.isEndElement()) reader.next();
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/customer","groupidlist").equals(reader.getName())){
+
+ object.setGroupidlist(Idlist.Factory.parse(reader));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+
+ while (!reader.isStartElement() && !reader.isEndElement()) reader.next();
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/customer","user").equals(reader.getName())){
+
+
+
+ // Process the array and step past its final element's end.
+ list5.add(User_type0.Factory.parse(reader));
+
+ //loop until we find a start element that is not part of this array
+ boolean loopDone5 = false;
+ while(!loopDone5){
+ // We should be at the end element, but make sure
+ while (!reader.isEndElement())
+ reader.next();
+ // Step out of this element
+ reader.next();
+ // Step to next element event.
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+ if (reader.isEndElement()){
+ //two continuous end elements means we are exiting the xml structure
+ loopDone5 = true;
+ } else {
+ if (new javax.xml.namespace.QName("http://www.vitero.de/schema/customer","user").equals(reader.getName())){
+ list5.add(User_type0.Factory.parse(reader));
+
+ }else{
+ loopDone5 = true;
+ }
+ }
+ }
+ // call the converter utility to convert and set the array
+
+ object.setUser((User_type0[])
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToArray(
+ User_type0.class,
+ list5));
+
+ } // End of if for expected property start element
+
+ else {
+
+ }
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+ if (reader.isStartElement())
+ // A start element we are not expecting indicates a trailing invalid property
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class GetCustomerRequest
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/customer",
+ "getCustomerRequest",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/customer")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for GetCustomerRequest
+ */
+
+
+ protected Customerid localGetCustomerRequest ;
+
+
+ /**
+ * Auto generated getter method
+ * @return Customerid
+ */
+ public Customerid getGetCustomerRequest(){
+ return localGetCustomerRequest;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param GetCustomerRequest
+ */
+ public void setGetCustomerRequest(Customerid param){
+
+ this.localGetCustomerRequest=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ GetCustomerRequest.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+ //We can safely assume an element has only one type associated with it
+
+ if (localGetCustomerRequest==null){
+ throw new org.apache.axis2.databinding.ADBException("Property cannot be null!");
+ }
+ localGetCustomerRequest.serialize(MY_QNAME,factory,xmlWriter);
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+
+ //We can safely assume an element has only one type associated with it
+ return localGetCustomerRequest.getPullParser(MY_QNAME);
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static GetCustomerRequest parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ GetCustomerRequest object =
+ new GetCustomerRequest();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/customer","getCustomerRequest").equals(reader.getName())){
+
+ object.setGetCustomerRequest(Customerid.Factory.parse(reader));
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class Customeriduserid
+ implements org.apache.axis2.databinding.ADBBean{
+ /* This type was generated from the piece of schema that had
+ name = customeriduserid
+ Namespace URI = http://www.vitero.de/schema/customer
+ Namespace Prefix = ns1
+ */
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/customer")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for Customerid
+ */
+
+
+ protected int localCustomerid ;
+
+
+ /**
+ * Auto generated getter method
+ * @return int
+ */
+ public int getCustomerid(){
+ return localCustomerid;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Customerid
+ */
+ public void setCustomerid(int param){
+
+ this.localCustomerid=param;
+
+
+ }
+
+
+ /**
+ * field for Userid
+ */
+
+
+ protected int localUserid ;
+
+
+ /**
+ * Auto generated getter method
+ * @return int
+ */
+ public int getUserid(){
+ return localUserid;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Userid
+ */
+ public void setUserid(int param){
+
+ this.localUserid=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,parentQName){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ Customeriduserid.this.serialize(parentQName,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ parentQName,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/customer");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":customeriduserid",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "customeriduserid",
+ xmlWriter);
+ }
+
+
+ }
+
+ namespace = "http://www.vitero.de/schema/customer";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"customerid", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"customerid");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("customerid");
+ }
+
+ if (localCustomerid==java.lang.Integer.MIN_VALUE) {
+
+ throw new org.apache.axis2.databinding.ADBException("customerid cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localCustomerid));
+ }
+
+ xmlWriter.writeEndElement();
+
+ namespace = "http://www.vitero.de/schema/customer";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"userid", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"userid");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("userid");
+ }
+
+ if (localUserid==java.lang.Integer.MIN_VALUE) {
+
+ throw new org.apache.axis2.databinding.ADBException("userid cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localUserid));
+ }
+
+ xmlWriter.writeEndElement();
+
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/customer",
+ "customerid"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localCustomerid));
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/customer",
+ "userid"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localUserid));
+
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static Customeriduserid parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ Customeriduserid object =
+ new Customeriduserid();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"customeriduserid".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (Customeriduserid)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/customer","customerid").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setCustomerid(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToInt(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/customer","userid").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setUserid(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToInt(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class User_type0
+ implements org.apache.axis2.databinding.ADBBean{
+ /* This type was generated from the piece of schema that had
+ name = user_type0
+ Namespace URI = http://www.vitero.de/schema/customer
+ Namespace Prefix = ns1
+ */
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/customer")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for Userid
+ */
+
+
+ protected int localUserid ;
+
+
+ /**
+ * Auto generated getter method
+ * @return int
+ */
+ public int getUserid(){
+ return localUserid;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Userid
+ */
+ public void setUserid(int param){
+
+ this.localUserid=param;
+
+
+ }
+
+
+ /**
+ * field for Admin
+ */
+
+
+ protected boolean localAdmin ;
+
+
+ /**
+ * Auto generated getter method
+ * @return boolean
+ */
+ public boolean getAdmin(){
+ return localAdmin;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Admin
+ */
+ public void setAdmin(boolean param){
+
+ this.localAdmin=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,parentQName){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ User_type0.this.serialize(parentQName,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ parentQName,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/customer");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":user_type0",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "user_type0",
+ xmlWriter);
+ }
+
+
+ }
+
+ namespace = "http://www.vitero.de/schema/customer";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"userid", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"userid");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("userid");
+ }
+
+ if (localUserid==java.lang.Integer.MIN_VALUE) {
+
+ throw new org.apache.axis2.databinding.ADBException("userid cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localUserid));
+ }
+
+ xmlWriter.writeEndElement();
+
+ namespace = "http://www.vitero.de/schema/customer";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"admin", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"admin");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("admin");
+ }
+
+ if (false) {
+
+ throw new org.apache.axis2.databinding.ADBException("admin cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localAdmin));
+ }
+
+ xmlWriter.writeEndElement();
+
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/customer",
+ "userid"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localUserid));
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/customer",
+ "admin"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localAdmin));
+
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static User_type0 parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ User_type0 object =
+ new User_type0();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"user_type0".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (User_type0)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/customer","userid").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setUserid(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToInt(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/customer","admin").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setAdmin(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToBoolean(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class SuccessResponse
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/customer",
+ "successResponse",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/customer")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for Request
+ */
+
+
+ protected java.lang.String localRequest ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getRequest(){
+ return localRequest;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Request
+ */
+ public void setRequest(java.lang.String param){
+
+ this.localRequest=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ SuccessResponse.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/customer");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":successResponse",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "successResponse",
+ xmlWriter);
+ }
+
+
+ }
+
+ namespace = "http://www.vitero.de/schema/customer";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"request", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"request");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("request");
+ }
+
+
+ if (localRequest==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("request cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localRequest);
+
+ }
+
+ xmlWriter.writeEndElement();
+
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/customer",
+ "request"));
+
+ if (localRequest != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localRequest));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("request cannot be null!!");
+ }
+
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static SuccessResponse parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ SuccessResponse object =
+ new SuccessResponse();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"successResponse".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (SuccessResponse)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/customer","request").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setRequest(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class GetCustomerByNameRequest
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/customer",
+ "getCustomerByNameRequest",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/customer")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for Customername
+ */
+
+
+ protected java.lang.String localCustomername ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getCustomername(){
+ return localCustomername;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Customername
+ */
+ public void setCustomername(java.lang.String param){
+
+ this.localCustomername=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ GetCustomerByNameRequest.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/customer");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":getCustomerByNameRequest",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "getCustomerByNameRequest",
+ xmlWriter);
+ }
+
+
+ }
+
+ namespace = "http://www.vitero.de/schema/customer";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"customername", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"customername");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("customername");
+ }
+
+
+ if (localCustomername==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("customername cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localCustomername);
+
+ }
+
+ xmlWriter.writeEndElement();
+
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/customer",
+ "customername"));
+
+ if (localCustomername != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localCustomername));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("customername cannot be null!!");
+ }
+
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static GetCustomerByNameRequest parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ GetCustomerByNameRequest object =
+ new GetCustomerByNameRequest();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"getCustomerByNameRequest".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (GetCustomerByNameRequest)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/customer","customername").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setCustomername(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class AddUserToCustomerRequest
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/customer",
+ "addUserToCustomerRequest",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/customer")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for AddUserToCustomerRequest
+ */
+
+
+ protected Customeriduserid localAddUserToCustomerRequest ;
+
+
+ /**
+ * Auto generated getter method
+ * @return Customeriduserid
+ */
+ public Customeriduserid getAddUserToCustomerRequest(){
+ return localAddUserToCustomerRequest;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param AddUserToCustomerRequest
+ */
+ public void setAddUserToCustomerRequest(Customeriduserid param){
+
+ this.localAddUserToCustomerRequest=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ AddUserToCustomerRequest.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+ //We can safely assume an element has only one type associated with it
+
+ if (localAddUserToCustomerRequest==null){
+ throw new org.apache.axis2.databinding.ADBException("Property cannot be null!");
+ }
+ localAddUserToCustomerRequest.serialize(MY_QNAME,factory,xmlWriter);
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+
+ //We can safely assume an element has only one type associated with it
+ return localAddUserToCustomerRequest.getPullParser(MY_QNAME);
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static AddUserToCustomerRequest parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ AddUserToCustomerRequest object =
+ new AddUserToCustomerRequest();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/customer","addUserToCustomerRequest").equals(reader.getName())){
+
+ object.setAddUserToCustomerRequest(Customeriduserid.Factory.parse(reader));
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class MoveUserToCustomerRequest
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/customer",
+ "moveUserToCustomerRequest",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/customer")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for Userid
+ */
+
+
+ protected int localUserid ;
+
+
+ /**
+ * Auto generated getter method
+ * @return int
+ */
+ public int getUserid(){
+ return localUserid;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Userid
+ */
+ public void setUserid(int param){
+
+ this.localUserid=param;
+
+
+ }
+
+
+ /**
+ * field for Sourcecustomerid
+ */
+
+
+ protected int localSourcecustomerid ;
+
+
+ /**
+ * Auto generated getter method
+ * @return int
+ */
+ public int getSourcecustomerid(){
+ return localSourcecustomerid;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Sourcecustomerid
+ */
+ public void setSourcecustomerid(int param){
+
+ this.localSourcecustomerid=param;
+
+
+ }
+
+
+ /**
+ * field for Destcustomerid
+ */
+
+
+ protected int localDestcustomerid ;
+
+
+ /**
+ * Auto generated getter method
+ * @return int
+ */
+ public int getDestcustomerid(){
+ return localDestcustomerid;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Destcustomerid
+ */
+ public void setDestcustomerid(int param){
+
+ this.localDestcustomerid=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ MoveUserToCustomerRequest.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/customer");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":moveUserToCustomerRequest",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "moveUserToCustomerRequest",
+ xmlWriter);
+ }
+
+
+ }
+
+ namespace = "http://www.vitero.de/schema/customer";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"userid", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"userid");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("userid");
+ }
+
+ if (localUserid==java.lang.Integer.MIN_VALUE) {
+
+ throw new org.apache.axis2.databinding.ADBException("userid cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localUserid));
+ }
+
+ xmlWriter.writeEndElement();
+
+ namespace = "http://www.vitero.de/schema/customer";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"sourcecustomerid", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"sourcecustomerid");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("sourcecustomerid");
+ }
+
+ if (localSourcecustomerid==java.lang.Integer.MIN_VALUE) {
+
+ throw new org.apache.axis2.databinding.ADBException("sourcecustomerid cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localSourcecustomerid));
+ }
+
+ xmlWriter.writeEndElement();
+
+ namespace = "http://www.vitero.de/schema/customer";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"destcustomerid", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"destcustomerid");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("destcustomerid");
+ }
+
+ if (localDestcustomerid==java.lang.Integer.MIN_VALUE) {
+
+ throw new org.apache.axis2.databinding.ADBException("destcustomerid cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localDestcustomerid));
+ }
+
+ xmlWriter.writeEndElement();
+
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/customer",
+ "userid"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localUserid));
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/customer",
+ "sourcecustomerid"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localSourcecustomerid));
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/customer",
+ "destcustomerid"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localDestcustomerid));
+
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static MoveUserToCustomerRequest parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ MoveUserToCustomerRequest object =
+ new MoveUserToCustomerRequest();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"moveUserToCustomerRequest".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (MoveUserToCustomerRequest)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/customer","userid").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setUserid(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToInt(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/customer","sourcecustomerid").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setSourcecustomerid(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToInt(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/customer","destcustomerid").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setDestcustomerid(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToInt(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class Customerid
+ implements org.apache.axis2.databinding.ADBBean{
+ /* This type was generated from the piece of schema that had
+ name = customerid
+ Namespace URI = http://www.vitero.de/schema/customer
+ Namespace Prefix = ns1
+ */
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/customer")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for Customerid
+ */
+
+
+ protected int localCustomerid ;
+
+
+ /**
+ * Auto generated getter method
+ * @return int
+ */
+ public int getCustomerid(){
+ return localCustomerid;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Customerid
+ */
+ public void setCustomerid(int param){
+
+ this.localCustomerid=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,parentQName){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ Customerid.this.serialize(parentQName,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ parentQName,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/customer");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":customerid",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "customerid",
+ xmlWriter);
+ }
+
+
+ }
+
+ namespace = "http://www.vitero.de/schema/customer";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"customerid", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"customerid");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("customerid");
+ }
+
+ if (localCustomerid==java.lang.Integer.MIN_VALUE) {
+
+ throw new org.apache.axis2.databinding.ADBException("customerid cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localCustomerid));
+ }
+
+ xmlWriter.writeEndElement();
+
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/customer",
+ "customerid"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localCustomerid));
+
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static Customerid parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ Customerid object =
+ new Customerid();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"customerid".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (Customerid)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/customer","customerid").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setCustomerid(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToInt(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class MoveAllUsersToCustomerRequest
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/customer",
+ "moveAllUsersToCustomerRequest",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/customer")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for Sourcecustomerid
+ */
+
+
+ protected int localSourcecustomerid ;
+
+
+ /**
+ * Auto generated getter method
+ * @return int
+ */
+ public int getSourcecustomerid(){
+ return localSourcecustomerid;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Sourcecustomerid
+ */
+ public void setSourcecustomerid(int param){
+
+ this.localSourcecustomerid=param;
+
+
+ }
+
+
+ /**
+ * field for Destcustomerid
+ */
+
+
+ protected int localDestcustomerid ;
+
+
+ /**
+ * Auto generated getter method
+ * @return int
+ */
+ public int getDestcustomerid(){
+ return localDestcustomerid;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Destcustomerid
+ */
+ public void setDestcustomerid(int param){
+
+ this.localDestcustomerid=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ MoveAllUsersToCustomerRequest.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/customer");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":moveAllUsersToCustomerRequest",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "moveAllUsersToCustomerRequest",
+ xmlWriter);
+ }
+
+
+ }
+
+ namespace = "http://www.vitero.de/schema/customer";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"sourcecustomerid", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"sourcecustomerid");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("sourcecustomerid");
+ }
+
+ if (localSourcecustomerid==java.lang.Integer.MIN_VALUE) {
+
+ throw new org.apache.axis2.databinding.ADBException("sourcecustomerid cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localSourcecustomerid));
+ }
+
+ xmlWriter.writeEndElement();
+
+ namespace = "http://www.vitero.de/schema/customer";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"destcustomerid", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"destcustomerid");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("destcustomerid");
+ }
+
+ if (localDestcustomerid==java.lang.Integer.MIN_VALUE) {
+
+ throw new org.apache.axis2.databinding.ADBException("destcustomerid cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localDestcustomerid));
+ }
+
+ xmlWriter.writeEndElement();
+
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/customer",
+ "sourcecustomerid"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localSourcecustomerid));
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/customer",
+ "destcustomerid"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localDestcustomerid));
+
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static MoveAllUsersToCustomerRequest parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ MoveAllUsersToCustomerRequest object =
+ new MoveAllUsersToCustomerRequest();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"moveAllUsersToCustomerRequest".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (MoveAllUsersToCustomerRequest)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/customer","sourcecustomerid").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setSourcecustomerid(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToInt(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/customer","destcustomerid").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setDestcustomerid(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToInt(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class Idlist
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/customer",
+ "idlist",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/customer")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ protected int[] local_int;
+
+ public int[] get_int(){
+ return local_int;
+ }
+
+ public void set_int(int[] itemList){
+ this.local_int = itemList;
+ }
+
+ public java.lang.String toString() {
+ java.lang.StringBuffer outString = new java.lang.StringBuffer();
+ if (local_int != null){
+ for(int i = 0; i < local_int.length;i++){
+
+ outString.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(local_int[i])).append(" ");
+
+
+ }
+ }
+ return outString.toString().trim();
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ Idlist.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+ // first write the start element
+ java.lang.String namespace = parentQName.getNamespaceURI();
+ java.lang.String localName = parentQName.getLocalPart();
+
+ if (! namespace.equals("")) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix, localName, namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace, localName);
+ }
+
+ } else {
+ xmlWriter.writeStartElement(localName);
+ }
+
+
+ xmlWriter.writeCharacters(Idlist.this.toString());
+
+
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(MY_QNAME,
+ new java.lang.Object[]{
+ org.apache.axis2.databinding.utils.reader.ADBXMLStreamReader.ELEMENT_TEXT,
+ toString()
+ },
+ null);
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+
+ public static Idlist fromString(javax.xml.stream.XMLStreamReader xmlStreamReader,
+ java.lang.String content)
+ throws org.apache.axis2.databinding.ADBException {
+
+ Idlist object = new Idlist();
+ java.lang.String[] values = content.split(" +");
+ int[] objectValues = new int[values.length];
+
+
+
+
+ try {
+ for (int i = 0; i < values.length; i++) {
+
+ objectValues[i] =
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToInt(values[i]);
+
+
+ }
+ object.set_int(objectValues);
+ return object;
+ } catch (java.lang.Exception e) {
+ throw new org.apache.axis2.databinding.ADBException();
+ }
+
+ }
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static Idlist parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ Idlist object =
+ new Idlist();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ java.lang.String content = reader.getElementText();
+ object = Idlist.Factory.fromString(reader,content);
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class GetCustomerByNameResponse
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/customer",
+ "getCustomerByNameResponse",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/customer")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for GetCustomerByNameResponse
+ */
+
+
+ protected Customer localGetCustomerByNameResponse ;
+
+
+ /**
+ * Auto generated getter method
+ * @return Customer
+ */
+ public Customer getGetCustomerByNameResponse(){
+ return localGetCustomerByNameResponse;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param GetCustomerByNameResponse
+ */
+ public void setGetCustomerByNameResponse(Customer param){
+
+ this.localGetCustomerByNameResponse=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ GetCustomerByNameResponse.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+ //We can safely assume an element has only one type associated with it
+
+ if (localGetCustomerByNameResponse==null){
+ throw new org.apache.axis2.databinding.ADBException("Property cannot be null!");
+ }
+ localGetCustomerByNameResponse.serialize(MY_QNAME,factory,xmlWriter);
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+
+ //We can safely assume an element has only one type associated with it
+ return localGetCustomerByNameResponse.getPullParser(MY_QNAME);
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static GetCustomerByNameResponse parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ GetCustomerByNameResponse object =
+ new GetCustomerByNameResponse();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/customer","getCustomerByNameResponse").equals(reader.getName())){
+
+ object.setGetCustomerByNameResponse(Customer.Factory.parse(reader));
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class RemoveUserFromCustomerRequest
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/customer",
+ "removeUserFromCustomerRequest",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/customer")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for RemoveUserFromCustomerRequest
+ */
+
+
+ protected Customeriduserid localRemoveUserFromCustomerRequest ;
+
+
+ /**
+ * Auto generated getter method
+ * @return Customeriduserid
+ */
+ public Customeriduserid getRemoveUserFromCustomerRequest(){
+ return localRemoveUserFromCustomerRequest;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param RemoveUserFromCustomerRequest
+ */
+ public void setRemoveUserFromCustomerRequest(Customeriduserid param){
+
+ this.localRemoveUserFromCustomerRequest=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ RemoveUserFromCustomerRequest.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+ //We can safely assume an element has only one type associated with it
+
+ if (localRemoveUserFromCustomerRequest==null){
+ throw new org.apache.axis2.databinding.ADBException("Property cannot be null!");
+ }
+ localRemoveUserFromCustomerRequest.serialize(MY_QNAME,factory,xmlWriter);
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+
+ //We can safely assume an element has only one type associated with it
+ return localRemoveUserFromCustomerRequest.getPullParser(MY_QNAME);
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static RemoveUserFromCustomerRequest parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ RemoveUserFromCustomerRequest object =
+ new RemoveUserFromCustomerRequest();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/customer","removeUserFromCustomerRequest").equals(reader.getName())){
+
+ object.setRemoveUserFromCustomerRequest(Customeriduserid.Factory.parse(reader));
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class ExtensionMapper{
+
+ public static java.lang.Object getTypeObject(java.lang.String namespaceURI,
+ java.lang.String typeName,
+ javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+
+
+ if (
+ "http://www.vitero.de/schema/customer".equals(namespaceURI) &&
+ "customertype".equals(typeName)){
+
+ return Customertype.Factory.parse(reader);
+
+
+ }
+
+
+ if (
+ "http://www.vitero.de/schema/customer".equals(namespaceURI) &&
+ "customer_type0".equals(typeName)){
+
+ return Customer_type0.Factory.parse(reader);
+
+
+ }
+
+
+ if (
+ "http://www.vitero.de/schema/customer".equals(namespaceURI) &&
+ "customerid".equals(typeName)){
+
+ return Customerid.Factory.parse(reader);
+
+
+ }
+
+
+ if (
+ "http://www.vitero.de/schema/customer".equals(namespaceURI) &&
+ "customer_type1".equals(typeName)){
+
+ return Customer_type1.Factory.parse(reader);
+
+
+ }
+
+
+ if (
+ "http://www.vitero.de/schema/customer".equals(namespaceURI) &&
+ "customeriduserid".equals(typeName)){
+
+ return Customeriduserid.Factory.parse(reader);
+
+
+ }
+
+
+ if (
+ "http://www.vitero.de/schema/customer".equals(namespaceURI) &&
+ "user_type0".equals(typeName)){
+
+ return User_type0.Factory.parse(reader);
+
+
+ }
+
+
+ if (
+ "http://www.vitero.de/schema/customer".equals(namespaceURI) &&
+ "customer".equals(typeName)){
+
+ return Customer.Factory.parse(reader);
+
+
+ }
+
+
+ if (
+ "http://www.vitero.de/schema/customer".equals(namespaceURI) &&
+ "idlist".equals(typeName)){
+
+ return Idlist.Factory.parse(reader);
+
+
+ }
+
+
+ throw new org.apache.axis2.databinding.ADBException("Unsupported type " + namespaceURI + " " + typeName);
+ }
+
+ }
+
+ public static class Customer_type0
+ implements org.apache.axis2.databinding.ADBBean{
+ /* This type was generated from the piece of schema that had
+ name = customer_type0
+ Namespace URI = http://www.vitero.de/schema/customer
+ Namespace Prefix = ns1
+ */
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/customer")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for Id
+ */
+
+
+ protected int localId ;
+
+
+ /**
+ * Auto generated getter method
+ * @return int
+ */
+ public int getId(){
+ return localId;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Id
+ */
+ public void setId(int param){
+
+ this.localId=param;
+
+
+ }
+
+
+ /**
+ * field for Shortname
+ */
+
+
+ protected java.lang.String localShortname ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localShortnameTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getShortname(){
+ return localShortname;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Shortname
+ */
+ public void setShortname(java.lang.String param){
+
+ if (param != null){
+ //update the setting tracker
+ localShortnameTracker = true;
+ } else {
+ localShortnameTracker = false;
+
+ }
+
+ this.localShortname=param;
+
+
+ }
+
+
+ /**
+ * field for Displayname
+ */
+
+
+ protected java.lang.String localDisplayname ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localDisplaynameTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getDisplayname(){
+ return localDisplayname;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Displayname
+ */
+ public void setDisplayname(java.lang.String param){
+
+ if (param != null){
+ //update the setting tracker
+ localDisplaynameTracker = true;
+ } else {
+ localDisplaynameTracker = false;
+
+ }
+
+ this.localDisplayname=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,parentQName){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ Customer_type0.this.serialize(parentQName,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ parentQName,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/customer");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":customer_type0",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "customer_type0",
+ xmlWriter);
+ }
+
+
+ }
+
+ namespace = "http://www.vitero.de/schema/customer";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"id", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"id");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("id");
+ }
+
+ if (localId==java.lang.Integer.MIN_VALUE) {
+
+ throw new org.apache.axis2.databinding.ADBException("id cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localId));
+ }
+
+ xmlWriter.writeEndElement();
+ if (localShortnameTracker){
+ namespace = "http://www.vitero.de/schema/customer";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"shortname", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"shortname");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("shortname");
+ }
+
+
+ if (localShortname==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("shortname cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localShortname);
+
+ }
+
+ xmlWriter.writeEndElement();
+ } if (localDisplaynameTracker){
+ namespace = "http://www.vitero.de/schema/customer";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"displayname", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"displayname");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("displayname");
+ }
+
+
+ if (localDisplayname==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("displayname cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localDisplayname);
+
+ }
+
+ xmlWriter.writeEndElement();
+ }
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/customer",
+ "id"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localId));
+ if (localShortnameTracker){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/customer",
+ "shortname"));
+
+ if (localShortname != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localShortname));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("shortname cannot be null!!");
+ }
+ } if (localDisplaynameTracker){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/customer",
+ "displayname"));
+
+ if (localDisplayname != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localDisplayname));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("displayname cannot be null!!");
+ }
+ }
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static Customer_type0 parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ Customer_type0 object =
+ new Customer_type0();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"customer_type0".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (Customer_type0)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/customer","id").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setId(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToInt(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/customer","shortname").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setShortname(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/customer","displayname").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setDisplayname(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class CreateCustomerResponse
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/customer",
+ "createCustomerResponse",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/customer")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for CreateCustomerResponse
+ */
+
+
+ protected Customerid localCreateCustomerResponse ;
+
+
+ /**
+ * Auto generated getter method
+ * @return Customerid
+ */
+ public Customerid getCreateCustomerResponse(){
+ return localCreateCustomerResponse;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param CreateCustomerResponse
+ */
+ public void setCreateCustomerResponse(Customerid param){
+
+ this.localCreateCustomerResponse=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ CreateCustomerResponse.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+ //We can safely assume an element has only one type associated with it
+
+ if (localCreateCustomerResponse==null){
+ throw new org.apache.axis2.databinding.ADBException("Property cannot be null!");
+ }
+ localCreateCustomerResponse.serialize(MY_QNAME,factory,xmlWriter);
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+
+ //We can safely assume an element has only one type associated with it
+ return localCreateCustomerResponse.getPullParser(MY_QNAME);
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static CreateCustomerResponse parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ CreateCustomerResponse object =
+ new CreateCustomerResponse();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/customer","createCustomerResponse").equals(reader.getName())){
+
+ object.setCreateCustomerResponse(Customerid.Factory.parse(reader));
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class Customer_type1
+ implements org.apache.axis2.databinding.ADBBean{
+ /* This type was generated from the piece of schema that had
+ name = customer_type1
+ Namespace URI = http://www.vitero.de/schema/customer
+ Namespace Prefix = ns1
+ */
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/customer")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for Shortname
+ */
+
+
+ protected java.lang.String localShortname ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getShortname(){
+ return localShortname;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Shortname
+ */
+ public void setShortname(java.lang.String param){
+
+ this.localShortname=param;
+
+
+ }
+
+
+ /**
+ * field for Displayname
+ */
+
+
+ protected java.lang.String localDisplayname ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getDisplayname(){
+ return localDisplayname;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Displayname
+ */
+ public void setDisplayname(java.lang.String param){
+
+ this.localDisplayname=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,parentQName){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ Customer_type1.this.serialize(parentQName,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ parentQName,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/customer");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":customer_type1",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "customer_type1",
+ xmlWriter);
+ }
+
+
+ }
+
+ namespace = "http://www.vitero.de/schema/customer";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"shortname", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"shortname");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("shortname");
+ }
+
+
+ if (localShortname==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("shortname cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localShortname);
+
+ }
+
+ xmlWriter.writeEndElement();
+
+ namespace = "http://www.vitero.de/schema/customer";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"displayname", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"displayname");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("displayname");
+ }
+
+
+ if (localDisplayname==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("displayname cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localDisplayname);
+
+ }
+
+ xmlWriter.writeEndElement();
+
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/customer",
+ "shortname"));
+
+ if (localShortname != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localShortname));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("shortname cannot be null!!");
+ }
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/customer",
+ "displayname"));
+
+ if (localDisplayname != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localDisplayname));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("displayname cannot be null!!");
+ }
+
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static Customer_type1 parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ Customer_type1 object =
+ new Customer_type1();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"customer_type1".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (Customer_type1)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/customer","shortname").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setShortname(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/customer","displayname").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setDisplayname(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class GetCustomerResponse
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/customer",
+ "getCustomerResponse",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/customer")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for GetCustomerResponse
+ */
+
+
+ protected Customer localGetCustomerResponse ;
+
+
+ /**
+ * Auto generated getter method
+ * @return Customer
+ */
+ public Customer getGetCustomerResponse(){
+ return localGetCustomerResponse;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param GetCustomerResponse
+ */
+ public void setGetCustomerResponse(Customer param){
+
+ this.localGetCustomerResponse=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ GetCustomerResponse.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+ //We can safely assume an element has only one type associated with it
+
+ if (localGetCustomerResponse==null){
+ throw new org.apache.axis2.databinding.ADBException("Property cannot be null!");
+ }
+ localGetCustomerResponse.serialize(MY_QNAME,factory,xmlWriter);
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+
+ //We can safely assume an element has only one type associated with it
+ return localGetCustomerResponse.getPullParser(MY_QNAME);
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static GetCustomerResponse parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ GetCustomerResponse object =
+ new GetCustomerResponse();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/customer","getCustomerResponse").equals(reader.getName())){
+
+ object.setGetCustomerResponse(Customer.Factory.parse(reader));
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class GetCustomerListRequest
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/customer",
+ "getCustomerListRequest",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/customer")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for GetCustomerListRequest
+ */
+
+
+ protected org.apache.axiom.om.OMElement localGetCustomerListRequest ;
+
+
+ /**
+ * Auto generated getter method
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getGetCustomerListRequest(){
+ return localGetCustomerListRequest;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param GetCustomerListRequest
+ */
+ public void setGetCustomerListRequest(org.apache.axiom.om.OMElement param){
+
+ this.localGetCustomerListRequest=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ GetCustomerListRequest.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+ //We can safely assume an element has only one type associated with it
+
+ java.lang.String namespace = "http://www.vitero.de/schema/customer";
+ java.lang.String localName = "getCustomerListRequest";
+
+ if (! namespace.equals("")) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix, localName, namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace, localName);
+ }
+
+ } else {
+ xmlWriter.writeStartElement(localName);
+ }
+
+ // add the type details if this is used in a simple type
+ if (serializeType){
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/customer");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":getCustomerListRequest",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "getCustomerListRequest",
+ xmlWriter);
+ }
+ }
+
+ if (localGetCustomerListRequest==null){
+
+ throw new org.apache.axis2.databinding.ADBException("Value cannot be null !!");
+
+ }else{
+ localGetCustomerListRequest.serialize(xmlWriter);
+
+ }
+
+ xmlWriter.writeEndElement();
+
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+
+ //We can safely assume an element has only one type associated with it
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(MY_QNAME,
+ new java.lang.Object[]{
+ org.apache.axis2.databinding.utils.reader.ADBXMLStreamReader.ELEMENT_TEXT,
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localGetCustomerListRequest)
+ },
+ null);
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static GetCustomerListRequest parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ GetCustomerListRequest object =
+ new GetCustomerListRequest();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement()){
+
+
+
+ //use the QName from the parser as the name for the builder
+ javax.xml.namespace.QName startQname1 = reader.getName();
+
+ // We need to wrap the reader so that it produces a fake START_DOCUMENT event
+ // this is needed by the builder classes
+ org.apache.axis2.databinding.utils.NamedStaxOMBuilder builder1 =
+ new org.apache.axis2.databinding.utils.NamedStaxOMBuilder(
+ new org.apache.axis2.util.StreamWrapper(reader),startQname1);
+ object.setGetCustomerListRequest(builder1.getOMElement());
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class CreateCustomerRequest
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/customer",
+ "createCustomerRequest",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/customer")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for Customer
+ */
+
+
+ protected Customer_type1 localCustomer ;
+
+
+ /**
+ * Auto generated getter method
+ * @return Customer_type1
+ */
+ public Customer_type1 getCustomer(){
+ return localCustomer;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Customer
+ */
+ public void setCustomer(Customer_type1 param){
+
+ this.localCustomer=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ CreateCustomerRequest.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/customer");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":createCustomerRequest",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "createCustomerRequest",
+ xmlWriter);
+ }
+
+
+ }
+
+ if (localCustomer==null){
+ throw new org.apache.axis2.databinding.ADBException("customer cannot be null!!");
+ }
+ localCustomer.serialize(new javax.xml.namespace.QName("http://www.vitero.de/schema/customer","customer"),
+ factory,xmlWriter);
+
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/customer",
+ "customer"));
+
+
+ if (localCustomer==null){
+ throw new org.apache.axis2.databinding.ADBException("customer cannot be null!!");
+ }
+ elementList.add(localCustomer);
+
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static CreateCustomerRequest parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ CreateCustomerRequest object =
+ new CreateCustomerRequest();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"createCustomerRequest".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (CreateCustomerRequest)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/customer","customer").equals(reader.getName())){
+
+ object.setCustomer(Customer_type1.Factory.parse(reader));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.GetCustomerByNameRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.GetCustomerByNameRequest.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.GetCustomerByNameResponse param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.GetCustomerByNameResponse.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.GetCustomerListRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.GetCustomerListRequest.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.GetCustomerListResponse param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.GetCustomerListResponse.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.SuccessResponse param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.SuccessResponse.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.MoveAllUsersToCustomerRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.MoveAllUsersToCustomerRequest.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.AddUserToCustomerRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.AddUserToCustomerRequest.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.DeleteCustomerRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.DeleteCustomerRequest.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.CreateCustomerRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.CreateCustomerRequest.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.CreateCustomerResponse param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.CreateCustomerResponse.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.MoveUserToCustomerRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.MoveUserToCustomerRequest.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.UpdateCustomerRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.UpdateCustomerRequest.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.GetCustomerRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.GetCustomerRequest.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.GetCustomerResponse param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.GetCustomerResponse.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.RemoveUserFromCustomerRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.RemoveUserFromCustomerRequest.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+
+ private org.apache.axiom.soap.SOAPEnvelope toEnvelope(org.apache.axiom.soap.SOAPFactory factory, com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.GetCustomerByNameRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault{
+
+
+ try{
+
+ org.apache.axiom.soap.SOAPEnvelope emptyEnvelope = factory.getDefaultEnvelope();
+ emptyEnvelope.getBody().addChild(param.getOMElement(com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.GetCustomerByNameRequest.MY_QNAME,factory));
+ return emptyEnvelope;
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+
+ /* methods to provide back word compatibility */
+
+
+
+ private org.apache.axiom.soap.SOAPEnvelope toEnvelope(org.apache.axiom.soap.SOAPFactory factory, com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.GetCustomerListRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault{
+
+
+ try{
+
+ org.apache.axiom.soap.SOAPEnvelope emptyEnvelope = factory.getDefaultEnvelope();
+ emptyEnvelope.getBody().addChild(param.getOMElement(com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.GetCustomerListRequest.MY_QNAME,factory));
+ return emptyEnvelope;
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+
+ /* methods to provide back word compatibility */
+
+
+
+ private org.apache.axiom.soap.SOAPEnvelope toEnvelope(org.apache.axiom.soap.SOAPFactory factory, com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.MoveAllUsersToCustomerRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault{
+
+
+ try{
+
+ org.apache.axiom.soap.SOAPEnvelope emptyEnvelope = factory.getDefaultEnvelope();
+ emptyEnvelope.getBody().addChild(param.getOMElement(com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.MoveAllUsersToCustomerRequest.MY_QNAME,factory));
+ return emptyEnvelope;
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+
+ /* methods to provide back word compatibility */
+
+
+
+ private org.apache.axiom.soap.SOAPEnvelope toEnvelope(org.apache.axiom.soap.SOAPFactory factory, com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.AddUserToCustomerRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault{
+
+
+ try{
+
+ org.apache.axiom.soap.SOAPEnvelope emptyEnvelope = factory.getDefaultEnvelope();
+ emptyEnvelope.getBody().addChild(param.getOMElement(com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.AddUserToCustomerRequest.MY_QNAME,factory));
+ return emptyEnvelope;
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+
+ /* methods to provide back word compatibility */
+
+
+
+ private org.apache.axiom.soap.SOAPEnvelope toEnvelope(org.apache.axiom.soap.SOAPFactory factory, com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.DeleteCustomerRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault{
+
+
+ try{
+
+ org.apache.axiom.soap.SOAPEnvelope emptyEnvelope = factory.getDefaultEnvelope();
+ emptyEnvelope.getBody().addChild(param.getOMElement(com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.DeleteCustomerRequest.MY_QNAME,factory));
+ return emptyEnvelope;
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+
+ /* methods to provide back word compatibility */
+
+
+
+ private org.apache.axiom.soap.SOAPEnvelope toEnvelope(org.apache.axiom.soap.SOAPFactory factory, com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.CreateCustomerRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault{
+
+
+ try{
+
+ org.apache.axiom.soap.SOAPEnvelope emptyEnvelope = factory.getDefaultEnvelope();
+ emptyEnvelope.getBody().addChild(param.getOMElement(com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.CreateCustomerRequest.MY_QNAME,factory));
+ return emptyEnvelope;
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+
+ /* methods to provide back word compatibility */
+
+
+
+ private org.apache.axiom.soap.SOAPEnvelope toEnvelope(org.apache.axiom.soap.SOAPFactory factory, com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.MoveUserToCustomerRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault{
+
+
+ try{
+
+ org.apache.axiom.soap.SOAPEnvelope emptyEnvelope = factory.getDefaultEnvelope();
+ emptyEnvelope.getBody().addChild(param.getOMElement(com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.MoveUserToCustomerRequest.MY_QNAME,factory));
+ return emptyEnvelope;
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+
+ /* methods to provide back word compatibility */
+
+
+
+ private org.apache.axiom.soap.SOAPEnvelope toEnvelope(org.apache.axiom.soap.SOAPFactory factory, com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.UpdateCustomerRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault{
+
+
+ try{
+
+ org.apache.axiom.soap.SOAPEnvelope emptyEnvelope = factory.getDefaultEnvelope();
+ emptyEnvelope.getBody().addChild(param.getOMElement(com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.UpdateCustomerRequest.MY_QNAME,factory));
+ return emptyEnvelope;
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+
+ /* methods to provide back word compatibility */
+
+
+
+ private org.apache.axiom.soap.SOAPEnvelope toEnvelope(org.apache.axiom.soap.SOAPFactory factory, com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.GetCustomerRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault{
+
+
+ try{
+
+ org.apache.axiom.soap.SOAPEnvelope emptyEnvelope = factory.getDefaultEnvelope();
+ emptyEnvelope.getBody().addChild(param.getOMElement(com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.GetCustomerRequest.MY_QNAME,factory));
+ return emptyEnvelope;
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+
+ /* methods to provide back word compatibility */
+
+
+
+ private org.apache.axiom.soap.SOAPEnvelope toEnvelope(org.apache.axiom.soap.SOAPFactory factory, com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.RemoveUserFromCustomerRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault{
+
+
+ try{
+
+ org.apache.axiom.soap.SOAPEnvelope emptyEnvelope = factory.getDefaultEnvelope();
+ emptyEnvelope.getBody().addChild(param.getOMElement(com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.RemoveUserFromCustomerRequest.MY_QNAME,factory));
+ return emptyEnvelope;
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+
+ /* methods to provide back word compatibility */
+
+
+
+
+ /**
+ * get the default envelope
+ */
+ private org.apache.axiom.soap.SOAPEnvelope toEnvelope(org.apache.axiom.soap.SOAPFactory factory){
+ return factory.getDefaultEnvelope();
+ }
+
+
+ private java.lang.Object fromOM(
+ org.apache.axiom.om.OMElement param,
+ java.lang.Class type,
+ java.util.Map extraNamespaces) throws org.apache.axis2.AxisFault{
+
+ try {
+
+ if (com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.GetCustomerByNameRequest.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.GetCustomerByNameRequest.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ if (com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.GetCustomerByNameResponse.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.GetCustomerByNameResponse.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ if (com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.GetCustomerListRequest.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.GetCustomerListRequest.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ if (com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.GetCustomerListResponse.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.GetCustomerListResponse.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ if (com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.SuccessResponse.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.SuccessResponse.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ if (com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.MoveAllUsersToCustomerRequest.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.MoveAllUsersToCustomerRequest.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ if (com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.AddUserToCustomerRequest.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.AddUserToCustomerRequest.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ if (com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.DeleteCustomerRequest.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.DeleteCustomerRequest.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ if (com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.CreateCustomerRequest.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.CreateCustomerRequest.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ if (com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.CreateCustomerResponse.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.CreateCustomerResponse.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ if (com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.MoveUserToCustomerRequest.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.MoveUserToCustomerRequest.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ if (com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.UpdateCustomerRequest.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.UpdateCustomerRequest.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ if (com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.GetCustomerRequest.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.GetCustomerRequest.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ if (com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.GetCustomerResponse.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.GetCustomerResponse.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ if (com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.RemoveUserFromCustomerRequest.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.CustomerServiceStub.RemoveUserFromCustomerRequest.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ } catch (java.lang.Exception e) {
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+ return null;
+ }
+
+
+
+
+ }
+
\ No newline at end of file
diff --git a/src/main/java/com/frentix/olat/vitero/manager/stubs/GroupServiceCallbackHandler.java b/src/main/java/com/frentix/olat/vitero/manager/stubs/GroupServiceCallbackHandler.java
new file mode 100644
index 0000000000000000000000000000000000000000..53f39080dcc993edaa3a687c7bd3328cdcd9df15
--- /dev/null
+++ b/src/main/java/com/frentix/olat/vitero/manager/stubs/GroupServiceCallbackHandler.java
@@ -0,0 +1,126 @@
+
+/**
+ * GroupServiceCallbackHandler.java
+ *
+ * This file was auto-generated from WSDL
+ * by the Apache Axis2 version: 1.4.1 Built on : Aug 13, 2008 (05:03:35 LKT)
+ */
+
+ package com.frentix.olat.vitero.manager.stubs;
+
+ /**
+ * GroupServiceCallbackHandler Callback class, Users can extend this class and implement
+ * their own receiveResult and receiveError methods.
+ */
+ public abstract class GroupServiceCallbackHandler{
+
+
+
+ protected Object clientData;
+
+ /**
+ * User can pass in any object that needs to be accessed once the NonBlocking
+ * Web service call is finished and appropriate method of this CallBack is called.
+ * @param clientData Object mechanism by which the user can pass in user data
+ * that will be avilable at the time this callback is called.
+ */
+ public GroupServiceCallbackHandler(Object clientData){
+ this.clientData = clientData;
+ }
+
+ /**
+ * Please use this constructor if you don't want to set any clientData
+ */
+ public GroupServiceCallbackHandler(){
+ this.clientData = null;
+ }
+
+ /**
+ * Get the client data
+ */
+
+ public Object getClientData() {
+ return clientData;
+ }
+
+
+ // No methods generated for meps other than in-out
+
+ /**
+ * auto generated Axis2 call back method for getGroupListByCustomer method
+ * override this method for handling normal response from getGroupListByCustomer operation
+ */
+ public void receiveResultgetGroupListByCustomer(
+ com.frentix.olat.vitero.manager.stubs.GroupServiceStub.GetGroupListByCustomerResponse result
+ ) {
+ }
+
+ /**
+ * auto generated Axis2 Error handler
+ * override this method for handling error response from getGroupListByCustomer operation
+ */
+ public void receiveErrorgetGroupListByCustomer(java.lang.Exception e) {
+ }
+
+ /**
+ * auto generated Axis2 call back method for getGroupByName method
+ * override this method for handling normal response from getGroupByName operation
+ */
+ public void receiveResultgetGroupByName(
+ com.frentix.olat.vitero.manager.stubs.GroupServiceStub.GetGroupByNameResponse result
+ ) {
+ }
+
+ /**
+ * auto generated Axis2 Error handler
+ * override this method for handling error response from getGroupByName operation
+ */
+ public void receiveErrorgetGroupByName(java.lang.Exception e) {
+ }
+
+ // No methods generated for meps other than in-out
+
+ // No methods generated for meps other than in-out
+
+ // No methods generated for meps other than in-out
+
+ // No methods generated for meps other than in-out
+
+ // No methods generated for meps other than in-out
+
+ /**
+ * auto generated Axis2 call back method for getGroup method
+ * override this method for handling normal response from getGroup operation
+ */
+ public void receiveResultgetGroup(
+ com.frentix.olat.vitero.manager.stubs.GroupServiceStub.GetGroupResponse result
+ ) {
+ }
+
+ /**
+ * auto generated Axis2 Error handler
+ * override this method for handling error response from getGroup operation
+ */
+ public void receiveErrorgetGroup(java.lang.Exception e) {
+ }
+
+ /**
+ * auto generated Axis2 call back method for createGroup method
+ * override this method for handling normal response from createGroup operation
+ */
+ public void receiveResultcreateGroup(
+ com.frentix.olat.vitero.manager.stubs.GroupServiceStub.CreateGroupResponse result
+ ) {
+ }
+
+ /**
+ * auto generated Axis2 Error handler
+ * override this method for handling error response from createGroup operation
+ */
+ public void receiveErrorcreateGroup(java.lang.Exception e) {
+ }
+
+
+
+ }
+
\ No newline at end of file
diff --git a/src/main/java/com/frentix/olat/vitero/manager/stubs/GroupServiceStub.java b/src/main/java/com/frentix/olat/vitero/manager/stubs/GroupServiceStub.java
new file mode 100644
index 0000000000000000000000000000000000000000..9260b86bff7600778ab96e561a123862b73086fb
--- /dev/null
+++ b/src/main/java/com/frentix/olat/vitero/manager/stubs/GroupServiceStub.java
@@ -0,0 +1,12491 @@
+
+/**
+ * GroupServiceStub.java
+ *
+ * This file was auto-generated from WSDL
+ * by the Apache Axis2 version: 1.4.1 Built on : Aug 13, 2008 (05:03:35 LKT)
+ */
+ package com.frentix.olat.vitero.manager.stubs;
+
+
+
+ /*
+ * GroupServiceStub java implementation
+ */
+
+
+ public class GroupServiceStub extends org.apache.axis2.client.Stub
+ {
+ protected org.apache.axis2.description.AxisOperation[] _operations;
+
+ //hashmaps to keep the fault mapping
+ private java.util.HashMap faultExceptionNameMap = new java.util.HashMap();
+ private java.util.HashMap faultExceptionClassNameMap = new java.util.HashMap();
+ private java.util.HashMap faultMessageMap = new java.util.HashMap();
+
+ private static int counter = 0;
+
+ private static synchronized String getUniqueSuffix(){
+ // reset the counter if it is greater than 99999
+ if (counter > 99999){
+ counter = 0;
+ }
+ counter = counter + 1;
+ return Long.toString(System.currentTimeMillis()) + "_" + counter;
+ }
+
+
+ private void populateAxisService() throws org.apache.axis2.AxisFault {
+
+ //creating the Service with a unique name
+ _service = new org.apache.axis2.description.AxisService("GroupService" + getUniqueSuffix());
+ addAnonymousOperations();
+
+ //creating the operations
+ org.apache.axis2.description.AxisOperation __operation;
+
+ _operations = new org.apache.axis2.description.AxisOperation[10];
+
+ __operation = new org.apache.axis2.description.OutOnlyAxisOperation();
+
+
+ __operation.setName(new javax.xml.namespace.QName("http://www.vitero.de/schema/group", "addUserToGroup"));
+ _service.addOperation(__operation);
+
+
+
+
+ _operations[0]=__operation;
+
+
+ __operation = new org.apache.axis2.description.OutInAxisOperation();
+
+
+ __operation.setName(new javax.xml.namespace.QName("http://www.vitero.de/schema/group", "getGroupListByCustomer"));
+ _service.addOperation(__operation);
+
+
+
+
+ _operations[1]=__operation;
+
+
+ __operation = new org.apache.axis2.description.OutInAxisOperation();
+
+
+ __operation.setName(new javax.xml.namespace.QName("http://www.vitero.de/schema/group", "getGroupByName"));
+ _service.addOperation(__operation);
+
+
+
+
+ _operations[2]=__operation;
+
+
+ __operation = new org.apache.axis2.description.OutInAxisOperation();
+
+
+ __operation.setName(new javax.xml.namespace.QName("http://www.vitero.de/schema/group", "success"));
+ _service.addOperation(__operation);
+
+
+
+
+ _operations[3]=__operation;
+
+
+ __operation = new org.apache.axis2.description.OutOnlyAxisOperation();
+
+
+ __operation.setName(new javax.xml.namespace.QName("http://www.vitero.de/schema/group", "deleteGroup"));
+ _service.addOperation(__operation);
+
+
+
+
+ _operations[4]=__operation;
+
+
+ __operation = new org.apache.axis2.description.OutOnlyAxisOperation();
+
+
+ __operation.setName(new javax.xml.namespace.QName("http://www.vitero.de/schema/group", "updateGroup"));
+ _service.addOperation(__operation);
+
+
+
+
+ _operations[5]=__operation;
+
+
+ __operation = new org.apache.axis2.description.OutOnlyAxisOperation();
+
+
+ __operation.setName(new javax.xml.namespace.QName("http://www.vitero.de/schema/group", "removeUserFromGroup"));
+ _service.addOperation(__operation);
+
+
+
+
+ _operations[6]=__operation;
+
+
+ __operation = new org.apache.axis2.description.OutOnlyAxisOperation();
+
+
+ __operation.setName(new javax.xml.namespace.QName("http://www.vitero.de/schema/group", "changeGroupRole"));
+ _service.addOperation(__operation);
+
+
+
+
+ _operations[7]=__operation;
+
+
+ __operation = new org.apache.axis2.description.OutInAxisOperation();
+
+
+ __operation.setName(new javax.xml.namespace.QName("http://www.vitero.de/schema/group", "getGroup"));
+ _service.addOperation(__operation);
+
+
+
+
+ _operations[8]=__operation;
+
+
+ __operation = new org.apache.axis2.description.OutInAxisOperation();
+
+
+ __operation.setName(new javax.xml.namespace.QName("http://www.vitero.de/schema/group", "createGroup"));
+ _service.addOperation(__operation);
+
+
+
+
+ _operations[9]=__operation;
+
+
+ }
+
+ //populates the faults
+ private void populateFaults(){
+
+
+
+ }
+
+ /**
+ *Constructor that takes in a configContext
+ */
+
+ public GroupServiceStub(org.apache.axis2.context.ConfigurationContext configurationContext,
+ java.lang.String targetEndpoint)
+ throws org.apache.axis2.AxisFault {
+ this(configurationContext,targetEndpoint,false);
+ }
+
+
+ /**
+ * Constructor that takes in a configContext and useseperate listner
+ */
+ public GroupServiceStub(org.apache.axis2.context.ConfigurationContext configurationContext,
+ java.lang.String targetEndpoint, boolean useSeparateListener)
+ throws org.apache.axis2.AxisFault {
+ //To populate AxisService
+ populateAxisService();
+ populateFaults();
+
+ _serviceClient = new org.apache.axis2.client.ServiceClient(configurationContext,_service);
+
+
+ configurationContext = _serviceClient.getServiceContext().getConfigurationContext();
+
+ _serviceClient.getOptions().setTo(new org.apache.axis2.addressing.EndpointReference(
+ targetEndpoint));
+ _serviceClient.getOptions().setUseSeparateListener(useSeparateListener);
+
+
+ }
+
+ /**
+ * Default Constructor
+ */
+ public GroupServiceStub(org.apache.axis2.context.ConfigurationContext configurationContext) throws org.apache.axis2.AxisFault {
+
+ this(configurationContext,"http://192.168.1.54:8080/vitero/services/" );
+
+ }
+
+ /**
+ * Default Constructor
+ */
+ public GroupServiceStub() throws org.apache.axis2.AxisFault {
+
+ this("http://192.168.1.54:8080/vitero/services/" );
+
+ }
+
+ /**
+ * Constructor taking the target endpoint
+ */
+ public GroupServiceStub(java.lang.String targetEndpoint) throws org.apache.axis2.AxisFault {
+ this(null,targetEndpoint);
+ }
+
+
+
+
+
+ /**
+ * Auto generated method signature
+ *
+ */
+ public void addUserToGroup(
+ com.frentix.olat.vitero.manager.stubs.GroupServiceStub.AddUserToGroupRequest addUserToGroupRequest0
+
+ ) throws java.rmi.RemoteException
+
+
+ {
+ org.apache.axis2.context.MessageContext _messageContext = null;
+
+
+ org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[0].getName());
+ _operationClient.getOptions().setAction("\"\"");
+ _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true);
+
+
+
+ addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&");
+
+ org.apache.axiom.soap.SOAPEnvelope env = null;
+ _messageContext = new org.apache.axis2.context.MessageContext();
+
+
+ //Style is Doc.
+
+
+ env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()),
+ addUserToGroupRequest0,
+ optimizeContent(new javax.xml.namespace.QName("http://www.vitero.de/schema/group",
+ "addUserToGroup")));
+
+
+ //adding SOAP soap_headers
+ _serviceClient.addHeadersToEnvelope(env);
+ // create message context with that soap envelope
+
+ _messageContext.setEnvelope(env);
+
+ // add the message contxt to the operation client
+ _operationClient.addMessageContext(_messageContext);
+
+ _operationClient.execute(true);
+
+
+ _messageContext.getTransportOut().getSender().cleanup(_messageContext);
+
+ return;
+ }
+
+ /**
+ * Auto generated method signature
+ *
+ * @see com.frentix.olat.vc.provider.vitero.stubs.GroupService#getGroupListByCustomer
+ * @param getGroupListByCustomerRequest1
+
+ */
+
+
+
+ public com.frentix.olat.vitero.manager.stubs.GroupServiceStub.GetGroupListByCustomerResponse getGroupListByCustomer(
+
+ com.frentix.olat.vitero.manager.stubs.GroupServiceStub.GetGroupListByCustomerRequest getGroupListByCustomerRequest1)
+
+
+ throws java.rmi.RemoteException
+
+ {
+ org.apache.axis2.context.MessageContext _messageContext = null;
+ try{
+ org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[1].getName());
+ _operationClient.getOptions().setAction("\"\"");
+ _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true);
+
+
+
+ addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&");
+
+
+ // create a message context
+ _messageContext = new org.apache.axis2.context.MessageContext();
+
+
+
+ // create SOAP envelope with that payload
+ org.apache.axiom.soap.SOAPEnvelope env = null;
+
+
+ env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()),
+ getGroupListByCustomerRequest1,
+ optimizeContent(new javax.xml.namespace.QName("http://www.vitero.de/schema/group",
+ "getGroupListByCustomer")));
+
+ //adding SOAP soap_headers
+ _serviceClient.addHeadersToEnvelope(env);
+ // set the message context with that soap envelope
+ _messageContext.setEnvelope(env);
+
+ // add the message contxt to the operation client
+ _operationClient.addMessageContext(_messageContext);
+
+ //execute the operation client
+ _operationClient.execute(true);
+
+
+ org.apache.axis2.context.MessageContext _returnMessageContext = _operationClient.getMessageContext(
+ org.apache.axis2.wsdl.WSDLConstants.MESSAGE_LABEL_IN_VALUE);
+ org.apache.axiom.soap.SOAPEnvelope _returnEnv = _returnMessageContext.getEnvelope();
+
+
+ java.lang.Object object = fromOM(
+ _returnEnv.getBody().getFirstElement() ,
+ com.frentix.olat.vitero.manager.stubs.GroupServiceStub.GetGroupListByCustomerResponse.class,
+ getEnvelopeNamespaces(_returnEnv));
+
+
+ return (com.frentix.olat.vitero.manager.stubs.GroupServiceStub.GetGroupListByCustomerResponse)object;
+
+ }catch(org.apache.axis2.AxisFault f){
+
+ org.apache.axiom.om.OMElement faultElt = f.getDetail();
+ if (faultElt!=null){
+ if (faultExceptionNameMap.containsKey(faultElt.getQName())){
+ //make the fault by reflection
+ try{
+ java.lang.String exceptionClassName = (java.lang.String)faultExceptionClassNameMap.get(faultElt.getQName());
+ java.lang.Class exceptionClass = java.lang.Class.forName(exceptionClassName);
+ java.lang.Exception ex=
+ (java.lang.Exception) exceptionClass.newInstance();
+ //message class
+ java.lang.String messageClassName = (java.lang.String)faultMessageMap.get(faultElt.getQName());
+ java.lang.Class messageClass = java.lang.Class.forName(messageClassName);
+ java.lang.Object messageObject = fromOM(faultElt,messageClass,null);
+ java.lang.reflect.Method m = exceptionClass.getMethod("setFaultMessage",
+ new java.lang.Class[]{messageClass});
+ m.invoke(ex,new java.lang.Object[]{messageObject});
+
+
+ throw new java.rmi.RemoteException(ex.getMessage(), ex);
+ }catch(java.lang.ClassCastException e){
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.ClassNotFoundException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ }catch (java.lang.NoSuchMethodException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.reflect.InvocationTargetException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.IllegalAccessException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.InstantiationException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ }
+ }else{
+ throw f;
+ }
+ }else{
+ throw f;
+ }
+ } finally {
+ _messageContext.getTransportOut().getSender().cleanup(_messageContext);
+ }
+ }
+
+ /**
+ * Auto generated method signature for Asynchronous Invocations
+ *
+ * @see com.frentix.olat.vc.provider.vitero.stubs.GroupService#startgetGroupListByCustomer
+ * @param getGroupListByCustomerRequest1
+
+ */
+ public void startgetGroupListByCustomer(
+
+ com.frentix.olat.vitero.manager.stubs.GroupServiceStub.GetGroupListByCustomerRequest getGroupListByCustomerRequest1,
+
+ final com.frentix.olat.vitero.manager.stubs.GroupServiceCallbackHandler callback)
+
+ throws java.rmi.RemoteException{
+
+ org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[1].getName());
+ _operationClient.getOptions().setAction("\"\"");
+ _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true);
+
+
+
+ addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&");
+
+
+
+ // create SOAP envelope with that payload
+ org.apache.axiom.soap.SOAPEnvelope env=null;
+ final org.apache.axis2.context.MessageContext _messageContext = new org.apache.axis2.context.MessageContext();
+
+
+ //Style is Doc.
+
+
+ env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()),
+ getGroupListByCustomerRequest1,
+ optimizeContent(new javax.xml.namespace.QName("http://www.vitero.de/schema/group",
+ "getGroupListByCustomer")));
+
+ // adding SOAP soap_headers
+ _serviceClient.addHeadersToEnvelope(env);
+ // create message context with that soap envelope
+ _messageContext.setEnvelope(env);
+
+ // add the message context to the operation client
+ _operationClient.addMessageContext(_messageContext);
+
+
+
+ _operationClient.setCallback(new org.apache.axis2.client.async.AxisCallback() {
+ public void onMessage(org.apache.axis2.context.MessageContext resultContext) {
+ try {
+ org.apache.axiom.soap.SOAPEnvelope resultEnv = resultContext.getEnvelope();
+
+ java.lang.Object object = fromOM(resultEnv.getBody().getFirstElement(),
+ com.frentix.olat.vitero.manager.stubs.GroupServiceStub.GetGroupListByCustomerResponse.class,
+ getEnvelopeNamespaces(resultEnv));
+ callback.receiveResultgetGroupListByCustomer(
+ (com.frentix.olat.vitero.manager.stubs.GroupServiceStub.GetGroupListByCustomerResponse)object);
+
+ } catch (org.apache.axis2.AxisFault e) {
+ callback.receiveErrorgetGroupListByCustomer(e);
+ }
+ }
+
+ public void onError(java.lang.Exception error) {
+ if (error instanceof org.apache.axis2.AxisFault) {
+ org.apache.axis2.AxisFault f = (org.apache.axis2.AxisFault) error;
+ org.apache.axiom.om.OMElement faultElt = f.getDetail();
+ if (faultElt!=null){
+ if (faultExceptionNameMap.containsKey(faultElt.getQName())){
+ //make the fault by reflection
+ try{
+ java.lang.String exceptionClassName = (java.lang.String)faultExceptionClassNameMap.get(faultElt.getQName());
+ java.lang.Class exceptionClass = java.lang.Class.forName(exceptionClassName);
+ java.lang.Exception ex=
+ (java.lang.Exception) exceptionClass.newInstance();
+ //message class
+ java.lang.String messageClassName = (java.lang.String)faultMessageMap.get(faultElt.getQName());
+ java.lang.Class messageClass = java.lang.Class.forName(messageClassName);
+ java.lang.Object messageObject = fromOM(faultElt,messageClass,null);
+ java.lang.reflect.Method m = exceptionClass.getMethod("setFaultMessage",
+ new java.lang.Class[]{messageClass});
+ m.invoke(ex,new java.lang.Object[]{messageObject});
+
+
+ callback.receiveErrorgetGroupListByCustomer(new java.rmi.RemoteException(ex.getMessage(), ex));
+ } catch(java.lang.ClassCastException e){
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetGroupListByCustomer(f);
+ } catch (java.lang.ClassNotFoundException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetGroupListByCustomer(f);
+ } catch (java.lang.NoSuchMethodException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetGroupListByCustomer(f);
+ } catch (java.lang.reflect.InvocationTargetException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetGroupListByCustomer(f);
+ } catch (java.lang.IllegalAccessException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetGroupListByCustomer(f);
+ } catch (java.lang.InstantiationException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetGroupListByCustomer(f);
+ } catch (org.apache.axis2.AxisFault e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetGroupListByCustomer(f);
+ }
+ } else {
+ callback.receiveErrorgetGroupListByCustomer(f);
+ }
+ } else {
+ callback.receiveErrorgetGroupListByCustomer(f);
+ }
+ } else {
+ callback.receiveErrorgetGroupListByCustomer(error);
+ }
+ }
+
+ public void onFault(org.apache.axis2.context.MessageContext faultContext) {
+ org.apache.axis2.AxisFault fault = org.apache.axis2.util.Utils.getInboundFaultFromMessageContext(faultContext);
+ onError(fault);
+ }
+
+ public void onComplete() {
+ try {
+ _messageContext.getTransportOut().getSender().cleanup(_messageContext);
+ } catch (org.apache.axis2.AxisFault axisFault) {
+ callback.receiveErrorgetGroupListByCustomer(axisFault);
+ }
+ }
+ });
+
+
+ org.apache.axis2.util.CallbackReceiver _callbackReceiver = null;
+ if ( _operations[1].getMessageReceiver()==null && _operationClient.getOptions().isUseSeparateListener()) {
+ _callbackReceiver = new org.apache.axis2.util.CallbackReceiver();
+ _operations[1].setMessageReceiver(
+ _callbackReceiver);
+ }
+
+ //execute the operation client
+ _operationClient.execute(false);
+
+ }
+
+ /**
+ * Auto generated method signature
+ *
+ * @see com.frentix.olat.vc.provider.vitero.stubs.GroupService#getGroupByName
+ * @param getGroupByNameRequest3
+
+ */
+
+
+
+ public com.frentix.olat.vitero.manager.stubs.GroupServiceStub.GetGroupByNameResponse getGroupByName(
+
+ com.frentix.olat.vitero.manager.stubs.GroupServiceStub.GetGroupByNameRequest getGroupByNameRequest3)
+
+
+ throws java.rmi.RemoteException
+
+ {
+ org.apache.axis2.context.MessageContext _messageContext = null;
+ try{
+ org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[2].getName());
+ _operationClient.getOptions().setAction("\"\"");
+ _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true);
+
+
+
+ addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&");
+
+
+ // create a message context
+ _messageContext = new org.apache.axis2.context.MessageContext();
+
+
+
+ // create SOAP envelope with that payload
+ org.apache.axiom.soap.SOAPEnvelope env = null;
+
+
+ env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()),
+ getGroupByNameRequest3,
+ optimizeContent(new javax.xml.namespace.QName("http://www.vitero.de/schema/group",
+ "getGroupByName")));
+
+ //adding SOAP soap_headers
+ _serviceClient.addHeadersToEnvelope(env);
+ // set the message context with that soap envelope
+ _messageContext.setEnvelope(env);
+
+ // add the message contxt to the operation client
+ _operationClient.addMessageContext(_messageContext);
+
+ //execute the operation client
+ _operationClient.execute(true);
+
+
+ org.apache.axis2.context.MessageContext _returnMessageContext = _operationClient.getMessageContext(
+ org.apache.axis2.wsdl.WSDLConstants.MESSAGE_LABEL_IN_VALUE);
+ org.apache.axiom.soap.SOAPEnvelope _returnEnv = _returnMessageContext.getEnvelope();
+
+
+ java.lang.Object object = fromOM(
+ _returnEnv.getBody().getFirstElement() ,
+ com.frentix.olat.vitero.manager.stubs.GroupServiceStub.GetGroupByNameResponse.class,
+ getEnvelopeNamespaces(_returnEnv));
+
+
+ return (com.frentix.olat.vitero.manager.stubs.GroupServiceStub.GetGroupByNameResponse)object;
+
+ }catch(org.apache.axis2.AxisFault f){
+
+ org.apache.axiom.om.OMElement faultElt = f.getDetail();
+ if (faultElt!=null){
+ if (faultExceptionNameMap.containsKey(faultElt.getQName())){
+ //make the fault by reflection
+ try{
+ java.lang.String exceptionClassName = (java.lang.String)faultExceptionClassNameMap.get(faultElt.getQName());
+ java.lang.Class exceptionClass = java.lang.Class.forName(exceptionClassName);
+ java.lang.Exception ex=
+ (java.lang.Exception) exceptionClass.newInstance();
+ //message class
+ java.lang.String messageClassName = (java.lang.String)faultMessageMap.get(faultElt.getQName());
+ java.lang.Class messageClass = java.lang.Class.forName(messageClassName);
+ java.lang.Object messageObject = fromOM(faultElt,messageClass,null);
+ java.lang.reflect.Method m = exceptionClass.getMethod("setFaultMessage",
+ new java.lang.Class[]{messageClass});
+ m.invoke(ex,new java.lang.Object[]{messageObject});
+
+
+ throw new java.rmi.RemoteException(ex.getMessage(), ex);
+ }catch(java.lang.ClassCastException e){
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.ClassNotFoundException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ }catch (java.lang.NoSuchMethodException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.reflect.InvocationTargetException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.IllegalAccessException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.InstantiationException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ }
+ }else{
+ throw f;
+ }
+ }else{
+ throw f;
+ }
+ } finally {
+ _messageContext.getTransportOut().getSender().cleanup(_messageContext);
+ }
+ }
+
+ /**
+ * Auto generated method signature for Asynchronous Invocations
+ *
+ * @see com.frentix.olat.vc.provider.vitero.stubs.GroupService#startgetGroupByName
+ * @param getGroupByNameRequest3
+
+ */
+ public void startgetGroupByName(
+
+ com.frentix.olat.vitero.manager.stubs.GroupServiceStub.GetGroupByNameRequest getGroupByNameRequest3,
+
+ final com.frentix.olat.vitero.manager.stubs.GroupServiceCallbackHandler callback)
+
+ throws java.rmi.RemoteException{
+
+ org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[2].getName());
+ _operationClient.getOptions().setAction("\"\"");
+ _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true);
+
+
+
+ addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&");
+
+
+
+ // create SOAP envelope with that payload
+ org.apache.axiom.soap.SOAPEnvelope env=null;
+ final org.apache.axis2.context.MessageContext _messageContext = new org.apache.axis2.context.MessageContext();
+
+
+ //Style is Doc.
+
+
+ env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()),
+ getGroupByNameRequest3,
+ optimizeContent(new javax.xml.namespace.QName("http://www.vitero.de/schema/group",
+ "getGroupByName")));
+
+ // adding SOAP soap_headers
+ _serviceClient.addHeadersToEnvelope(env);
+ // create message context with that soap envelope
+ _messageContext.setEnvelope(env);
+
+ // add the message context to the operation client
+ _operationClient.addMessageContext(_messageContext);
+
+
+
+ _operationClient.setCallback(new org.apache.axis2.client.async.AxisCallback() {
+ public void onMessage(org.apache.axis2.context.MessageContext resultContext) {
+ try {
+ org.apache.axiom.soap.SOAPEnvelope resultEnv = resultContext.getEnvelope();
+
+ java.lang.Object object = fromOM(resultEnv.getBody().getFirstElement(),
+ com.frentix.olat.vitero.manager.stubs.GroupServiceStub.GetGroupByNameResponse.class,
+ getEnvelopeNamespaces(resultEnv));
+ callback.receiveResultgetGroupByName(
+ (com.frentix.olat.vitero.manager.stubs.GroupServiceStub.GetGroupByNameResponse)object);
+
+ } catch (org.apache.axis2.AxisFault e) {
+ callback.receiveErrorgetGroupByName(e);
+ }
+ }
+
+ public void onError(java.lang.Exception error) {
+ if (error instanceof org.apache.axis2.AxisFault) {
+ org.apache.axis2.AxisFault f = (org.apache.axis2.AxisFault) error;
+ org.apache.axiom.om.OMElement faultElt = f.getDetail();
+ if (faultElt!=null){
+ if (faultExceptionNameMap.containsKey(faultElt.getQName())){
+ //make the fault by reflection
+ try{
+ java.lang.String exceptionClassName = (java.lang.String)faultExceptionClassNameMap.get(faultElt.getQName());
+ java.lang.Class exceptionClass = java.lang.Class.forName(exceptionClassName);
+ java.lang.Exception ex=
+ (java.lang.Exception) exceptionClass.newInstance();
+ //message class
+ java.lang.String messageClassName = (java.lang.String)faultMessageMap.get(faultElt.getQName());
+ java.lang.Class messageClass = java.lang.Class.forName(messageClassName);
+ java.lang.Object messageObject = fromOM(faultElt,messageClass,null);
+ java.lang.reflect.Method m = exceptionClass.getMethod("setFaultMessage",
+ new java.lang.Class[]{messageClass});
+ m.invoke(ex,new java.lang.Object[]{messageObject});
+
+
+ callback.receiveErrorgetGroupByName(new java.rmi.RemoteException(ex.getMessage(), ex));
+ } catch(java.lang.ClassCastException e){
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetGroupByName(f);
+ } catch (java.lang.ClassNotFoundException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetGroupByName(f);
+ } catch (java.lang.NoSuchMethodException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetGroupByName(f);
+ } catch (java.lang.reflect.InvocationTargetException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetGroupByName(f);
+ } catch (java.lang.IllegalAccessException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetGroupByName(f);
+ } catch (java.lang.InstantiationException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetGroupByName(f);
+ } catch (org.apache.axis2.AxisFault e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetGroupByName(f);
+ }
+ } else {
+ callback.receiveErrorgetGroupByName(f);
+ }
+ } else {
+ callback.receiveErrorgetGroupByName(f);
+ }
+ } else {
+ callback.receiveErrorgetGroupByName(error);
+ }
+ }
+
+ public void onFault(org.apache.axis2.context.MessageContext faultContext) {
+ org.apache.axis2.AxisFault fault = org.apache.axis2.util.Utils.getInboundFaultFromMessageContext(faultContext);
+ onError(fault);
+ }
+
+ public void onComplete() {
+ try {
+ _messageContext.getTransportOut().getSender().cleanup(_messageContext);
+ } catch (org.apache.axis2.AxisFault axisFault) {
+ callback.receiveErrorgetGroupByName(axisFault);
+ }
+ }
+ });
+
+
+ org.apache.axis2.util.CallbackReceiver _callbackReceiver = null;
+ if ( _operations[2].getMessageReceiver()==null && _operationClient.getOptions().isUseSeparateListener()) {
+ _callbackReceiver = new org.apache.axis2.util.CallbackReceiver();
+ _operations[2].setMessageReceiver(
+ _callbackReceiver);
+ }
+
+ //execute the operation client
+ _operationClient.execute(false);
+
+ }
+
+
+ /**
+ * Auto generated method signature
+ *
+ */
+ public void deleteGroup(
+ com.frentix.olat.vitero.manager.stubs.GroupServiceStub.DeleteGroupRequest deleteGroupRequest6
+
+ ) throws java.rmi.RemoteException
+
+
+ {
+ org.apache.axis2.context.MessageContext _messageContext = null;
+
+
+ org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[4].getName());
+ _operationClient.getOptions().setAction("\"\"");
+ _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true);
+
+
+
+ addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&");
+
+ org.apache.axiom.soap.SOAPEnvelope env = null;
+ _messageContext = new org.apache.axis2.context.MessageContext();
+
+
+ //Style is Doc.
+
+
+ env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()),
+ deleteGroupRequest6,
+ optimizeContent(new javax.xml.namespace.QName("http://www.vitero.de/schema/group",
+ "deleteGroup")));
+
+
+ //adding SOAP soap_headers
+ _serviceClient.addHeadersToEnvelope(env);
+ // create message context with that soap envelope
+
+ _messageContext.setEnvelope(env);
+
+ // add the message contxt to the operation client
+ _operationClient.addMessageContext(_messageContext);
+
+ _operationClient.execute(true);
+
+
+ _messageContext.getTransportOut().getSender().cleanup(_messageContext);
+
+ return;
+ }
+
+
+ /**
+ * Auto generated method signature
+ *
+ */
+ public void updateGroup(
+ com.frentix.olat.vitero.manager.stubs.GroupServiceStub.UpdateGroupRequest updateGroupRequest7
+
+ ) throws java.rmi.RemoteException
+
+
+ {
+ org.apache.axis2.context.MessageContext _messageContext = null;
+
+
+ org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[5].getName());
+ _operationClient.getOptions().setAction("\"\"");
+ _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true);
+
+
+
+ addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&");
+
+ org.apache.axiom.soap.SOAPEnvelope env = null;
+ _messageContext = new org.apache.axis2.context.MessageContext();
+
+
+ //Style is Doc.
+
+
+ env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()),
+ updateGroupRequest7,
+ optimizeContent(new javax.xml.namespace.QName("http://www.vitero.de/schema/group",
+ "updateGroup")));
+
+
+ //adding SOAP soap_headers
+ _serviceClient.addHeadersToEnvelope(env);
+ // create message context with that soap envelope
+
+ _messageContext.setEnvelope(env);
+
+ // add the message contxt to the operation client
+ _operationClient.addMessageContext(_messageContext);
+
+ _operationClient.execute(true);
+
+
+ _messageContext.getTransportOut().getSender().cleanup(_messageContext);
+
+ return;
+ }
+
+
+ /**
+ * Auto generated method signature
+ *
+ */
+ public void removeUserFromGroup(
+ com.frentix.olat.vitero.manager.stubs.GroupServiceStub.RemoveUserFromGroupRequest removeUserFromGroupRequest8
+
+ ) throws java.rmi.RemoteException
+
+
+ {
+ org.apache.axis2.context.MessageContext _messageContext = null;
+
+
+ org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[6].getName());
+ _operationClient.getOptions().setAction("\"\"");
+ _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true);
+
+
+
+ addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&");
+
+ org.apache.axiom.soap.SOAPEnvelope env = null;
+ _messageContext = new org.apache.axis2.context.MessageContext();
+
+
+ //Style is Doc.
+
+
+ env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()),
+ removeUserFromGroupRequest8,
+ optimizeContent(new javax.xml.namespace.QName("http://www.vitero.de/schema/group",
+ "removeUserFromGroup")));
+
+
+ //adding SOAP soap_headers
+ _serviceClient.addHeadersToEnvelope(env);
+ // create message context with that soap envelope
+
+ _messageContext.setEnvelope(env);
+
+ // add the message contxt to the operation client
+ _operationClient.addMessageContext(_messageContext);
+
+ _operationClient.execute(true);
+
+
+ _messageContext.getTransportOut().getSender().cleanup(_messageContext);
+
+ return;
+ }
+
+
+ /**
+ * Auto generated method signature
+ *
+ */
+ public void changeGroupRole(
+ com.frentix.olat.vitero.manager.stubs.GroupServiceStub.ChangeGroupRoleRequest changeGroupRoleRequest9
+
+ ) throws java.rmi.RemoteException
+
+
+ {
+ org.apache.axis2.context.MessageContext _messageContext = null;
+
+
+ org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[7].getName());
+ _operationClient.getOptions().setAction("\"\"");
+ _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true);
+
+
+
+ addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&");
+
+ org.apache.axiom.soap.SOAPEnvelope env = null;
+ _messageContext = new org.apache.axis2.context.MessageContext();
+
+
+ //Style is Doc.
+
+
+ env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()),
+ changeGroupRoleRequest9,
+ optimizeContent(new javax.xml.namespace.QName("http://www.vitero.de/schema/group",
+ "changeGroupRole")));
+
+
+ //adding SOAP soap_headers
+ _serviceClient.addHeadersToEnvelope(env);
+ // create message context with that soap envelope
+
+ _messageContext.setEnvelope(env);
+
+ // add the message contxt to the operation client
+ _operationClient.addMessageContext(_messageContext);
+
+ _operationClient.execute(true);
+
+
+ _messageContext.getTransportOut().getSender().cleanup(_messageContext);
+
+ return;
+ }
+
+ /**
+ * Auto generated method signature
+ *
+ * @see com.frentix.olat.vc.provider.vitero.stubs.GroupService#getGroup
+ * @param getGroupRequest10
+
+ */
+
+
+
+ public com.frentix.olat.vitero.manager.stubs.GroupServiceStub.GetGroupResponse getGroup(
+
+ com.frentix.olat.vitero.manager.stubs.GroupServiceStub.GetGroupRequest getGroupRequest10)
+
+
+ throws java.rmi.RemoteException
+
+ {
+ org.apache.axis2.context.MessageContext _messageContext = null;
+ try{
+ org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[8].getName());
+ _operationClient.getOptions().setAction("\"\"");
+ _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true);
+
+
+
+ addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&");
+
+
+ // create a message context
+ _messageContext = new org.apache.axis2.context.MessageContext();
+
+
+
+ // create SOAP envelope with that payload
+ org.apache.axiom.soap.SOAPEnvelope env = null;
+
+
+ env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()),
+ getGroupRequest10,
+ optimizeContent(new javax.xml.namespace.QName("http://www.vitero.de/schema/group",
+ "getGroup")));
+
+ //adding SOAP soap_headers
+ _serviceClient.addHeadersToEnvelope(env);
+ // set the message context with that soap envelope
+ _messageContext.setEnvelope(env);
+
+ // add the message contxt to the operation client
+ _operationClient.addMessageContext(_messageContext);
+
+ //execute the operation client
+ _operationClient.execute(true);
+
+
+ org.apache.axis2.context.MessageContext _returnMessageContext = _operationClient.getMessageContext(
+ org.apache.axis2.wsdl.WSDLConstants.MESSAGE_LABEL_IN_VALUE);
+ org.apache.axiom.soap.SOAPEnvelope _returnEnv = _returnMessageContext.getEnvelope();
+
+
+ java.lang.Object object = fromOM(
+ _returnEnv.getBody().getFirstElement() ,
+ com.frentix.olat.vitero.manager.stubs.GroupServiceStub.GetGroupResponse.class,
+ getEnvelopeNamespaces(_returnEnv));
+
+
+ return (com.frentix.olat.vitero.manager.stubs.GroupServiceStub.GetGroupResponse)object;
+
+ }catch(org.apache.axis2.AxisFault f){
+
+ org.apache.axiom.om.OMElement faultElt = f.getDetail();
+ if (faultElt!=null){
+ if (faultExceptionNameMap.containsKey(faultElt.getQName())){
+ //make the fault by reflection
+ try{
+ java.lang.String exceptionClassName = (java.lang.String)faultExceptionClassNameMap.get(faultElt.getQName());
+ java.lang.Class exceptionClass = java.lang.Class.forName(exceptionClassName);
+ java.lang.Exception ex=
+ (java.lang.Exception) exceptionClass.newInstance();
+ //message class
+ java.lang.String messageClassName = (java.lang.String)faultMessageMap.get(faultElt.getQName());
+ java.lang.Class messageClass = java.lang.Class.forName(messageClassName);
+ java.lang.Object messageObject = fromOM(faultElt,messageClass,null);
+ java.lang.reflect.Method m = exceptionClass.getMethod("setFaultMessage",
+ new java.lang.Class[]{messageClass});
+ m.invoke(ex,new java.lang.Object[]{messageObject});
+
+
+ throw new java.rmi.RemoteException(ex.getMessage(), ex);
+ }catch(java.lang.ClassCastException e){
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.ClassNotFoundException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ }catch (java.lang.NoSuchMethodException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.reflect.InvocationTargetException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.IllegalAccessException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.InstantiationException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ }
+ }else{
+ throw f;
+ }
+ }else{
+ throw f;
+ }
+ } finally {
+ _messageContext.getTransportOut().getSender().cleanup(_messageContext);
+ }
+ }
+
+ /**
+ * Auto generated method signature for Asynchronous Invocations
+ *
+ * @see com.frentix.olat.vc.provider.vitero.stubs.GroupService#startgetGroup
+ * @param getGroupRequest10
+
+ */
+ public void startgetGroup(
+
+ com.frentix.olat.vitero.manager.stubs.GroupServiceStub.GetGroupRequest getGroupRequest10,
+
+ final com.frentix.olat.vitero.manager.stubs.GroupServiceCallbackHandler callback)
+
+ throws java.rmi.RemoteException{
+
+ org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[8].getName());
+ _operationClient.getOptions().setAction("\"\"");
+ _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true);
+
+
+
+ addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&");
+
+
+
+ // create SOAP envelope with that payload
+ org.apache.axiom.soap.SOAPEnvelope env=null;
+ final org.apache.axis2.context.MessageContext _messageContext = new org.apache.axis2.context.MessageContext();
+
+
+ //Style is Doc.
+
+
+ env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()),
+ getGroupRequest10,
+ optimizeContent(new javax.xml.namespace.QName("http://www.vitero.de/schema/group",
+ "getGroup")));
+
+ // adding SOAP soap_headers
+ _serviceClient.addHeadersToEnvelope(env);
+ // create message context with that soap envelope
+ _messageContext.setEnvelope(env);
+
+ // add the message context to the operation client
+ _operationClient.addMessageContext(_messageContext);
+
+
+
+ _operationClient.setCallback(new org.apache.axis2.client.async.AxisCallback() {
+ public void onMessage(org.apache.axis2.context.MessageContext resultContext) {
+ try {
+ org.apache.axiom.soap.SOAPEnvelope resultEnv = resultContext.getEnvelope();
+
+ java.lang.Object object = fromOM(resultEnv.getBody().getFirstElement(),
+ com.frentix.olat.vitero.manager.stubs.GroupServiceStub.GetGroupResponse.class,
+ getEnvelopeNamespaces(resultEnv));
+ callback.receiveResultgetGroup(
+ (com.frentix.olat.vitero.manager.stubs.GroupServiceStub.GetGroupResponse)object);
+
+ } catch (org.apache.axis2.AxisFault e) {
+ callback.receiveErrorgetGroup(e);
+ }
+ }
+
+ public void onError(java.lang.Exception error) {
+ if (error instanceof org.apache.axis2.AxisFault) {
+ org.apache.axis2.AxisFault f = (org.apache.axis2.AxisFault) error;
+ org.apache.axiom.om.OMElement faultElt = f.getDetail();
+ if (faultElt!=null){
+ if (faultExceptionNameMap.containsKey(faultElt.getQName())){
+ //make the fault by reflection
+ try{
+ java.lang.String exceptionClassName = (java.lang.String)faultExceptionClassNameMap.get(faultElt.getQName());
+ java.lang.Class exceptionClass = java.lang.Class.forName(exceptionClassName);
+ java.lang.Exception ex=
+ (java.lang.Exception) exceptionClass.newInstance();
+ //message class
+ java.lang.String messageClassName = (java.lang.String)faultMessageMap.get(faultElt.getQName());
+ java.lang.Class messageClass = java.lang.Class.forName(messageClassName);
+ java.lang.Object messageObject = fromOM(faultElt,messageClass,null);
+ java.lang.reflect.Method m = exceptionClass.getMethod("setFaultMessage",
+ new java.lang.Class[]{messageClass});
+ m.invoke(ex,new java.lang.Object[]{messageObject});
+
+
+ callback.receiveErrorgetGroup(new java.rmi.RemoteException(ex.getMessage(), ex));
+ } catch(java.lang.ClassCastException e){
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetGroup(f);
+ } catch (java.lang.ClassNotFoundException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetGroup(f);
+ } catch (java.lang.NoSuchMethodException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetGroup(f);
+ } catch (java.lang.reflect.InvocationTargetException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetGroup(f);
+ } catch (java.lang.IllegalAccessException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetGroup(f);
+ } catch (java.lang.InstantiationException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetGroup(f);
+ } catch (org.apache.axis2.AxisFault e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetGroup(f);
+ }
+ } else {
+ callback.receiveErrorgetGroup(f);
+ }
+ } else {
+ callback.receiveErrorgetGroup(f);
+ }
+ } else {
+ callback.receiveErrorgetGroup(error);
+ }
+ }
+
+ public void onFault(org.apache.axis2.context.MessageContext faultContext) {
+ org.apache.axis2.AxisFault fault = org.apache.axis2.util.Utils.getInboundFaultFromMessageContext(faultContext);
+ onError(fault);
+ }
+
+ public void onComplete() {
+ try {
+ _messageContext.getTransportOut().getSender().cleanup(_messageContext);
+ } catch (org.apache.axis2.AxisFault axisFault) {
+ callback.receiveErrorgetGroup(axisFault);
+ }
+ }
+ });
+
+
+ org.apache.axis2.util.CallbackReceiver _callbackReceiver = null;
+ if ( _operations[8].getMessageReceiver()==null && _operationClient.getOptions().isUseSeparateListener()) {
+ _callbackReceiver = new org.apache.axis2.util.CallbackReceiver();
+ _operations[8].setMessageReceiver(
+ _callbackReceiver);
+ }
+
+ //execute the operation client
+ _operationClient.execute(false);
+
+ }
+
+ /**
+ * Auto generated method signature
+ *
+ * @see com.frentix.olat.vc.provider.vitero.stubs.GroupService#createGroup
+ * @param createGroupRequest12
+
+ */
+
+
+
+ public com.frentix.olat.vitero.manager.stubs.GroupServiceStub.CreateGroupResponse createGroup(
+
+ com.frentix.olat.vitero.manager.stubs.GroupServiceStub.CreateGroupRequest createGroupRequest12)
+
+
+ throws java.rmi.RemoteException
+
+ {
+ org.apache.axis2.context.MessageContext _messageContext = null;
+ try{
+ org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[9].getName());
+ _operationClient.getOptions().setAction("\"\"");
+ _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true);
+
+
+
+ addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&");
+
+
+ // create a message context
+ _messageContext = new org.apache.axis2.context.MessageContext();
+
+
+
+ // create SOAP envelope with that payload
+ org.apache.axiom.soap.SOAPEnvelope env = null;
+
+
+ env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()),
+ createGroupRequest12,
+ optimizeContent(new javax.xml.namespace.QName("http://www.vitero.de/schema/group",
+ "createGroup")));
+
+ //adding SOAP soap_headers
+ _serviceClient.addHeadersToEnvelope(env);
+ // set the message context with that soap envelope
+ _messageContext.setEnvelope(env);
+
+ // add the message contxt to the operation client
+ _operationClient.addMessageContext(_messageContext);
+
+ //execute the operation client
+ _operationClient.execute(true);
+
+
+ org.apache.axis2.context.MessageContext _returnMessageContext = _operationClient.getMessageContext(
+ org.apache.axis2.wsdl.WSDLConstants.MESSAGE_LABEL_IN_VALUE);
+ org.apache.axiom.soap.SOAPEnvelope _returnEnv = _returnMessageContext.getEnvelope();
+
+
+ java.lang.Object object = fromOM(
+ _returnEnv.getBody().getFirstElement() ,
+ com.frentix.olat.vitero.manager.stubs.GroupServiceStub.CreateGroupResponse.class,
+ getEnvelopeNamespaces(_returnEnv));
+
+
+ return (com.frentix.olat.vitero.manager.stubs.GroupServiceStub.CreateGroupResponse)object;
+
+ }catch(org.apache.axis2.AxisFault f){
+
+ org.apache.axiom.om.OMElement faultElt = f.getDetail();
+ if (faultElt!=null){
+ if (faultExceptionNameMap.containsKey(faultElt.getQName())){
+ //make the fault by reflection
+ try{
+ java.lang.String exceptionClassName = (java.lang.String)faultExceptionClassNameMap.get(faultElt.getQName());
+ java.lang.Class exceptionClass = java.lang.Class.forName(exceptionClassName);
+ java.lang.Exception ex=
+ (java.lang.Exception) exceptionClass.newInstance();
+ //message class
+ java.lang.String messageClassName = (java.lang.String)faultMessageMap.get(faultElt.getQName());
+ java.lang.Class messageClass = java.lang.Class.forName(messageClassName);
+ java.lang.Object messageObject = fromOM(faultElt,messageClass,null);
+ java.lang.reflect.Method m = exceptionClass.getMethod("setFaultMessage",
+ new java.lang.Class[]{messageClass});
+ m.invoke(ex,new java.lang.Object[]{messageObject});
+
+
+ throw new java.rmi.RemoteException(ex.getMessage(), ex);
+ }catch(java.lang.ClassCastException e){
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.ClassNotFoundException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ }catch (java.lang.NoSuchMethodException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.reflect.InvocationTargetException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.IllegalAccessException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.InstantiationException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ }
+ }else{
+ throw f;
+ }
+ }else{
+ throw f;
+ }
+ } finally {
+ _messageContext.getTransportOut().getSender().cleanup(_messageContext);
+ }
+ }
+
+ /**
+ * Auto generated method signature for Asynchronous Invocations
+ *
+ * @see com.frentix.olat.vc.provider.vitero.stubs.GroupService#startcreateGroup
+ * @param createGroupRequest12
+
+ */
+ public void startcreateGroup(
+
+ com.frentix.olat.vitero.manager.stubs.GroupServiceStub.CreateGroupRequest createGroupRequest12,
+
+ final com.frentix.olat.vitero.manager.stubs.GroupServiceCallbackHandler callback)
+
+ throws java.rmi.RemoteException{
+
+ org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[9].getName());
+ _operationClient.getOptions().setAction("\"\"");
+ _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true);
+
+
+
+ addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&");
+
+
+
+ // create SOAP envelope with that payload
+ org.apache.axiom.soap.SOAPEnvelope env=null;
+ final org.apache.axis2.context.MessageContext _messageContext = new org.apache.axis2.context.MessageContext();
+
+
+ //Style is Doc.
+
+
+ env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()),
+ createGroupRequest12,
+ optimizeContent(new javax.xml.namespace.QName("http://www.vitero.de/schema/group",
+ "createGroup")));
+
+ // adding SOAP soap_headers
+ _serviceClient.addHeadersToEnvelope(env);
+ // create message context with that soap envelope
+ _messageContext.setEnvelope(env);
+
+ // add the message context to the operation client
+ _operationClient.addMessageContext(_messageContext);
+
+
+
+ _operationClient.setCallback(new org.apache.axis2.client.async.AxisCallback() {
+ public void onMessage(org.apache.axis2.context.MessageContext resultContext) {
+ try {
+ org.apache.axiom.soap.SOAPEnvelope resultEnv = resultContext.getEnvelope();
+
+ java.lang.Object object = fromOM(resultEnv.getBody().getFirstElement(),
+ com.frentix.olat.vitero.manager.stubs.GroupServiceStub.CreateGroupResponse.class,
+ getEnvelopeNamespaces(resultEnv));
+ callback.receiveResultcreateGroup(
+ (com.frentix.olat.vitero.manager.stubs.GroupServiceStub.CreateGroupResponse)object);
+
+ } catch (org.apache.axis2.AxisFault e) {
+ callback.receiveErrorcreateGroup(e);
+ }
+ }
+
+ public void onError(java.lang.Exception error) {
+ if (error instanceof org.apache.axis2.AxisFault) {
+ org.apache.axis2.AxisFault f = (org.apache.axis2.AxisFault) error;
+ org.apache.axiom.om.OMElement faultElt = f.getDetail();
+ if (faultElt!=null){
+ if (faultExceptionNameMap.containsKey(faultElt.getQName())){
+ //make the fault by reflection
+ try{
+ java.lang.String exceptionClassName = (java.lang.String)faultExceptionClassNameMap.get(faultElt.getQName());
+ java.lang.Class exceptionClass = java.lang.Class.forName(exceptionClassName);
+ java.lang.Exception ex=
+ (java.lang.Exception) exceptionClass.newInstance();
+ //message class
+ java.lang.String messageClassName = (java.lang.String)faultMessageMap.get(faultElt.getQName());
+ java.lang.Class messageClass = java.lang.Class.forName(messageClassName);
+ java.lang.Object messageObject = fromOM(faultElt,messageClass,null);
+ java.lang.reflect.Method m = exceptionClass.getMethod("setFaultMessage",
+ new java.lang.Class[]{messageClass});
+ m.invoke(ex,new java.lang.Object[]{messageObject});
+
+
+ callback.receiveErrorcreateGroup(new java.rmi.RemoteException(ex.getMessage(), ex));
+ } catch(java.lang.ClassCastException e){
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorcreateGroup(f);
+ } catch (java.lang.ClassNotFoundException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorcreateGroup(f);
+ } catch (java.lang.NoSuchMethodException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorcreateGroup(f);
+ } catch (java.lang.reflect.InvocationTargetException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorcreateGroup(f);
+ } catch (java.lang.IllegalAccessException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorcreateGroup(f);
+ } catch (java.lang.InstantiationException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorcreateGroup(f);
+ } catch (org.apache.axis2.AxisFault e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorcreateGroup(f);
+ }
+ } else {
+ callback.receiveErrorcreateGroup(f);
+ }
+ } else {
+ callback.receiveErrorcreateGroup(f);
+ }
+ } else {
+ callback.receiveErrorcreateGroup(error);
+ }
+ }
+
+ public void onFault(org.apache.axis2.context.MessageContext faultContext) {
+ org.apache.axis2.AxisFault fault = org.apache.axis2.util.Utils.getInboundFaultFromMessageContext(faultContext);
+ onError(fault);
+ }
+
+ public void onComplete() {
+ try {
+ _messageContext.getTransportOut().getSender().cleanup(_messageContext);
+ } catch (org.apache.axis2.AxisFault axisFault) {
+ callback.receiveErrorcreateGroup(axisFault);
+ }
+ }
+ });
+
+
+ org.apache.axis2.util.CallbackReceiver _callbackReceiver = null;
+ if ( _operations[9].getMessageReceiver()==null && _operationClient.getOptions().isUseSeparateListener()) {
+ _callbackReceiver = new org.apache.axis2.util.CallbackReceiver();
+ _operations[9].setMessageReceiver(
+ _callbackReceiver);
+ }
+
+ //execute the operation client
+ _operationClient.execute(false);
+
+ }
+
+
+
+ /**
+ * A utility method that copies the namepaces from the SOAPEnvelope
+ */
+ private java.util.Map getEnvelopeNamespaces(org.apache.axiom.soap.SOAPEnvelope env){
+ java.util.Map returnMap = new java.util.HashMap();
+ java.util.Iterator namespaceIterator = env.getAllDeclaredNamespaces();
+ while (namespaceIterator.hasNext()) {
+ org.apache.axiom.om.OMNamespace ns = (org.apache.axiom.om.OMNamespace) namespaceIterator.next();
+ returnMap.put(ns.getPrefix(),ns.getNamespaceURI());
+ }
+ return returnMap;
+ }
+
+
+
+ private javax.xml.namespace.QName[] opNameArray = null;
+ private boolean optimizeContent(javax.xml.namespace.QName opName) {
+
+
+ if (opNameArray == null) {
+ return false;
+ }
+ for (int i = 0; i < opNameArray.length; i++) {
+ if (opName.equals(opNameArray[i])) {
+ return true;
+ }
+ }
+ return false;
+ }
+ //http://192.168.1.54:8080/vitero/services/
+ public static class GetGroupByNameResponse
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/group",
+ "getGroupByNameResponse",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/group")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for GetGroupByNameResponse
+ */
+
+
+ protected Group localGetGroupByNameResponse ;
+
+
+ /**
+ * Auto generated getter method
+ * @return Group
+ */
+ public Group getGetGroupByNameResponse(){
+ return localGetGroupByNameResponse;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param GetGroupByNameResponse
+ */
+ public void setGetGroupByNameResponse(Group param){
+
+ this.localGetGroupByNameResponse=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ GetGroupByNameResponse.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+ //We can safely assume an element has only one type associated with it
+
+ if (localGetGroupByNameResponse==null){
+ throw new org.apache.axis2.databinding.ADBException("Property cannot be null!");
+ }
+ localGetGroupByNameResponse.serialize(MY_QNAME,factory,xmlWriter);
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+
+ //We can safely assume an element has only one type associated with it
+ return localGetGroupByNameResponse.getPullParser(MY_QNAME);
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static GetGroupByNameResponse parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ GetGroupByNameResponse object =
+ new GetGroupByNameResponse();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/group","getGroupByNameResponse").equals(reader.getName())){
+
+ object.setGetGroupByNameResponse(Group.Factory.parse(reader));
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class UpdateGroupRequest
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/group",
+ "updateGroupRequest",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/group")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for Group
+ */
+
+
+ protected Group_type0 localGroup ;
+
+
+ /**
+ * Auto generated getter method
+ * @return Group_type0
+ */
+ public Group_type0 getGroup(){
+ return localGroup;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Group
+ */
+ public void setGroup(Group_type0 param){
+
+ this.localGroup=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ UpdateGroupRequest.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/group");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":updateGroupRequest",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "updateGroupRequest",
+ xmlWriter);
+ }
+
+
+ }
+
+ if (localGroup==null){
+ throw new org.apache.axis2.databinding.ADBException("group cannot be null!!");
+ }
+ localGroup.serialize(new javax.xml.namespace.QName("http://www.vitero.de/schema/group","group"),
+ factory,xmlWriter);
+
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/group",
+ "group"));
+
+
+ if (localGroup==null){
+ throw new org.apache.axis2.databinding.ADBException("group cannot be null!!");
+ }
+ elementList.add(localGroup);
+
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static UpdateGroupRequest parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ UpdateGroupRequest object =
+ new UpdateGroupRequest();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"updateGroupRequest".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (UpdateGroupRequest)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/group","group").equals(reader.getName())){
+
+ object.setGroup(Group_type0.Factory.parse(reader));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class Participant_type0
+ implements org.apache.axis2.databinding.ADBBean{
+ /* This type was generated from the piece of schema that had
+ name = participant_type0
+ Namespace URI = http://www.vitero.de/schema/group
+ Namespace Prefix = ns1
+ */
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/group")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for Userid
+ */
+
+
+ protected int localUserid ;
+
+
+ /**
+ * Auto generated getter method
+ * @return int
+ */
+ public int getUserid(){
+ return localUserid;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Userid
+ */
+ public void setUserid(int param){
+
+ this.localUserid=param;
+
+
+ }
+
+
+ /**
+ * field for Role
+ */
+
+
+ protected int localRole ;
+
+
+ /**
+ * Auto generated getter method
+ * @return int
+ */
+ public int getRole(){
+ return localRole;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Role
+ */
+ public void setRole(int param){
+
+ this.localRole=param;
+
+
+ }
+
+
+ /**
+ * field for Enabled
+ */
+
+
+ protected boolean localEnabled ;
+
+
+ /**
+ * Auto generated getter method
+ * @return boolean
+ */
+ public boolean getEnabled(){
+ return localEnabled;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Enabled
+ */
+ public void setEnabled(boolean param){
+
+ this.localEnabled=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,parentQName){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ Participant_type0.this.serialize(parentQName,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ parentQName,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/group");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":participant_type0",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "participant_type0",
+ xmlWriter);
+ }
+
+
+ }
+
+ namespace = "http://www.vitero.de/schema/group";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"userid", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"userid");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("userid");
+ }
+
+ if (localUserid==java.lang.Integer.MIN_VALUE) {
+
+ throw new org.apache.axis2.databinding.ADBException("userid cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localUserid));
+ }
+
+ xmlWriter.writeEndElement();
+
+ namespace = "http://www.vitero.de/schema/group";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"role", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"role");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("role");
+ }
+
+ if (localRole==java.lang.Integer.MIN_VALUE) {
+
+ throw new org.apache.axis2.databinding.ADBException("role cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localRole));
+ }
+
+ xmlWriter.writeEndElement();
+
+ namespace = "http://www.vitero.de/schema/group";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"enabled", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"enabled");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("enabled");
+ }
+
+ if (false) {
+
+ throw new org.apache.axis2.databinding.ADBException("enabled cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localEnabled));
+ }
+
+ xmlWriter.writeEndElement();
+
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/group",
+ "userid"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localUserid));
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/group",
+ "role"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localRole));
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/group",
+ "enabled"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localEnabled));
+
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static Participant_type0 parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ Participant_type0 object =
+ new Participant_type0();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"participant_type0".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (Participant_type0)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/group","userid").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setUserid(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToInt(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/group","role").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setRole(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToInt(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/group","enabled").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setEnabled(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToBoolean(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class Groupiduserid
+ implements org.apache.axis2.databinding.ADBBean{
+ /* This type was generated from the piece of schema that had
+ name = groupiduserid
+ Namespace URI = http://www.vitero.de/schema/group
+ Namespace Prefix = ns1
+ */
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/group")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for Groupid
+ */
+
+
+ protected int localGroupid ;
+
+
+ /**
+ * Auto generated getter method
+ * @return int
+ */
+ public int getGroupid(){
+ return localGroupid;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Groupid
+ */
+ public void setGroupid(int param){
+
+ this.localGroupid=param;
+
+
+ }
+
+
+ /**
+ * field for Userid
+ */
+
+
+ protected int localUserid ;
+
+
+ /**
+ * Auto generated getter method
+ * @return int
+ */
+ public int getUserid(){
+ return localUserid;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Userid
+ */
+ public void setUserid(int param){
+
+ this.localUserid=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,parentQName){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ Groupiduserid.this.serialize(parentQName,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ parentQName,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/group");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":groupiduserid",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "groupiduserid",
+ xmlWriter);
+ }
+
+
+ }
+
+ namespace = "http://www.vitero.de/schema/group";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"groupid", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"groupid");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("groupid");
+ }
+
+ if (localGroupid==java.lang.Integer.MIN_VALUE) {
+
+ throw new org.apache.axis2.databinding.ADBException("groupid cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localGroupid));
+ }
+
+ xmlWriter.writeEndElement();
+
+ namespace = "http://www.vitero.de/schema/group";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"userid", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"userid");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("userid");
+ }
+
+ if (localUserid==java.lang.Integer.MIN_VALUE) {
+
+ throw new org.apache.axis2.databinding.ADBException("userid cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localUserid));
+ }
+
+ xmlWriter.writeEndElement();
+
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/group",
+ "groupid"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localGroupid));
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/group",
+ "userid"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localUserid));
+
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static Groupiduserid parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ Groupiduserid object =
+ new Groupiduserid();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"groupiduserid".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (Groupiduserid)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/group","groupid").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setGroupid(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToInt(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/group","userid").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setUserid(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToInt(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class Grouptype
+ implements org.apache.axis2.databinding.ADBBean{
+ /* This type was generated from the piece of schema that had
+ name = grouptype
+ Namespace URI = http://www.vitero.de/schema/group
+ Namespace Prefix = ns1
+ */
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/group")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for Id
+ */
+
+
+ protected int localId ;
+
+
+ /**
+ * Auto generated getter method
+ * @return int
+ */
+ public int getId(){
+ return localId;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Id
+ */
+ public void setId(int param){
+
+ this.localId=param;
+
+
+ }
+
+
+ /**
+ * field for Name
+ */
+
+
+ protected java.lang.String localName ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getName(){
+ return localName;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Name
+ */
+ public void setName(java.lang.String param){
+
+ this.localName=param;
+
+
+ }
+
+
+ /**
+ * field for Customerid
+ */
+
+
+ protected int localCustomerid ;
+
+
+ /**
+ * Auto generated getter method
+ * @return int
+ */
+ public int getCustomerid(){
+ return localCustomerid;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Customerid
+ */
+ public void setCustomerid(int param){
+
+ this.localCustomerid=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,parentQName){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ Grouptype.this.serialize(parentQName,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ parentQName,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/group");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":grouptype",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "grouptype",
+ xmlWriter);
+ }
+
+
+ }
+
+ namespace = "http://www.vitero.de/schema/group";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"id", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"id");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("id");
+ }
+
+ if (localId==java.lang.Integer.MIN_VALUE) {
+
+ throw new org.apache.axis2.databinding.ADBException("id cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localId));
+ }
+
+ xmlWriter.writeEndElement();
+
+ namespace = "http://www.vitero.de/schema/group";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"name", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"name");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("name");
+ }
+
+
+ if (localName==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("name cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localName);
+
+ }
+
+ xmlWriter.writeEndElement();
+
+ namespace = "http://www.vitero.de/schema/group";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"customerid", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"customerid");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("customerid");
+ }
+
+ if (localCustomerid==java.lang.Integer.MIN_VALUE) {
+
+ throw new org.apache.axis2.databinding.ADBException("customerid cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localCustomerid));
+ }
+
+ xmlWriter.writeEndElement();
+
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/group",
+ "id"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localId));
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/group",
+ "name"));
+
+ if (localName != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localName));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("name cannot be null!!");
+ }
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/group",
+ "customerid"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localCustomerid));
+
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static Grouptype parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ Grouptype object =
+ new Grouptype();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"grouptype".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (Grouptype)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/group","id").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setId(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToInt(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/group","name").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setName(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/group","customerid").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setCustomerid(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToInt(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class DeleteGroupRequest
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/group",
+ "deleteGroupRequest",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/group")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for DeleteGroupRequest
+ */
+
+
+ protected Groupid localDeleteGroupRequest ;
+
+
+ /**
+ * Auto generated getter method
+ * @return Groupid
+ */
+ public Groupid getDeleteGroupRequest(){
+ return localDeleteGroupRequest;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param DeleteGroupRequest
+ */
+ public void setDeleteGroupRequest(Groupid param){
+
+ this.localDeleteGroupRequest=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ DeleteGroupRequest.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+ //We can safely assume an element has only one type associated with it
+
+ if (localDeleteGroupRequest==null){
+ throw new org.apache.axis2.databinding.ADBException("Property cannot be null!");
+ }
+ localDeleteGroupRequest.serialize(MY_QNAME,factory,xmlWriter);
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+
+ //We can safely assume an element has only one type associated with it
+ return localDeleteGroupRequest.getPullParser(MY_QNAME);
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static DeleteGroupRequest parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ DeleteGroupRequest object =
+ new DeleteGroupRequest();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/group","deleteGroupRequest").equals(reader.getName())){
+
+ object.setDeleteGroupRequest(Groupid.Factory.parse(reader));
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class Groupnamecustomerid
+ implements org.apache.axis2.databinding.ADBBean{
+ /* This type was generated from the piece of schema that had
+ name = groupnamecustomerid
+ Namespace URI = http://www.vitero.de/schema/group
+ Namespace Prefix = ns1
+ */
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/group")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for Groupname
+ */
+
+
+ protected java.lang.String localGroupname ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getGroupname(){
+ return localGroupname;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Groupname
+ */
+ public void setGroupname(java.lang.String param){
+
+ this.localGroupname=param;
+
+
+ }
+
+
+ /**
+ * field for Customerid
+ */
+
+
+ protected int localCustomerid ;
+
+
+ /**
+ * Auto generated getter method
+ * @return int
+ */
+ public int getCustomerid(){
+ return localCustomerid;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Customerid
+ */
+ public void setCustomerid(int param){
+
+ this.localCustomerid=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,parentQName){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ Groupnamecustomerid.this.serialize(parentQName,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ parentQName,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/group");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":groupnamecustomerid",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "groupnamecustomerid",
+ xmlWriter);
+ }
+
+
+ }
+
+ namespace = "http://www.vitero.de/schema/group";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"groupname", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"groupname");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("groupname");
+ }
+
+
+ if (localGroupname==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("groupname cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localGroupname);
+
+ }
+
+ xmlWriter.writeEndElement();
+
+ namespace = "http://www.vitero.de/schema/group";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"customerid", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"customerid");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("customerid");
+ }
+
+ if (localCustomerid==java.lang.Integer.MIN_VALUE) {
+
+ throw new org.apache.axis2.databinding.ADBException("customerid cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localCustomerid));
+ }
+
+ xmlWriter.writeEndElement();
+
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/group",
+ "groupname"));
+
+ if (localGroupname != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localGroupname));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("groupname cannot be null!!");
+ }
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/group",
+ "customerid"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localCustomerid));
+
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static Groupnamecustomerid parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ Groupnamecustomerid object =
+ new Groupnamecustomerid();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"groupnamecustomerid".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (Groupnamecustomerid)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/group","groupname").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setGroupname(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/group","customerid").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setCustomerid(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToInt(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class Group_type0
+ implements org.apache.axis2.databinding.ADBBean{
+ /* This type was generated from the piece of schema that had
+ name = group_type0
+ Namespace URI = http://www.vitero.de/schema/group
+ Namespace Prefix = ns1
+ */
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/group")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for Id
+ */
+
+
+ protected int localId ;
+
+
+ /**
+ * Auto generated getter method
+ * @return int
+ */
+ public int getId(){
+ return localId;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Id
+ */
+ public void setId(int param){
+
+ this.localId=param;
+
+
+ }
+
+
+ /**
+ * field for Name
+ */
+
+
+ protected java.lang.String localName ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getName(){
+ return localName;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Name
+ */
+ public void setName(java.lang.String param){
+
+ this.localName=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,parentQName){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ Group_type0.this.serialize(parentQName,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ parentQName,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/group");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":group_type0",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "group_type0",
+ xmlWriter);
+ }
+
+
+ }
+
+ namespace = "http://www.vitero.de/schema/group";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"id", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"id");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("id");
+ }
+
+ if (localId==java.lang.Integer.MIN_VALUE) {
+
+ throw new org.apache.axis2.databinding.ADBException("id cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localId));
+ }
+
+ xmlWriter.writeEndElement();
+
+ namespace = "http://www.vitero.de/schema/group";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"name", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"name");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("name");
+ }
+
+
+ if (localName==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("name cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localName);
+
+ }
+
+ xmlWriter.writeEndElement();
+
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/group",
+ "id"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localId));
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/group",
+ "name"));
+
+ if (localName != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localName));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("name cannot be null!!");
+ }
+
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static Group_type0 parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ Group_type0 object =
+ new Group_type0();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"group_type0".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (Group_type0)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/group","id").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setId(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToInt(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/group","name").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setName(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class Completegrouptype
+ implements org.apache.axis2.databinding.ADBBean{
+ /* This type was generated from the piece of schema that had
+ name = completegrouptype
+ Namespace URI = http://www.vitero.de/schema/group
+ Namespace Prefix = ns1
+ */
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/group")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for Id
+ */
+
+
+ protected int localId ;
+
+
+ /**
+ * Auto generated getter method
+ * @return int
+ */
+ public int getId(){
+ return localId;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Id
+ */
+ public void setId(int param){
+
+ this.localId=param;
+
+
+ }
+
+
+ /**
+ * field for Name
+ */
+
+
+ protected java.lang.String localName ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getName(){
+ return localName;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Name
+ */
+ public void setName(java.lang.String param){
+
+ this.localName=param;
+
+
+ }
+
+
+ /**
+ * field for Customerid
+ */
+
+
+ protected int localCustomerid ;
+
+
+ /**
+ * Auto generated getter method
+ * @return int
+ */
+ public int getCustomerid(){
+ return localCustomerid;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Customerid
+ */
+ public void setCustomerid(int param){
+
+ this.localCustomerid=param;
+
+
+ }
+
+
+ /**
+ * field for Participant
+ * This was an Array!
+ */
+
+
+ protected Participant_type0[] localParticipant ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localParticipantTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return Participant_type0[]
+ */
+ public Participant_type0[] getParticipant(){
+ return localParticipant;
+ }
+
+
+
+
+
+
+ /**
+ * validate the array for Participant
+ */
+ protected void validateParticipant(Participant_type0[] param){
+
+ }
+
+
+ /**
+ * Auto generated setter method
+ * @param param Participant
+ */
+ public void setParticipant(Participant_type0[] param){
+
+ validateParticipant(param);
+
+
+ if (param != null){
+ //update the setting tracker
+ localParticipantTracker = true;
+ } else {
+ localParticipantTracker = false;
+
+ }
+
+ this.localParticipant=param;
+ }
+
+
+
+ /**
+ * Auto generated add method for the array for convenience
+ * @param param Participant_type0
+ */
+ public void addParticipant(Participant_type0 param){
+ if (localParticipant == null){
+ localParticipant = new Participant_type0[]{};
+ }
+
+
+ //update the setting tracker
+ localParticipantTracker = true;
+
+
+ java.util.List list =
+ org.apache.axis2.databinding.utils.ConverterUtil.toList(localParticipant);
+ list.add(param);
+ this.localParticipant =
+ (Participant_type0[])list.toArray(
+ new Participant_type0[list.size()]);
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,parentQName){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ Completegrouptype.this.serialize(parentQName,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ parentQName,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/group");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":completegrouptype",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "completegrouptype",
+ xmlWriter);
+ }
+
+
+ }
+
+ namespace = "http://www.vitero.de/schema/group";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"id", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"id");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("id");
+ }
+
+ if (localId==java.lang.Integer.MIN_VALUE) {
+
+ throw new org.apache.axis2.databinding.ADBException("id cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localId));
+ }
+
+ xmlWriter.writeEndElement();
+
+ namespace = "http://www.vitero.de/schema/group";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"name", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"name");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("name");
+ }
+
+
+ if (localName==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("name cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localName);
+
+ }
+
+ xmlWriter.writeEndElement();
+
+ namespace = "http://www.vitero.de/schema/group";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"customerid", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"customerid");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("customerid");
+ }
+
+ if (localCustomerid==java.lang.Integer.MIN_VALUE) {
+
+ throw new org.apache.axis2.databinding.ADBException("customerid cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localCustomerid));
+ }
+
+ xmlWriter.writeEndElement();
+ if (localParticipantTracker){
+ if (localParticipant!=null){
+ for (int i = 0;i < localParticipant.length;i++){
+ if (localParticipant[i] != null){
+ localParticipant[i].serialize(new javax.xml.namespace.QName("http://www.vitero.de/schema/group","participant"),
+ factory,xmlWriter);
+ } else {
+
+ // we don't have to do any thing since minOccures is zero
+
+ }
+
+ }
+ } else {
+
+ throw new org.apache.axis2.databinding.ADBException("participant cannot be null!!");
+
+ }
+ }
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/group",
+ "id"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localId));
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/group",
+ "name"));
+
+ if (localName != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localName));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("name cannot be null!!");
+ }
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/group",
+ "customerid"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localCustomerid));
+ if (localParticipantTracker){
+ if (localParticipant!=null) {
+ for (int i = 0;i < localParticipant.length;i++){
+
+ if (localParticipant[i] != null){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/group",
+ "participant"));
+ elementList.add(localParticipant[i]);
+ } else {
+
+ // nothing to do
+
+ }
+
+ }
+ } else {
+
+ throw new org.apache.axis2.databinding.ADBException("participant cannot be null!!");
+
+ }
+
+ }
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static Completegrouptype parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ Completegrouptype object =
+ new Completegrouptype();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"completegrouptype".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (Completegrouptype)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+ java.util.ArrayList list4 = new java.util.ArrayList();
+
+
+ while (!reader.isStartElement() && !reader.isEndElement()) reader.next();
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/group","id").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setId(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToInt(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+
+ while (!reader.isStartElement() && !reader.isEndElement()) reader.next();
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/group","name").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setName(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+
+ while (!reader.isStartElement() && !reader.isEndElement()) reader.next();
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/group","customerid").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setCustomerid(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToInt(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+
+ while (!reader.isStartElement() && !reader.isEndElement()) reader.next();
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/group","participant").equals(reader.getName())){
+
+
+
+ // Process the array and step past its final element's end.
+ list4.add(Participant_type0.Factory.parse(reader));
+
+ //loop until we find a start element that is not part of this array
+ boolean loopDone4 = false;
+ while(!loopDone4){
+ // We should be at the end element, but make sure
+ while (!reader.isEndElement())
+ reader.next();
+ // Step out of this element
+ reader.next();
+ // Step to next element event.
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+ if (reader.isEndElement()){
+ //two continuous end elements means we are exiting the xml structure
+ loopDone4 = true;
+ } else {
+ if (new javax.xml.namespace.QName("http://www.vitero.de/schema/group","participant").equals(reader.getName())){
+ list4.add(Participant_type0.Factory.parse(reader));
+
+ }else{
+ loopDone4 = true;
+ }
+ }
+ }
+ // call the converter utility to convert and set the array
+
+ object.setParticipant((Participant_type0[])
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToArray(
+ Participant_type0.class,
+ list4));
+
+ } // End of if for expected property start element
+
+ else {
+
+ }
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+ if (reader.isStartElement())
+ // A start element we are not expecting indicates a trailing invalid property
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class GetGroupResponse
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/group",
+ "getGroupResponse",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/group")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for GetGroupResponse
+ */
+
+
+ protected Group localGetGroupResponse ;
+
+
+ /**
+ * Auto generated getter method
+ * @return Group
+ */
+ public Group getGetGroupResponse(){
+ return localGetGroupResponse;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param GetGroupResponse
+ */
+ public void setGetGroupResponse(Group param){
+
+ this.localGetGroupResponse=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ GetGroupResponse.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+ //We can safely assume an element has only one type associated with it
+
+ if (localGetGroupResponse==null){
+ throw new org.apache.axis2.databinding.ADBException("Property cannot be null!");
+ }
+ localGetGroupResponse.serialize(MY_QNAME,factory,xmlWriter);
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+
+ //We can safely assume an element has only one type associated with it
+ return localGetGroupResponse.getPullParser(MY_QNAME);
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static GetGroupResponse parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ GetGroupResponse object =
+ new GetGroupResponse();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/group","getGroupResponse").equals(reader.getName())){
+
+ object.setGetGroupResponse(Group.Factory.parse(reader));
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class SuccessResponse
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/group",
+ "successResponse",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/group")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for Request
+ */
+
+
+ protected java.lang.String localRequest ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getRequest(){
+ return localRequest;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Request
+ */
+ public void setRequest(java.lang.String param){
+
+ this.localRequest=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ SuccessResponse.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/group");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":successResponse",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "successResponse",
+ xmlWriter);
+ }
+
+
+ }
+
+ namespace = "http://www.vitero.de/schema/group";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"request", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"request");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("request");
+ }
+
+
+ if (localRequest==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("request cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localRequest);
+
+ }
+
+ xmlWriter.writeEndElement();
+
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/group",
+ "request"));
+
+ if (localRequest != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localRequest));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("request cannot be null!!");
+ }
+
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static SuccessResponse parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ SuccessResponse object =
+ new SuccessResponse();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"successResponse".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (SuccessResponse)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/group","request").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setRequest(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class GetGroupListByCustomerResponse
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/group",
+ "getGroupListByCustomerResponse",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/group")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for Group
+ * This was an Array!
+ */
+
+
+ protected Grouptype[] localGroup ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localGroupTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return Grouptype[]
+ */
+ public Grouptype[] getGroup(){
+ return localGroup;
+ }
+
+
+
+
+
+
+ /**
+ * validate the array for Group
+ */
+ protected void validateGroup(Grouptype[] param){
+
+ }
+
+
+ /**
+ * Auto generated setter method
+ * @param param Group
+ */
+ public void setGroup(Grouptype[] param){
+
+ validateGroup(param);
+
+
+ if (param != null){
+ //update the setting tracker
+ localGroupTracker = true;
+ } else {
+ localGroupTracker = false;
+
+ }
+
+ this.localGroup=param;
+ }
+
+
+
+ /**
+ * Auto generated add method for the array for convenience
+ * @param param Grouptype
+ */
+ public void addGroup(Grouptype param){
+ if (localGroup == null){
+ localGroup = new Grouptype[]{};
+ }
+
+
+ //update the setting tracker
+ localGroupTracker = true;
+
+
+ java.util.List list =
+ org.apache.axis2.databinding.utils.ConverterUtil.toList(localGroup);
+ list.add(param);
+ this.localGroup =
+ (Grouptype[])list.toArray(
+ new Grouptype[list.size()]);
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ GetGroupListByCustomerResponse.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/group");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":getGroupListByCustomerResponse",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "getGroupListByCustomerResponse",
+ xmlWriter);
+ }
+
+
+ }
+ if (localGroupTracker){
+ if (localGroup!=null){
+ for (int i = 0;i < localGroup.length;i++){
+ if (localGroup[i] != null){
+ localGroup[i].serialize(new javax.xml.namespace.QName("http://www.vitero.de/schema/group","group"),
+ factory,xmlWriter);
+ } else {
+
+ // we don't have to do any thing since minOccures is zero
+
+ }
+
+ }
+ } else {
+
+ throw new org.apache.axis2.databinding.ADBException("group cannot be null!!");
+
+ }
+ }
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+ if (localGroupTracker){
+ if (localGroup!=null) {
+ for (int i = 0;i < localGroup.length;i++){
+
+ if (localGroup[i] != null){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/group",
+ "group"));
+ elementList.add(localGroup[i]);
+ } else {
+
+ // nothing to do
+
+ }
+
+ }
+ } else {
+
+ throw new org.apache.axis2.databinding.ADBException("group cannot be null!!");
+
+ }
+
+ }
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static GetGroupListByCustomerResponse parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ GetGroupListByCustomerResponse object =
+ new GetGroupListByCustomerResponse();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"getGroupListByCustomerResponse".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (GetGroupListByCustomerResponse)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+ java.util.ArrayList list1 = new java.util.ArrayList();
+
+
+ while (!reader.isStartElement() && !reader.isEndElement()) reader.next();
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/group","group").equals(reader.getName())){
+
+
+
+ // Process the array and step past its final element's end.
+ list1.add(Grouptype.Factory.parse(reader));
+
+ //loop until we find a start element that is not part of this array
+ boolean loopDone1 = false;
+ while(!loopDone1){
+ // We should be at the end element, but make sure
+ while (!reader.isEndElement())
+ reader.next();
+ // Step out of this element
+ reader.next();
+ // Step to next element event.
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+ if (reader.isEndElement()){
+ //two continuous end elements means we are exiting the xml structure
+ loopDone1 = true;
+ } else {
+ if (new javax.xml.namespace.QName("http://www.vitero.de/schema/group","group").equals(reader.getName())){
+ list1.add(Grouptype.Factory.parse(reader));
+
+ }else{
+ loopDone1 = true;
+ }
+ }
+ }
+ // call the converter utility to convert and set the array
+
+ object.setGroup((Grouptype[])
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToArray(
+ Grouptype.class,
+ list1));
+
+ } // End of if for expected property start element
+
+ else {
+
+ }
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+ if (reader.isStartElement())
+ // A start element we are not expecting indicates a trailing invalid property
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class ExtensionMapper{
+
+ public static java.lang.Object getTypeObject(java.lang.String namespaceURI,
+ java.lang.String typeName,
+ javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+
+
+ if (
+ "http://www.vitero.de/schema/group".equals(namespaceURI) &&
+ "completegrouptype".equals(typeName)){
+
+ return Completegrouptype.Factory.parse(reader);
+
+
+ }
+
+
+ if (
+ "http://www.vitero.de/schema/group".equals(namespaceURI) &&
+ "grouptype".equals(typeName)){
+
+ return Grouptype.Factory.parse(reader);
+
+
+ }
+
+
+ if (
+ "http://www.vitero.de/schema/group".equals(namespaceURI) &&
+ "groupiduserid".equals(typeName)){
+
+ return Groupiduserid.Factory.parse(reader);
+
+
+ }
+
+
+ if (
+ "http://www.vitero.de/schema/group".equals(namespaceURI) &&
+ "group".equals(typeName)){
+
+ return Group.Factory.parse(reader);
+
+
+ }
+
+
+ if (
+ "http://www.vitero.de/schema/group".equals(namespaceURI) &&
+ "group_type0".equals(typeName)){
+
+ return Group_type0.Factory.parse(reader);
+
+
+ }
+
+
+ if (
+ "http://www.vitero.de/schema/group".equals(namespaceURI) &&
+ "groupnamecustomerid".equals(typeName)){
+
+ return Groupnamecustomerid.Factory.parse(reader);
+
+
+ }
+
+
+ if (
+ "http://www.vitero.de/schema/group".equals(namespaceURI) &&
+ "participant_type0".equals(typeName)){
+
+ return Participant_type0.Factory.parse(reader);
+
+
+ }
+
+
+ if (
+ "http://www.vitero.de/schema/group".equals(namespaceURI) &&
+ "groupid".equals(typeName)){
+
+ return Groupid.Factory.parse(reader);
+
+
+ }
+
+
+ throw new org.apache.axis2.databinding.ADBException("Unsupported type " + namespaceURI + " " + typeName);
+ }
+
+ }
+
+ public static class Groupid
+ implements org.apache.axis2.databinding.ADBBean{
+ /* This type was generated from the piece of schema that had
+ name = groupid
+ Namespace URI = http://www.vitero.de/schema/group
+ Namespace Prefix = ns1
+ */
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/group")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for Groupid
+ */
+
+
+ protected int localGroupid ;
+
+
+ /**
+ * Auto generated getter method
+ * @return int
+ */
+ public int getGroupid(){
+ return localGroupid;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Groupid
+ */
+ public void setGroupid(int param){
+
+ this.localGroupid=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,parentQName){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ Groupid.this.serialize(parentQName,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ parentQName,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/group");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":groupid",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "groupid",
+ xmlWriter);
+ }
+
+
+ }
+
+ namespace = "http://www.vitero.de/schema/group";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"groupid", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"groupid");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("groupid");
+ }
+
+ if (localGroupid==java.lang.Integer.MIN_VALUE) {
+
+ throw new org.apache.axis2.databinding.ADBException("groupid cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localGroupid));
+ }
+
+ xmlWriter.writeEndElement();
+
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/group",
+ "groupid"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localGroupid));
+
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static Groupid parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ Groupid object =
+ new Groupid();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"groupid".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (Groupid)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/group","groupid").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setGroupid(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToInt(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class GetGroupRequest
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/group",
+ "getGroupRequest",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/group")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for GetGroupRequest
+ */
+
+
+ protected Groupid localGetGroupRequest ;
+
+
+ /**
+ * Auto generated getter method
+ * @return Groupid
+ */
+ public Groupid getGetGroupRequest(){
+ return localGetGroupRequest;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param GetGroupRequest
+ */
+ public void setGetGroupRequest(Groupid param){
+
+ this.localGetGroupRequest=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ GetGroupRequest.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+ //We can safely assume an element has only one type associated with it
+
+ if (localGetGroupRequest==null){
+ throw new org.apache.axis2.databinding.ADBException("Property cannot be null!");
+ }
+ localGetGroupRequest.serialize(MY_QNAME,factory,xmlWriter);
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+
+ //We can safely assume an element has only one type associated with it
+ return localGetGroupRequest.getPullParser(MY_QNAME);
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static GetGroupRequest parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ GetGroupRequest object =
+ new GetGroupRequest();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/group","getGroupRequest").equals(reader.getName())){
+
+ object.setGetGroupRequest(Groupid.Factory.parse(reader));
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class AddUserToGroupRequest
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/group",
+ "addUserToGroupRequest",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/group")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for AddUserToGroupRequest
+ */
+
+
+ protected Groupiduserid localAddUserToGroupRequest ;
+
+
+ /**
+ * Auto generated getter method
+ * @return Groupiduserid
+ */
+ public Groupiduserid getAddUserToGroupRequest(){
+ return localAddUserToGroupRequest;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param AddUserToGroupRequest
+ */
+ public void setAddUserToGroupRequest(Groupiduserid param){
+
+ this.localAddUserToGroupRequest=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ AddUserToGroupRequest.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+ //We can safely assume an element has only one type associated with it
+
+ if (localAddUserToGroupRequest==null){
+ throw new org.apache.axis2.databinding.ADBException("Property cannot be null!");
+ }
+ localAddUserToGroupRequest.serialize(MY_QNAME,factory,xmlWriter);
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+
+ //We can safely assume an element has only one type associated with it
+ return localAddUserToGroupRequest.getPullParser(MY_QNAME);
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static AddUserToGroupRequest parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ AddUserToGroupRequest object =
+ new AddUserToGroupRequest();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/group","addUserToGroupRequest").equals(reader.getName())){
+
+ object.setAddUserToGroupRequest(Groupiduserid.Factory.parse(reader));
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class Group
+ implements org.apache.axis2.databinding.ADBBean{
+ /* This type was generated from the piece of schema that had
+ name = group
+ Namespace URI = http://www.vitero.de/schema/group
+ Namespace Prefix = ns1
+ */
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/group")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for Group
+ */
+
+
+ protected Completegrouptype localGroup ;
+
+
+ /**
+ * Auto generated getter method
+ * @return Completegrouptype
+ */
+ public Completegrouptype getGroup(){
+ return localGroup;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Group
+ */
+ public void setGroup(Completegrouptype param){
+
+ this.localGroup=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,parentQName){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ Group.this.serialize(parentQName,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ parentQName,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/group");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":group",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "group",
+ xmlWriter);
+ }
+
+
+ }
+
+ if (localGroup==null){
+ throw new org.apache.axis2.databinding.ADBException("group cannot be null!!");
+ }
+ localGroup.serialize(new javax.xml.namespace.QName("http://www.vitero.de/schema/group","group"),
+ factory,xmlWriter);
+
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/group",
+ "group"));
+
+
+ if (localGroup==null){
+ throw new org.apache.axis2.databinding.ADBException("group cannot be null!!");
+ }
+ elementList.add(localGroup);
+
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static Group parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ Group object =
+ new Group();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"group".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (Group)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/group","group").equals(reader.getName())){
+
+ object.setGroup(Completegrouptype.Factory.parse(reader));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class CreateGroupRequest
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/group",
+ "createGroupRequest",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/group")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for Group
+ */
+
+
+ protected Groupnamecustomerid localGroup ;
+
+
+ /**
+ * Auto generated getter method
+ * @return Groupnamecustomerid
+ */
+ public Groupnamecustomerid getGroup(){
+ return localGroup;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Group
+ */
+ public void setGroup(Groupnamecustomerid param){
+
+ this.localGroup=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ CreateGroupRequest.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/group");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":createGroupRequest",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "createGroupRequest",
+ xmlWriter);
+ }
+
+
+ }
+
+ if (localGroup==null){
+ throw new org.apache.axis2.databinding.ADBException("group cannot be null!!");
+ }
+ localGroup.serialize(new javax.xml.namespace.QName("http://www.vitero.de/schema/group","group"),
+ factory,xmlWriter);
+
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/group",
+ "group"));
+
+
+ if (localGroup==null){
+ throw new org.apache.axis2.databinding.ADBException("group cannot be null!!");
+ }
+ elementList.add(localGroup);
+
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static CreateGroupRequest parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ CreateGroupRequest object =
+ new CreateGroupRequest();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"createGroupRequest".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (CreateGroupRequest)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/group","group").equals(reader.getName())){
+
+ object.setGroup(Groupnamecustomerid.Factory.parse(reader));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class GetGroupByNameRequest
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/group",
+ "getGroupByNameRequest",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/group")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for GetGroupByNameRequest
+ */
+
+
+ protected Groupnamecustomerid localGetGroupByNameRequest ;
+
+
+ /**
+ * Auto generated getter method
+ * @return Groupnamecustomerid
+ */
+ public Groupnamecustomerid getGetGroupByNameRequest(){
+ return localGetGroupByNameRequest;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param GetGroupByNameRequest
+ */
+ public void setGetGroupByNameRequest(Groupnamecustomerid param){
+
+ this.localGetGroupByNameRequest=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ GetGroupByNameRequest.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+ //We can safely assume an element has only one type associated with it
+
+ if (localGetGroupByNameRequest==null){
+ throw new org.apache.axis2.databinding.ADBException("Property cannot be null!");
+ }
+ localGetGroupByNameRequest.serialize(MY_QNAME,factory,xmlWriter);
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+
+ //We can safely assume an element has only one type associated with it
+ return localGetGroupByNameRequest.getPullParser(MY_QNAME);
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static GetGroupByNameRequest parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ GetGroupByNameRequest object =
+ new GetGroupByNameRequest();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/group","getGroupByNameRequest").equals(reader.getName())){
+
+ object.setGetGroupByNameRequest(Groupnamecustomerid.Factory.parse(reader));
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class GetGroupListByCustomerRequest
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/group",
+ "getGroupListByCustomerRequest",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/group")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for Customerid
+ */
+
+
+ protected int localCustomerid ;
+
+
+ /**
+ * Auto generated getter method
+ * @return int
+ */
+ public int getCustomerid(){
+ return localCustomerid;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Customerid
+ */
+ public void setCustomerid(int param){
+
+ this.localCustomerid=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ GetGroupListByCustomerRequest.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/group");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":getGroupListByCustomerRequest",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "getGroupListByCustomerRequest",
+ xmlWriter);
+ }
+
+
+ }
+
+ namespace = "http://www.vitero.de/schema/group";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"customerid", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"customerid");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("customerid");
+ }
+
+ if (localCustomerid==java.lang.Integer.MIN_VALUE) {
+
+ throw new org.apache.axis2.databinding.ADBException("customerid cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localCustomerid));
+ }
+
+ xmlWriter.writeEndElement();
+
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/group",
+ "customerid"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localCustomerid));
+
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static GetGroupListByCustomerRequest parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ GetGroupListByCustomerRequest object =
+ new GetGroupListByCustomerRequest();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"getGroupListByCustomerRequest".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (GetGroupListByCustomerRequest)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/group","customerid").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setCustomerid(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToInt(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class CreateGroupResponse
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/group",
+ "createGroupResponse",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/group")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for CreateGroupResponse
+ */
+
+
+ protected Groupid localCreateGroupResponse ;
+
+
+ /**
+ * Auto generated getter method
+ * @return Groupid
+ */
+ public Groupid getCreateGroupResponse(){
+ return localCreateGroupResponse;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param CreateGroupResponse
+ */
+ public void setCreateGroupResponse(Groupid param){
+
+ this.localCreateGroupResponse=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ CreateGroupResponse.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+ //We can safely assume an element has only one type associated with it
+
+ if (localCreateGroupResponse==null){
+ throw new org.apache.axis2.databinding.ADBException("Property cannot be null!");
+ }
+ localCreateGroupResponse.serialize(MY_QNAME,factory,xmlWriter);
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+
+ //We can safely assume an element has only one type associated with it
+ return localCreateGroupResponse.getPullParser(MY_QNAME);
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static CreateGroupResponse parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ CreateGroupResponse object =
+ new CreateGroupResponse();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/group","createGroupResponse").equals(reader.getName())){
+
+ object.setCreateGroupResponse(Groupid.Factory.parse(reader));
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class RemoveUserFromGroupRequest
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/group",
+ "removeUserFromGroupRequest",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/group")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for RemoveUserFromGroupRequest
+ */
+
+
+ protected Groupiduserid localRemoveUserFromGroupRequest ;
+
+
+ /**
+ * Auto generated getter method
+ * @return Groupiduserid
+ */
+ public Groupiduserid getRemoveUserFromGroupRequest(){
+ return localRemoveUserFromGroupRequest;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param RemoveUserFromGroupRequest
+ */
+ public void setRemoveUserFromGroupRequest(Groupiduserid param){
+
+ this.localRemoveUserFromGroupRequest=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ RemoveUserFromGroupRequest.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+ //We can safely assume an element has only one type associated with it
+
+ if (localRemoveUserFromGroupRequest==null){
+ throw new org.apache.axis2.databinding.ADBException("Property cannot be null!");
+ }
+ localRemoveUserFromGroupRequest.serialize(MY_QNAME,factory,xmlWriter);
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+
+ //We can safely assume an element has only one type associated with it
+ return localRemoveUserFromGroupRequest.getPullParser(MY_QNAME);
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static RemoveUserFromGroupRequest parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ RemoveUserFromGroupRequest object =
+ new RemoveUserFromGroupRequest();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/group","removeUserFromGroupRequest").equals(reader.getName())){
+
+ object.setRemoveUserFromGroupRequest(Groupiduserid.Factory.parse(reader));
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class ChangeGroupRoleRequest
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/group",
+ "changeGroupRoleRequest",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/group")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for Groupid
+ */
+
+
+ protected int localGroupid ;
+
+
+ /**
+ * Auto generated getter method
+ * @return int
+ */
+ public int getGroupid(){
+ return localGroupid;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Groupid
+ */
+ public void setGroupid(int param){
+
+ this.localGroupid=param;
+
+
+ }
+
+
+ /**
+ * field for Userid
+ */
+
+
+ protected int localUserid ;
+
+
+ /**
+ * Auto generated getter method
+ * @return int
+ */
+ public int getUserid(){
+ return localUserid;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Userid
+ */
+ public void setUserid(int param){
+
+ this.localUserid=param;
+
+
+ }
+
+
+ /**
+ * field for Role
+ */
+
+
+ protected int localRole ;
+
+
+ /**
+ * Auto generated getter method
+ * @return int
+ */
+ public int getRole(){
+ return localRole;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Role
+ */
+ public void setRole(int param){
+
+ this.localRole=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ ChangeGroupRoleRequest.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/group");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":changeGroupRoleRequest",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "changeGroupRoleRequest",
+ xmlWriter);
+ }
+
+
+ }
+
+ namespace = "http://www.vitero.de/schema/group";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"groupid", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"groupid");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("groupid");
+ }
+
+ if (localGroupid==java.lang.Integer.MIN_VALUE) {
+
+ throw new org.apache.axis2.databinding.ADBException("groupid cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localGroupid));
+ }
+
+ xmlWriter.writeEndElement();
+
+ namespace = "http://www.vitero.de/schema/group";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"userid", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"userid");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("userid");
+ }
+
+ if (localUserid==java.lang.Integer.MIN_VALUE) {
+
+ throw new org.apache.axis2.databinding.ADBException("userid cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localUserid));
+ }
+
+ xmlWriter.writeEndElement();
+
+ namespace = "http://www.vitero.de/schema/group";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"role", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"role");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("role");
+ }
+
+ if (localRole==java.lang.Integer.MIN_VALUE) {
+
+ throw new org.apache.axis2.databinding.ADBException("role cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localRole));
+ }
+
+ xmlWriter.writeEndElement();
+
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/group",
+ "groupid"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localGroupid));
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/group",
+ "userid"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localUserid));
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/group",
+ "role"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localRole));
+
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static ChangeGroupRoleRequest parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ ChangeGroupRoleRequest object =
+ new ChangeGroupRoleRequest();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"changeGroupRoleRequest".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (ChangeGroupRoleRequest)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/group","groupid").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setGroupid(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToInt(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/group","userid").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setUserid(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToInt(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/group","role").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setRole(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToInt(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.GroupServiceStub.AddUserToGroupRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.GroupServiceStub.AddUserToGroupRequest.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.GroupServiceStub.GetGroupListByCustomerRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.GroupServiceStub.GetGroupListByCustomerRequest.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.GroupServiceStub.GetGroupListByCustomerResponse param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.GroupServiceStub.GetGroupListByCustomerResponse.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.GroupServiceStub.GetGroupByNameRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.GroupServiceStub.GetGroupByNameRequest.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.GroupServiceStub.GetGroupByNameResponse param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.GroupServiceStub.GetGroupByNameResponse.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.GroupServiceStub.SuccessResponse param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.GroupServiceStub.SuccessResponse.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.GroupServiceStub.DeleteGroupRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.GroupServiceStub.DeleteGroupRequest.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.GroupServiceStub.UpdateGroupRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.GroupServiceStub.UpdateGroupRequest.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.GroupServiceStub.RemoveUserFromGroupRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.GroupServiceStub.RemoveUserFromGroupRequest.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.GroupServiceStub.ChangeGroupRoleRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.GroupServiceStub.ChangeGroupRoleRequest.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.GroupServiceStub.GetGroupRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.GroupServiceStub.GetGroupRequest.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.GroupServiceStub.GetGroupResponse param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.GroupServiceStub.GetGroupResponse.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.GroupServiceStub.CreateGroupRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.GroupServiceStub.CreateGroupRequest.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.GroupServiceStub.CreateGroupResponse param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.GroupServiceStub.CreateGroupResponse.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+
+ private org.apache.axiom.soap.SOAPEnvelope toEnvelope(org.apache.axiom.soap.SOAPFactory factory, com.frentix.olat.vitero.manager.stubs.GroupServiceStub.AddUserToGroupRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault{
+
+
+ try{
+
+ org.apache.axiom.soap.SOAPEnvelope emptyEnvelope = factory.getDefaultEnvelope();
+ emptyEnvelope.getBody().addChild(param.getOMElement(com.frentix.olat.vitero.manager.stubs.GroupServiceStub.AddUserToGroupRequest.MY_QNAME,factory));
+ return emptyEnvelope;
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+
+ /* methods to provide back word compatibility */
+
+
+
+ private org.apache.axiom.soap.SOAPEnvelope toEnvelope(org.apache.axiom.soap.SOAPFactory factory, com.frentix.olat.vitero.manager.stubs.GroupServiceStub.GetGroupListByCustomerRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault{
+
+
+ try{
+
+ org.apache.axiom.soap.SOAPEnvelope emptyEnvelope = factory.getDefaultEnvelope();
+ emptyEnvelope.getBody().addChild(param.getOMElement(com.frentix.olat.vitero.manager.stubs.GroupServiceStub.GetGroupListByCustomerRequest.MY_QNAME,factory));
+ return emptyEnvelope;
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+
+ /* methods to provide back word compatibility */
+
+
+
+ private org.apache.axiom.soap.SOAPEnvelope toEnvelope(org.apache.axiom.soap.SOAPFactory factory, com.frentix.olat.vitero.manager.stubs.GroupServiceStub.GetGroupByNameRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault{
+
+
+ try{
+
+ org.apache.axiom.soap.SOAPEnvelope emptyEnvelope = factory.getDefaultEnvelope();
+ emptyEnvelope.getBody().addChild(param.getOMElement(com.frentix.olat.vitero.manager.stubs.GroupServiceStub.GetGroupByNameRequest.MY_QNAME,factory));
+ return emptyEnvelope;
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+
+ /* methods to provide back word compatibility */
+
+
+
+ private org.apache.axiom.soap.SOAPEnvelope toEnvelope(org.apache.axiom.soap.SOAPFactory factory, com.frentix.olat.vitero.manager.stubs.GroupServiceStub.DeleteGroupRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault{
+
+
+ try{
+
+ org.apache.axiom.soap.SOAPEnvelope emptyEnvelope = factory.getDefaultEnvelope();
+ emptyEnvelope.getBody().addChild(param.getOMElement(com.frentix.olat.vitero.manager.stubs.GroupServiceStub.DeleteGroupRequest.MY_QNAME,factory));
+ return emptyEnvelope;
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+
+ /* methods to provide back word compatibility */
+
+
+
+ private org.apache.axiom.soap.SOAPEnvelope toEnvelope(org.apache.axiom.soap.SOAPFactory factory, com.frentix.olat.vitero.manager.stubs.GroupServiceStub.UpdateGroupRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault{
+
+
+ try{
+
+ org.apache.axiom.soap.SOAPEnvelope emptyEnvelope = factory.getDefaultEnvelope();
+ emptyEnvelope.getBody().addChild(param.getOMElement(com.frentix.olat.vitero.manager.stubs.GroupServiceStub.UpdateGroupRequest.MY_QNAME,factory));
+ return emptyEnvelope;
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+
+ /* methods to provide back word compatibility */
+
+
+
+ private org.apache.axiom.soap.SOAPEnvelope toEnvelope(org.apache.axiom.soap.SOAPFactory factory, com.frentix.olat.vitero.manager.stubs.GroupServiceStub.RemoveUserFromGroupRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault{
+
+
+ try{
+
+ org.apache.axiom.soap.SOAPEnvelope emptyEnvelope = factory.getDefaultEnvelope();
+ emptyEnvelope.getBody().addChild(param.getOMElement(com.frentix.olat.vitero.manager.stubs.GroupServiceStub.RemoveUserFromGroupRequest.MY_QNAME,factory));
+ return emptyEnvelope;
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+
+ /* methods to provide back word compatibility */
+
+
+
+ private org.apache.axiom.soap.SOAPEnvelope toEnvelope(org.apache.axiom.soap.SOAPFactory factory, com.frentix.olat.vitero.manager.stubs.GroupServiceStub.ChangeGroupRoleRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault{
+
+
+ try{
+
+ org.apache.axiom.soap.SOAPEnvelope emptyEnvelope = factory.getDefaultEnvelope();
+ emptyEnvelope.getBody().addChild(param.getOMElement(com.frentix.olat.vitero.manager.stubs.GroupServiceStub.ChangeGroupRoleRequest.MY_QNAME,factory));
+ return emptyEnvelope;
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+
+ /* methods to provide back word compatibility */
+
+
+
+ private org.apache.axiom.soap.SOAPEnvelope toEnvelope(org.apache.axiom.soap.SOAPFactory factory, com.frentix.olat.vitero.manager.stubs.GroupServiceStub.GetGroupRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault{
+
+
+ try{
+
+ org.apache.axiom.soap.SOAPEnvelope emptyEnvelope = factory.getDefaultEnvelope();
+ emptyEnvelope.getBody().addChild(param.getOMElement(com.frentix.olat.vitero.manager.stubs.GroupServiceStub.GetGroupRequest.MY_QNAME,factory));
+ return emptyEnvelope;
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+
+ /* methods to provide back word compatibility */
+
+
+
+ private org.apache.axiom.soap.SOAPEnvelope toEnvelope(org.apache.axiom.soap.SOAPFactory factory, com.frentix.olat.vitero.manager.stubs.GroupServiceStub.CreateGroupRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault{
+
+
+ try{
+
+ org.apache.axiom.soap.SOAPEnvelope emptyEnvelope = factory.getDefaultEnvelope();
+ emptyEnvelope.getBody().addChild(param.getOMElement(com.frentix.olat.vitero.manager.stubs.GroupServiceStub.CreateGroupRequest.MY_QNAME,factory));
+ return emptyEnvelope;
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+
+ /* methods to provide back word compatibility */
+
+
+
+
+ /**
+ * get the default envelope
+ */
+ private org.apache.axiom.soap.SOAPEnvelope toEnvelope(org.apache.axiom.soap.SOAPFactory factory){
+ return factory.getDefaultEnvelope();
+ }
+
+
+ private java.lang.Object fromOM(
+ org.apache.axiom.om.OMElement param,
+ java.lang.Class type,
+ java.util.Map extraNamespaces) throws org.apache.axis2.AxisFault{
+
+ try {
+
+ if (com.frentix.olat.vitero.manager.stubs.GroupServiceStub.AddUserToGroupRequest.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.GroupServiceStub.AddUserToGroupRequest.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ if (com.frentix.olat.vitero.manager.stubs.GroupServiceStub.GetGroupListByCustomerRequest.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.GroupServiceStub.GetGroupListByCustomerRequest.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ if (com.frentix.olat.vitero.manager.stubs.GroupServiceStub.GetGroupListByCustomerResponse.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.GroupServiceStub.GetGroupListByCustomerResponse.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ if (com.frentix.olat.vitero.manager.stubs.GroupServiceStub.GetGroupByNameRequest.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.GroupServiceStub.GetGroupByNameRequest.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ if (com.frentix.olat.vitero.manager.stubs.GroupServiceStub.GetGroupByNameResponse.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.GroupServiceStub.GetGroupByNameResponse.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ if (com.frentix.olat.vitero.manager.stubs.GroupServiceStub.SuccessResponse.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.GroupServiceStub.SuccessResponse.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ if (com.frentix.olat.vitero.manager.stubs.GroupServiceStub.DeleteGroupRequest.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.GroupServiceStub.DeleteGroupRequest.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ if (com.frentix.olat.vitero.manager.stubs.GroupServiceStub.UpdateGroupRequest.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.GroupServiceStub.UpdateGroupRequest.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ if (com.frentix.olat.vitero.manager.stubs.GroupServiceStub.RemoveUserFromGroupRequest.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.GroupServiceStub.RemoveUserFromGroupRequest.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ if (com.frentix.olat.vitero.manager.stubs.GroupServiceStub.ChangeGroupRoleRequest.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.GroupServiceStub.ChangeGroupRoleRequest.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ if (com.frentix.olat.vitero.manager.stubs.GroupServiceStub.GetGroupRequest.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.GroupServiceStub.GetGroupRequest.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ if (com.frentix.olat.vitero.manager.stubs.GroupServiceStub.GetGroupResponse.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.GroupServiceStub.GetGroupResponse.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ if (com.frentix.olat.vitero.manager.stubs.GroupServiceStub.CreateGroupRequest.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.GroupServiceStub.CreateGroupRequest.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ if (com.frentix.olat.vitero.manager.stubs.GroupServiceStub.CreateGroupResponse.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.GroupServiceStub.CreateGroupResponse.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ } catch (java.lang.Exception e) {
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+ return null;
+ }
+
+
+
+
+ }
+
\ No newline at end of file
diff --git a/src/main/java/com/frentix/olat/vitero/manager/stubs/LicenceServiceCallbackHandler.java b/src/main/java/com/frentix/olat/vitero/manager/stubs/LicenceServiceCallbackHandler.java
new file mode 100644
index 0000000000000000000000000000000000000000..c9c2e76c520ac74cf695e68a8ea52e00ed20a03c
--- /dev/null
+++ b/src/main/java/com/frentix/olat/vitero/manager/stubs/LicenceServiceCallbackHandler.java
@@ -0,0 +1,148 @@
+
+/**
+ * LicenceServiceCallbackHandler.java
+ *
+ * This file was auto-generated from WSDL
+ * by the Apache Axis2 version: 1.4.1 Built on : Aug 13, 2008 (05:03:35 LKT)
+ */
+
+ package com.frentix.olat.vitero.manager.stubs;
+
+ /**
+ * LicenceServiceCallbackHandler Callback class, Users can extend this class and implement
+ * their own receiveResult and receiveError methods.
+ */
+ public abstract class LicenceServiceCallbackHandler{
+
+
+
+ protected Object clientData;
+
+ /**
+ * User can pass in any object that needs to be accessed once the NonBlocking
+ * Web service call is finished and appropriate method of this CallBack is called.
+ * @param clientData Object mechanism by which the user can pass in user data
+ * that will be avilable at the time this callback is called.
+ */
+ public LicenceServiceCallbackHandler(Object clientData){
+ this.clientData = clientData;
+ }
+
+ /**
+ * Please use this constructor if you don't want to set any clientData
+ */
+ public LicenceServiceCallbackHandler(){
+ this.clientData = null;
+ }
+
+ /**
+ * Get the client data
+ */
+
+ public Object getClientData() {
+ return clientData;
+ }
+
+
+ /**
+ * auto generated Axis2 call back method for getBookableModulesForGroup method
+ * override this method for handling normal response from getBookableModulesForGroup operation
+ */
+ public void receiveResultgetBookableModulesForGroup(
+ com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.GetBookableModulesForGroupResponse result
+ ) {
+ }
+
+ /**
+ * auto generated Axis2 Error handler
+ * override this method for handling error response from getBookableModulesForGroup operation
+ */
+ public void receiveErrorgetBookableModulesForGroup(java.lang.Exception e) {
+ }
+
+ // No methods generated for meps other than in-out
+
+ /**
+ * auto generated Axis2 call back method for groupHasBookableModule method
+ * override this method for handling normal response from groupHasBookableModule operation
+ */
+ public void receiveResultgroupHasBookableModule(
+ com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.GroupHasBookableModuleResponse result
+ ) {
+ }
+
+ /**
+ * auto generated Axis2 Error handler
+ * override this method for handling error response from groupHasBookableModule operation
+ */
+ public void receiveErrorgroupHasBookableModule(java.lang.Exception e) {
+ }
+
+ /**
+ * auto generated Axis2 call back method for getAllModules method
+ * override this method for handling normal response from getAllModules operation
+ */
+ public void receiveResultgetAllModules(
+ com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.GetAllModulesResponse result
+ ) {
+ }
+
+ /**
+ * auto generated Axis2 Error handler
+ * override this method for handling error response from getAllModules operation
+ */
+ public void receiveErrorgetAllModules(java.lang.Exception e) {
+ }
+
+ /**
+ * auto generated Axis2 call back method for getModulesForCustomer method
+ * override this method for handling normal response from getModulesForCustomer operation
+ */
+ public void receiveResultgetModulesForCustomer(
+ com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.GetModulesForCustomerResponse result
+ ) {
+ }
+
+ /**
+ * auto generated Axis2 Error handler
+ * override this method for handling error response from getModulesForCustomer operation
+ */
+ public void receiveErrorgetModulesForCustomer(java.lang.Exception e) {
+ }
+
+ /**
+ * auto generated Axis2 call back method for isPhoneAvailable method
+ * override this method for handling normal response from isPhoneAvailable operation
+ */
+ public void receiveResultisPhoneAvailable(
+ com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.IsPhoneAvailableResponse result
+ ) {
+ }
+
+ /**
+ * auto generated Axis2 Error handler
+ * override this method for handling error response from isPhoneAvailable operation
+ */
+ public void receiveErrorisPhoneAvailable(java.lang.Exception e) {
+ }
+
+ /**
+ * auto generated Axis2 call back method for getBookableRoomsForGroup method
+ * override this method for handling normal response from getBookableRoomsForGroup operation
+ */
+ public void receiveResultgetBookableRoomsForGroup(
+ com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.GetBookableRoomsForGroupResponse result
+ ) {
+ }
+
+ /**
+ * auto generated Axis2 Error handler
+ * override this method for handling error response from getBookableRoomsForGroup operation
+ */
+ public void receiveErrorgetBookableRoomsForGroup(java.lang.Exception e) {
+ }
+
+
+
+ }
+
\ No newline at end of file
diff --git a/src/main/java/com/frentix/olat/vitero/manager/stubs/LicenceServiceStub.java b/src/main/java/com/frentix/olat/vitero/manager/stubs/LicenceServiceStub.java
new file mode 100644
index 0000000000000000000000000000000000000000..8d061b67215052244c7397125cea0be42ed7857e
--- /dev/null
+++ b/src/main/java/com/frentix/olat/vitero/manager/stubs/LicenceServiceStub.java
@@ -0,0 +1,10997 @@
+
+/**
+ * LicenceServiceStub.java
+ *
+ * This file was auto-generated from WSDL
+ * by the Apache Axis2 version: 1.4.1 Built on : Aug 13, 2008 (05:03:35 LKT)
+ */
+ package com.frentix.olat.vitero.manager.stubs;
+
+
+
+ /*
+ * LicenceServiceStub java implementation
+ */
+
+
+ public class LicenceServiceStub extends org.apache.axis2.client.Stub
+ {
+ protected org.apache.axis2.description.AxisOperation[] _operations;
+
+ //hashmaps to keep the fault mapping
+ private java.util.HashMap faultExceptionNameMap = new java.util.HashMap();
+ private java.util.HashMap faultExceptionClassNameMap = new java.util.HashMap();
+ private java.util.HashMap faultMessageMap = new java.util.HashMap();
+
+ private static int counter = 0;
+
+ private static synchronized String getUniqueSuffix(){
+ // reset the counter if it is greater than 99999
+ if (counter > 99999){
+ counter = 0;
+ }
+ counter = counter + 1;
+ return Long.toString(System.currentTimeMillis()) + "_" + counter;
+ }
+
+
+ private void populateAxisService() throws org.apache.axis2.AxisFault {
+
+ //creating the Service with a unique name
+ _service = new org.apache.axis2.description.AxisService("LicenceService" + getUniqueSuffix());
+ addAnonymousOperations();
+
+ //creating the operations
+ org.apache.axis2.description.AxisOperation __operation;
+
+ _operations = new org.apache.axis2.description.AxisOperation[7];
+
+ __operation = new org.apache.axis2.description.OutInAxisOperation();
+
+
+ __operation.setName(new javax.xml.namespace.QName("http://www.vitero.de/schema/licence", "getBookableModulesForGroup"));
+ _service.addOperation(__operation);
+
+
+
+
+ _operations[0]=__operation;
+
+
+ __operation = new org.apache.axis2.description.OutInAxisOperation();
+
+
+ __operation.setName(new javax.xml.namespace.QName("http://www.vitero.de/schema/licence", "success"));
+ _service.addOperation(__operation);
+
+
+
+
+ _operations[1]=__operation;
+
+
+ __operation = new org.apache.axis2.description.OutInAxisOperation();
+
+
+ __operation.setName(new javax.xml.namespace.QName("http://www.vitero.de/schema/licence", "groupHasBookableModule"));
+ _service.addOperation(__operation);
+
+
+
+
+ _operations[2]=__operation;
+
+
+ __operation = new org.apache.axis2.description.OutInAxisOperation();
+
+
+ __operation.setName(new javax.xml.namespace.QName("http://www.vitero.de/schema/licence", "getAllModules"));
+ _service.addOperation(__operation);
+
+
+
+
+ _operations[3]=__operation;
+
+
+ __operation = new org.apache.axis2.description.OutInAxisOperation();
+
+
+ __operation.setName(new javax.xml.namespace.QName("http://www.vitero.de/schema/licence", "getModulesForCustomer"));
+ _service.addOperation(__operation);
+
+
+
+
+ _operations[4]=__operation;
+
+
+ __operation = new org.apache.axis2.description.OutInAxisOperation();
+
+
+ __operation.setName(new javax.xml.namespace.QName("http://www.vitero.de/schema/licence", "isPhoneAvailable"));
+ _service.addOperation(__operation);
+
+
+
+
+ _operations[5]=__operation;
+
+
+ __operation = new org.apache.axis2.description.OutInAxisOperation();
+
+
+ __operation.setName(new javax.xml.namespace.QName("http://www.vitero.de/schema/licence", "getBookableRoomsForGroup"));
+ _service.addOperation(__operation);
+
+
+
+
+ _operations[6]=__operation;
+
+
+ }
+
+ //populates the faults
+ private void populateFaults(){
+
+
+
+ }
+
+ /**
+ *Constructor that takes in a configContext
+ */
+
+ public LicenceServiceStub(org.apache.axis2.context.ConfigurationContext configurationContext,
+ java.lang.String targetEndpoint)
+ throws org.apache.axis2.AxisFault {
+ this(configurationContext,targetEndpoint,false);
+ }
+
+
+ /**
+ * Constructor that takes in a configContext and useseperate listner
+ */
+ public LicenceServiceStub(org.apache.axis2.context.ConfigurationContext configurationContext,
+ java.lang.String targetEndpoint, boolean useSeparateListener)
+ throws org.apache.axis2.AxisFault {
+ //To populate AxisService
+ populateAxisService();
+ populateFaults();
+
+ _serviceClient = new org.apache.axis2.client.ServiceClient(configurationContext,_service);
+
+
+ configurationContext = _serviceClient.getServiceContext().getConfigurationContext();
+
+ _serviceClient.getOptions().setTo(new org.apache.axis2.addressing.EndpointReference(
+ targetEndpoint));
+ _serviceClient.getOptions().setUseSeparateListener(useSeparateListener);
+
+
+ }
+
+ /**
+ * Default Constructor
+ */
+ public LicenceServiceStub(org.apache.axis2.context.ConfigurationContext configurationContext) throws org.apache.axis2.AxisFault {
+
+ this(configurationContext,"http://192.168.1.54:8080/vitero/services/" );
+
+ }
+
+ /**
+ * Default Constructor
+ */
+ public LicenceServiceStub() throws org.apache.axis2.AxisFault {
+
+ this("http://192.168.1.54:8080/vitero/services/" );
+
+ }
+
+ /**
+ * Constructor taking the target endpoint
+ */
+ public LicenceServiceStub(java.lang.String targetEndpoint) throws org.apache.axis2.AxisFault {
+ this(null,targetEndpoint);
+ }
+
+
+
+
+ /**
+ * Auto generated method signature
+ *
+ * @see com.frentix.olat.vc.provider.vitero.stubs.LicenceService#getBookableModulesForGroup
+ * @param getBookableModulesForGroupRequest0
+
+ */
+
+
+
+ public com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.GetBookableModulesForGroupResponse getBookableModulesForGroup(
+
+ com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.GetBookableModulesForGroupRequest getBookableModulesForGroupRequest0)
+
+
+ throws java.rmi.RemoteException
+
+ {
+ org.apache.axis2.context.MessageContext _messageContext = null;
+ try{
+ org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[0].getName());
+ _operationClient.getOptions().setAction("\"\"");
+ _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true);
+
+
+
+ addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&");
+
+
+ // create a message context
+ _messageContext = new org.apache.axis2.context.MessageContext();
+
+
+
+ // create SOAP envelope with that payload
+ org.apache.axiom.soap.SOAPEnvelope env = null;
+
+
+ env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()),
+ getBookableModulesForGroupRequest0,
+ optimizeContent(new javax.xml.namespace.QName("http://www.vitero.de/schema/licence",
+ "getBookableModulesForGroup")));
+
+ //adding SOAP soap_headers
+ _serviceClient.addHeadersToEnvelope(env);
+ // set the message context with that soap envelope
+ _messageContext.setEnvelope(env);
+
+ // add the message contxt to the operation client
+ _operationClient.addMessageContext(_messageContext);
+
+ //execute the operation client
+ _operationClient.execute(true);
+
+
+ org.apache.axis2.context.MessageContext _returnMessageContext = _operationClient.getMessageContext(
+ org.apache.axis2.wsdl.WSDLConstants.MESSAGE_LABEL_IN_VALUE);
+ org.apache.axiom.soap.SOAPEnvelope _returnEnv = _returnMessageContext.getEnvelope();
+
+
+ java.lang.Object object = fromOM(
+ _returnEnv.getBody().getFirstElement() ,
+ com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.GetBookableModulesForGroupResponse.class,
+ getEnvelopeNamespaces(_returnEnv));
+
+
+ return (com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.GetBookableModulesForGroupResponse)object;
+
+ }catch(org.apache.axis2.AxisFault f){
+
+ org.apache.axiom.om.OMElement faultElt = f.getDetail();
+ if (faultElt!=null){
+ if (faultExceptionNameMap.containsKey(faultElt.getQName())){
+ //make the fault by reflection
+ try{
+ java.lang.String exceptionClassName = (java.lang.String)faultExceptionClassNameMap.get(faultElt.getQName());
+ java.lang.Class exceptionClass = java.lang.Class.forName(exceptionClassName);
+ java.lang.Exception ex=
+ (java.lang.Exception) exceptionClass.newInstance();
+ //message class
+ java.lang.String messageClassName = (java.lang.String)faultMessageMap.get(faultElt.getQName());
+ java.lang.Class messageClass = java.lang.Class.forName(messageClassName);
+ java.lang.Object messageObject = fromOM(faultElt,messageClass,null);
+ java.lang.reflect.Method m = exceptionClass.getMethod("setFaultMessage",
+ new java.lang.Class[]{messageClass});
+ m.invoke(ex,new java.lang.Object[]{messageObject});
+
+
+ throw new java.rmi.RemoteException(ex.getMessage(), ex);
+ }catch(java.lang.ClassCastException e){
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.ClassNotFoundException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ }catch (java.lang.NoSuchMethodException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.reflect.InvocationTargetException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.IllegalAccessException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.InstantiationException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ }
+ }else{
+ throw f;
+ }
+ }else{
+ throw f;
+ }
+ } finally {
+ _messageContext.getTransportOut().getSender().cleanup(_messageContext);
+ }
+ }
+
+ /**
+ * Auto generated method signature for Asynchronous Invocations
+ *
+ * @see com.frentix.olat.vc.provider.vitero.stubs.LicenceService#startgetBookableModulesForGroup
+ * @param getBookableModulesForGroupRequest0
+
+ */
+ public void startgetBookableModulesForGroup(
+
+ com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.GetBookableModulesForGroupRequest getBookableModulesForGroupRequest0,
+
+ final com.frentix.olat.vitero.manager.stubs.LicenceServiceCallbackHandler callback)
+
+ throws java.rmi.RemoteException{
+
+ org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[0].getName());
+ _operationClient.getOptions().setAction("\"\"");
+ _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true);
+
+
+
+ addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&");
+
+
+
+ // create SOAP envelope with that payload
+ org.apache.axiom.soap.SOAPEnvelope env=null;
+ final org.apache.axis2.context.MessageContext _messageContext = new org.apache.axis2.context.MessageContext();
+
+
+ //Style is Doc.
+
+
+ env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()),
+ getBookableModulesForGroupRequest0,
+ optimizeContent(new javax.xml.namespace.QName("http://www.vitero.de/schema/licence",
+ "getBookableModulesForGroup")));
+
+ // adding SOAP soap_headers
+ _serviceClient.addHeadersToEnvelope(env);
+ // create message context with that soap envelope
+ _messageContext.setEnvelope(env);
+
+ // add the message context to the operation client
+ _operationClient.addMessageContext(_messageContext);
+
+
+
+ _operationClient.setCallback(new org.apache.axis2.client.async.AxisCallback() {
+ public void onMessage(org.apache.axis2.context.MessageContext resultContext) {
+ try {
+ org.apache.axiom.soap.SOAPEnvelope resultEnv = resultContext.getEnvelope();
+
+ java.lang.Object object = fromOM(resultEnv.getBody().getFirstElement(),
+ com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.GetBookableModulesForGroupResponse.class,
+ getEnvelopeNamespaces(resultEnv));
+ callback.receiveResultgetBookableModulesForGroup(
+ (com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.GetBookableModulesForGroupResponse)object);
+
+ } catch (org.apache.axis2.AxisFault e) {
+ callback.receiveErrorgetBookableModulesForGroup(e);
+ }
+ }
+
+ public void onError(java.lang.Exception error) {
+ if (error instanceof org.apache.axis2.AxisFault) {
+ org.apache.axis2.AxisFault f = (org.apache.axis2.AxisFault) error;
+ org.apache.axiom.om.OMElement faultElt = f.getDetail();
+ if (faultElt!=null){
+ if (faultExceptionNameMap.containsKey(faultElt.getQName())){
+ //make the fault by reflection
+ try{
+ java.lang.String exceptionClassName = (java.lang.String)faultExceptionClassNameMap.get(faultElt.getQName());
+ java.lang.Class exceptionClass = java.lang.Class.forName(exceptionClassName);
+ java.lang.Exception ex=
+ (java.lang.Exception) exceptionClass.newInstance();
+ //message class
+ java.lang.String messageClassName = (java.lang.String)faultMessageMap.get(faultElt.getQName());
+ java.lang.Class messageClass = java.lang.Class.forName(messageClassName);
+ java.lang.Object messageObject = fromOM(faultElt,messageClass,null);
+ java.lang.reflect.Method m = exceptionClass.getMethod("setFaultMessage",
+ new java.lang.Class[]{messageClass});
+ m.invoke(ex,new java.lang.Object[]{messageObject});
+
+
+ callback.receiveErrorgetBookableModulesForGroup(new java.rmi.RemoteException(ex.getMessage(), ex));
+ } catch(java.lang.ClassCastException e){
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetBookableModulesForGroup(f);
+ } catch (java.lang.ClassNotFoundException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetBookableModulesForGroup(f);
+ } catch (java.lang.NoSuchMethodException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetBookableModulesForGroup(f);
+ } catch (java.lang.reflect.InvocationTargetException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetBookableModulesForGroup(f);
+ } catch (java.lang.IllegalAccessException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetBookableModulesForGroup(f);
+ } catch (java.lang.InstantiationException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetBookableModulesForGroup(f);
+ } catch (org.apache.axis2.AxisFault e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetBookableModulesForGroup(f);
+ }
+ } else {
+ callback.receiveErrorgetBookableModulesForGroup(f);
+ }
+ } else {
+ callback.receiveErrorgetBookableModulesForGroup(f);
+ }
+ } else {
+ callback.receiveErrorgetBookableModulesForGroup(error);
+ }
+ }
+
+ public void onFault(org.apache.axis2.context.MessageContext faultContext) {
+ org.apache.axis2.AxisFault fault = org.apache.axis2.util.Utils.getInboundFaultFromMessageContext(faultContext);
+ onError(fault);
+ }
+
+ public void onComplete() {
+ try {
+ _messageContext.getTransportOut().getSender().cleanup(_messageContext);
+ } catch (org.apache.axis2.AxisFault axisFault) {
+ callback.receiveErrorgetBookableModulesForGroup(axisFault);
+ }
+ }
+ });
+
+
+ org.apache.axis2.util.CallbackReceiver _callbackReceiver = null;
+ if ( _operations[0].getMessageReceiver()==null && _operationClient.getOptions().isUseSeparateListener()) {
+ _callbackReceiver = new org.apache.axis2.util.CallbackReceiver();
+ _operations[0].setMessageReceiver(
+ _callbackReceiver);
+ }
+
+ //execute the operation client
+ _operationClient.execute(false);
+
+ }
+
+ /**
+ * Auto generated method signature
+ *
+ * @see com.frentix.olat.vc.provider.vitero.stubs.LicenceService#groupHasBookableModule
+ * @param groupHasBookableModuleRequest3
+
+ */
+
+
+
+ public com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.GroupHasBookableModuleResponse groupHasBookableModule(
+
+ com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.GroupHasBookableModuleRequest groupHasBookableModuleRequest3)
+
+
+ throws java.rmi.RemoteException
+
+ {
+ org.apache.axis2.context.MessageContext _messageContext = null;
+ try{
+ org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[2].getName());
+ _operationClient.getOptions().setAction("\"\"");
+ _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true);
+
+
+
+ addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&");
+
+
+ // create a message context
+ _messageContext = new org.apache.axis2.context.MessageContext();
+
+
+
+ // create SOAP envelope with that payload
+ org.apache.axiom.soap.SOAPEnvelope env = null;
+
+
+ env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()),
+ groupHasBookableModuleRequest3,
+ optimizeContent(new javax.xml.namespace.QName("http://www.vitero.de/schema/licence",
+ "groupHasBookableModule")));
+
+ //adding SOAP soap_headers
+ _serviceClient.addHeadersToEnvelope(env);
+ // set the message context with that soap envelope
+ _messageContext.setEnvelope(env);
+
+ // add the message contxt to the operation client
+ _operationClient.addMessageContext(_messageContext);
+
+ //execute the operation client
+ _operationClient.execute(true);
+
+
+ org.apache.axis2.context.MessageContext _returnMessageContext = _operationClient.getMessageContext(
+ org.apache.axis2.wsdl.WSDLConstants.MESSAGE_LABEL_IN_VALUE);
+ org.apache.axiom.soap.SOAPEnvelope _returnEnv = _returnMessageContext.getEnvelope();
+
+
+ java.lang.Object object = fromOM(
+ _returnEnv.getBody().getFirstElement() ,
+ com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.GroupHasBookableModuleResponse.class,
+ getEnvelopeNamespaces(_returnEnv));
+
+
+ return (com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.GroupHasBookableModuleResponse)object;
+
+ }catch(org.apache.axis2.AxisFault f){
+
+ org.apache.axiom.om.OMElement faultElt = f.getDetail();
+ if (faultElt!=null){
+ if (faultExceptionNameMap.containsKey(faultElt.getQName())){
+ //make the fault by reflection
+ try{
+ java.lang.String exceptionClassName = (java.lang.String)faultExceptionClassNameMap.get(faultElt.getQName());
+ java.lang.Class exceptionClass = java.lang.Class.forName(exceptionClassName);
+ java.lang.Exception ex=
+ (java.lang.Exception) exceptionClass.newInstance();
+ //message class
+ java.lang.String messageClassName = (java.lang.String)faultMessageMap.get(faultElt.getQName());
+ java.lang.Class messageClass = java.lang.Class.forName(messageClassName);
+ java.lang.Object messageObject = fromOM(faultElt,messageClass,null);
+ java.lang.reflect.Method m = exceptionClass.getMethod("setFaultMessage",
+ new java.lang.Class[]{messageClass});
+ m.invoke(ex,new java.lang.Object[]{messageObject});
+
+
+ throw new java.rmi.RemoteException(ex.getMessage(), ex);
+ }catch(java.lang.ClassCastException e){
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.ClassNotFoundException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ }catch (java.lang.NoSuchMethodException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.reflect.InvocationTargetException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.IllegalAccessException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.InstantiationException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ }
+ }else{
+ throw f;
+ }
+ }else{
+ throw f;
+ }
+ } finally {
+ _messageContext.getTransportOut().getSender().cleanup(_messageContext);
+ }
+ }
+
+ /**
+ * Auto generated method signature for Asynchronous Invocations
+ *
+ * @see com.frentix.olat.vc.provider.vitero.stubs.LicenceService#startgroupHasBookableModule
+ * @param groupHasBookableModuleRequest3
+
+ */
+ public void startgroupHasBookableModule(
+
+ com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.GroupHasBookableModuleRequest groupHasBookableModuleRequest3,
+
+ final com.frentix.olat.vitero.manager.stubs.LicenceServiceCallbackHandler callback)
+
+ throws java.rmi.RemoteException{
+
+ org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[2].getName());
+ _operationClient.getOptions().setAction("\"\"");
+ _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true);
+
+
+
+ addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&");
+
+
+
+ // create SOAP envelope with that payload
+ org.apache.axiom.soap.SOAPEnvelope env=null;
+ final org.apache.axis2.context.MessageContext _messageContext = new org.apache.axis2.context.MessageContext();
+
+
+ //Style is Doc.
+
+
+ env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()),
+ groupHasBookableModuleRequest3,
+ optimizeContent(new javax.xml.namespace.QName("http://www.vitero.de/schema/licence",
+ "groupHasBookableModule")));
+
+ // adding SOAP soap_headers
+ _serviceClient.addHeadersToEnvelope(env);
+ // create message context with that soap envelope
+ _messageContext.setEnvelope(env);
+
+ // add the message context to the operation client
+ _operationClient.addMessageContext(_messageContext);
+
+
+
+ _operationClient.setCallback(new org.apache.axis2.client.async.AxisCallback() {
+ public void onMessage(org.apache.axis2.context.MessageContext resultContext) {
+ try {
+ org.apache.axiom.soap.SOAPEnvelope resultEnv = resultContext.getEnvelope();
+
+ java.lang.Object object = fromOM(resultEnv.getBody().getFirstElement(),
+ com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.GroupHasBookableModuleResponse.class,
+ getEnvelopeNamespaces(resultEnv));
+ callback.receiveResultgroupHasBookableModule(
+ (com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.GroupHasBookableModuleResponse)object);
+
+ } catch (org.apache.axis2.AxisFault e) {
+ callback.receiveErrorgroupHasBookableModule(e);
+ }
+ }
+
+ public void onError(java.lang.Exception error) {
+ if (error instanceof org.apache.axis2.AxisFault) {
+ org.apache.axis2.AxisFault f = (org.apache.axis2.AxisFault) error;
+ org.apache.axiom.om.OMElement faultElt = f.getDetail();
+ if (faultElt!=null){
+ if (faultExceptionNameMap.containsKey(faultElt.getQName())){
+ //make the fault by reflection
+ try{
+ java.lang.String exceptionClassName = (java.lang.String)faultExceptionClassNameMap.get(faultElt.getQName());
+ java.lang.Class exceptionClass = java.lang.Class.forName(exceptionClassName);
+ java.lang.Exception ex=
+ (java.lang.Exception) exceptionClass.newInstance();
+ //message class
+ java.lang.String messageClassName = (java.lang.String)faultMessageMap.get(faultElt.getQName());
+ java.lang.Class messageClass = java.lang.Class.forName(messageClassName);
+ java.lang.Object messageObject = fromOM(faultElt,messageClass,null);
+ java.lang.reflect.Method m = exceptionClass.getMethod("setFaultMessage",
+ new java.lang.Class[]{messageClass});
+ m.invoke(ex,new java.lang.Object[]{messageObject});
+
+
+ callback.receiveErrorgroupHasBookableModule(new java.rmi.RemoteException(ex.getMessage(), ex));
+ } catch(java.lang.ClassCastException e){
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgroupHasBookableModule(f);
+ } catch (java.lang.ClassNotFoundException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgroupHasBookableModule(f);
+ } catch (java.lang.NoSuchMethodException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgroupHasBookableModule(f);
+ } catch (java.lang.reflect.InvocationTargetException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgroupHasBookableModule(f);
+ } catch (java.lang.IllegalAccessException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgroupHasBookableModule(f);
+ } catch (java.lang.InstantiationException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgroupHasBookableModule(f);
+ } catch (org.apache.axis2.AxisFault e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgroupHasBookableModule(f);
+ }
+ } else {
+ callback.receiveErrorgroupHasBookableModule(f);
+ }
+ } else {
+ callback.receiveErrorgroupHasBookableModule(f);
+ }
+ } else {
+ callback.receiveErrorgroupHasBookableModule(error);
+ }
+ }
+
+ public void onFault(org.apache.axis2.context.MessageContext faultContext) {
+ org.apache.axis2.AxisFault fault = org.apache.axis2.util.Utils.getInboundFaultFromMessageContext(faultContext);
+ onError(fault);
+ }
+
+ public void onComplete() {
+ try {
+ _messageContext.getTransportOut().getSender().cleanup(_messageContext);
+ } catch (org.apache.axis2.AxisFault axisFault) {
+ callback.receiveErrorgroupHasBookableModule(axisFault);
+ }
+ }
+ });
+
+
+ org.apache.axis2.util.CallbackReceiver _callbackReceiver = null;
+ if ( _operations[2].getMessageReceiver()==null && _operationClient.getOptions().isUseSeparateListener()) {
+ _callbackReceiver = new org.apache.axis2.util.CallbackReceiver();
+ _operations[2].setMessageReceiver(
+ _callbackReceiver);
+ }
+
+ //execute the operation client
+ _operationClient.execute(false);
+
+ }
+
+ /**
+ * Auto generated method signature
+ *
+ * @see com.frentix.olat.vc.provider.vitero.stubs.LicenceService#getAllModules
+ * @param getAllModulesRequest5
+
+ */
+
+
+
+ public com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.GetAllModulesResponse getAllModules(
+
+ com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.GetAllModulesRequest getAllModulesRequest5)
+
+
+ throws java.rmi.RemoteException
+
+ {
+ org.apache.axis2.context.MessageContext _messageContext = null;
+ try{
+ org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[3].getName());
+ _operationClient.getOptions().setAction("\"\"");
+ _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true);
+
+
+
+ addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&");
+
+
+ // create a message context
+ _messageContext = new org.apache.axis2.context.MessageContext();
+
+
+
+ // create SOAP envelope with that payload
+ org.apache.axiom.soap.SOAPEnvelope env = null;
+
+
+ env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()),
+ getAllModulesRequest5,
+ optimizeContent(new javax.xml.namespace.QName("http://www.vitero.de/schema/licence",
+ "getAllModules")));
+
+ //adding SOAP soap_headers
+ _serviceClient.addHeadersToEnvelope(env);
+ // set the message context with that soap envelope
+ _messageContext.setEnvelope(env);
+
+ // add the message contxt to the operation client
+ _operationClient.addMessageContext(_messageContext);
+
+ //execute the operation client
+ _operationClient.execute(true);
+
+
+ org.apache.axis2.context.MessageContext _returnMessageContext = _operationClient.getMessageContext(
+ org.apache.axis2.wsdl.WSDLConstants.MESSAGE_LABEL_IN_VALUE);
+ org.apache.axiom.soap.SOAPEnvelope _returnEnv = _returnMessageContext.getEnvelope();
+
+
+ java.lang.Object object = fromOM(
+ _returnEnv.getBody().getFirstElement() ,
+ com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.GetAllModulesResponse.class,
+ getEnvelopeNamespaces(_returnEnv));
+
+
+ return (com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.GetAllModulesResponse)object;
+
+ }catch(org.apache.axis2.AxisFault f){
+
+ org.apache.axiom.om.OMElement faultElt = f.getDetail();
+ if (faultElt!=null){
+ if (faultExceptionNameMap.containsKey(faultElt.getQName())){
+ //make the fault by reflection
+ try{
+ java.lang.String exceptionClassName = (java.lang.String)faultExceptionClassNameMap.get(faultElt.getQName());
+ java.lang.Class exceptionClass = java.lang.Class.forName(exceptionClassName);
+ java.lang.Exception ex=
+ (java.lang.Exception) exceptionClass.newInstance();
+ //message class
+ java.lang.String messageClassName = (java.lang.String)faultMessageMap.get(faultElt.getQName());
+ java.lang.Class messageClass = java.lang.Class.forName(messageClassName);
+ java.lang.Object messageObject = fromOM(faultElt,messageClass,null);
+ java.lang.reflect.Method m = exceptionClass.getMethod("setFaultMessage",
+ new java.lang.Class[]{messageClass});
+ m.invoke(ex,new java.lang.Object[]{messageObject});
+
+
+ throw new java.rmi.RemoteException(ex.getMessage(), ex);
+ }catch(java.lang.ClassCastException e){
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.ClassNotFoundException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ }catch (java.lang.NoSuchMethodException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.reflect.InvocationTargetException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.IllegalAccessException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.InstantiationException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ }
+ }else{
+ throw f;
+ }
+ }else{
+ throw f;
+ }
+ } finally {
+ _messageContext.getTransportOut().getSender().cleanup(_messageContext);
+ }
+ }
+
+ /**
+ * Auto generated method signature for Asynchronous Invocations
+ *
+ * @see com.frentix.olat.vc.provider.vitero.stubs.LicenceService#startgetAllModules
+ * @param getAllModulesRequest5
+
+ */
+ public void startgetAllModules(
+
+ com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.GetAllModulesRequest getAllModulesRequest5,
+
+ final com.frentix.olat.vitero.manager.stubs.LicenceServiceCallbackHandler callback)
+
+ throws java.rmi.RemoteException{
+
+ org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[3].getName());
+ _operationClient.getOptions().setAction("\"\"");
+ _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true);
+
+
+
+ addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&");
+
+
+
+ // create SOAP envelope with that payload
+ org.apache.axiom.soap.SOAPEnvelope env=null;
+ final org.apache.axis2.context.MessageContext _messageContext = new org.apache.axis2.context.MessageContext();
+
+
+ //Style is Doc.
+
+
+ env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()),
+ getAllModulesRequest5,
+ optimizeContent(new javax.xml.namespace.QName("http://www.vitero.de/schema/licence",
+ "getAllModules")));
+
+ // adding SOAP soap_headers
+ _serviceClient.addHeadersToEnvelope(env);
+ // create message context with that soap envelope
+ _messageContext.setEnvelope(env);
+
+ // add the message context to the operation client
+ _operationClient.addMessageContext(_messageContext);
+
+
+
+ _operationClient.setCallback(new org.apache.axis2.client.async.AxisCallback() {
+ public void onMessage(org.apache.axis2.context.MessageContext resultContext) {
+ try {
+ org.apache.axiom.soap.SOAPEnvelope resultEnv = resultContext.getEnvelope();
+
+ java.lang.Object object = fromOM(resultEnv.getBody().getFirstElement(),
+ com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.GetAllModulesResponse.class,
+ getEnvelopeNamespaces(resultEnv));
+ callback.receiveResultgetAllModules(
+ (com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.GetAllModulesResponse)object);
+
+ } catch (org.apache.axis2.AxisFault e) {
+ callback.receiveErrorgetAllModules(e);
+ }
+ }
+
+ public void onError(java.lang.Exception error) {
+ if (error instanceof org.apache.axis2.AxisFault) {
+ org.apache.axis2.AxisFault f = (org.apache.axis2.AxisFault) error;
+ org.apache.axiom.om.OMElement faultElt = f.getDetail();
+ if (faultElt!=null){
+ if (faultExceptionNameMap.containsKey(faultElt.getQName())){
+ //make the fault by reflection
+ try{
+ java.lang.String exceptionClassName = (java.lang.String)faultExceptionClassNameMap.get(faultElt.getQName());
+ java.lang.Class exceptionClass = java.lang.Class.forName(exceptionClassName);
+ java.lang.Exception ex=
+ (java.lang.Exception) exceptionClass.newInstance();
+ //message class
+ java.lang.String messageClassName = (java.lang.String)faultMessageMap.get(faultElt.getQName());
+ java.lang.Class messageClass = java.lang.Class.forName(messageClassName);
+ java.lang.Object messageObject = fromOM(faultElt,messageClass,null);
+ java.lang.reflect.Method m = exceptionClass.getMethod("setFaultMessage",
+ new java.lang.Class[]{messageClass});
+ m.invoke(ex,new java.lang.Object[]{messageObject});
+
+
+ callback.receiveErrorgetAllModules(new java.rmi.RemoteException(ex.getMessage(), ex));
+ } catch(java.lang.ClassCastException e){
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetAllModules(f);
+ } catch (java.lang.ClassNotFoundException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetAllModules(f);
+ } catch (java.lang.NoSuchMethodException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetAllModules(f);
+ } catch (java.lang.reflect.InvocationTargetException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetAllModules(f);
+ } catch (java.lang.IllegalAccessException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetAllModules(f);
+ } catch (java.lang.InstantiationException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetAllModules(f);
+ } catch (org.apache.axis2.AxisFault e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetAllModules(f);
+ }
+ } else {
+ callback.receiveErrorgetAllModules(f);
+ }
+ } else {
+ callback.receiveErrorgetAllModules(f);
+ }
+ } else {
+ callback.receiveErrorgetAllModules(error);
+ }
+ }
+
+ public void onFault(org.apache.axis2.context.MessageContext faultContext) {
+ org.apache.axis2.AxisFault fault = org.apache.axis2.util.Utils.getInboundFaultFromMessageContext(faultContext);
+ onError(fault);
+ }
+
+ public void onComplete() {
+ try {
+ _messageContext.getTransportOut().getSender().cleanup(_messageContext);
+ } catch (org.apache.axis2.AxisFault axisFault) {
+ callback.receiveErrorgetAllModules(axisFault);
+ }
+ }
+ });
+
+
+ org.apache.axis2.util.CallbackReceiver _callbackReceiver = null;
+ if ( _operations[3].getMessageReceiver()==null && _operationClient.getOptions().isUseSeparateListener()) {
+ _callbackReceiver = new org.apache.axis2.util.CallbackReceiver();
+ _operations[3].setMessageReceiver(
+ _callbackReceiver);
+ }
+
+ //execute the operation client
+ _operationClient.execute(false);
+
+ }
+
+ /**
+ * Auto generated method signature
+ *
+ * @see com.frentix.olat.vc.provider.vitero.stubs.LicenceService#getModulesForCustomer
+ * @param getModulesForCustomerRequest7
+
+ */
+
+
+
+ public com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.GetModulesForCustomerResponse getModulesForCustomer(
+
+ com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.GetModulesForCustomerRequest getModulesForCustomerRequest7)
+
+
+ throws java.rmi.RemoteException
+
+ {
+ org.apache.axis2.context.MessageContext _messageContext = null;
+ try{
+ org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[4].getName());
+ _operationClient.getOptions().setAction("\"\"");
+ _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true);
+
+
+
+ addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&");
+
+
+ // create a message context
+ _messageContext = new org.apache.axis2.context.MessageContext();
+
+
+
+ // create SOAP envelope with that payload
+ org.apache.axiom.soap.SOAPEnvelope env = null;
+
+
+ env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()),
+ getModulesForCustomerRequest7,
+ optimizeContent(new javax.xml.namespace.QName("http://www.vitero.de/schema/licence",
+ "getModulesForCustomer")));
+
+ //adding SOAP soap_headers
+ _serviceClient.addHeadersToEnvelope(env);
+ // set the message context with that soap envelope
+ _messageContext.setEnvelope(env);
+
+ // add the message contxt to the operation client
+ _operationClient.addMessageContext(_messageContext);
+
+ //execute the operation client
+ _operationClient.execute(true);
+
+
+ org.apache.axis2.context.MessageContext _returnMessageContext = _operationClient.getMessageContext(
+ org.apache.axis2.wsdl.WSDLConstants.MESSAGE_LABEL_IN_VALUE);
+ org.apache.axiom.soap.SOAPEnvelope _returnEnv = _returnMessageContext.getEnvelope();
+
+
+ java.lang.Object object = fromOM(
+ _returnEnv.getBody().getFirstElement() ,
+ com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.GetModulesForCustomerResponse.class,
+ getEnvelopeNamespaces(_returnEnv));
+
+
+ return (com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.GetModulesForCustomerResponse)object;
+
+ }catch(org.apache.axis2.AxisFault f){
+
+ org.apache.axiom.om.OMElement faultElt = f.getDetail();
+ if (faultElt!=null){
+ if (faultExceptionNameMap.containsKey(faultElt.getQName())){
+ //make the fault by reflection
+ try{
+ java.lang.String exceptionClassName = (java.lang.String)faultExceptionClassNameMap.get(faultElt.getQName());
+ java.lang.Class exceptionClass = java.lang.Class.forName(exceptionClassName);
+ java.lang.Exception ex=
+ (java.lang.Exception) exceptionClass.newInstance();
+ //message class
+ java.lang.String messageClassName = (java.lang.String)faultMessageMap.get(faultElt.getQName());
+ java.lang.Class messageClass = java.lang.Class.forName(messageClassName);
+ java.lang.Object messageObject = fromOM(faultElt,messageClass,null);
+ java.lang.reflect.Method m = exceptionClass.getMethod("setFaultMessage",
+ new java.lang.Class[]{messageClass});
+ m.invoke(ex,new java.lang.Object[]{messageObject});
+
+
+ throw new java.rmi.RemoteException(ex.getMessage(), ex);
+ }catch(java.lang.ClassCastException e){
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.ClassNotFoundException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ }catch (java.lang.NoSuchMethodException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.reflect.InvocationTargetException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.IllegalAccessException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.InstantiationException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ }
+ }else{
+ throw f;
+ }
+ }else{
+ throw f;
+ }
+ } finally {
+ _messageContext.getTransportOut().getSender().cleanup(_messageContext);
+ }
+ }
+
+ /**
+ * Auto generated method signature for Asynchronous Invocations
+ *
+ * @see com.frentix.olat.vc.provider.vitero.stubs.LicenceService#startgetModulesForCustomer
+ * @param getModulesForCustomerRequest7
+
+ */
+ public void startgetModulesForCustomer(
+
+ com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.GetModulesForCustomerRequest getModulesForCustomerRequest7,
+
+ final com.frentix.olat.vitero.manager.stubs.LicenceServiceCallbackHandler callback)
+
+ throws java.rmi.RemoteException{
+
+ org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[4].getName());
+ _operationClient.getOptions().setAction("\"\"");
+ _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true);
+
+
+
+ addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&");
+
+
+
+ // create SOAP envelope with that payload
+ org.apache.axiom.soap.SOAPEnvelope env=null;
+ final org.apache.axis2.context.MessageContext _messageContext = new org.apache.axis2.context.MessageContext();
+
+
+ //Style is Doc.
+
+
+ env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()),
+ getModulesForCustomerRequest7,
+ optimizeContent(new javax.xml.namespace.QName("http://www.vitero.de/schema/licence",
+ "getModulesForCustomer")));
+
+ // adding SOAP soap_headers
+ _serviceClient.addHeadersToEnvelope(env);
+ // create message context with that soap envelope
+ _messageContext.setEnvelope(env);
+
+ // add the message context to the operation client
+ _operationClient.addMessageContext(_messageContext);
+
+
+
+ _operationClient.setCallback(new org.apache.axis2.client.async.AxisCallback() {
+ public void onMessage(org.apache.axis2.context.MessageContext resultContext) {
+ try {
+ org.apache.axiom.soap.SOAPEnvelope resultEnv = resultContext.getEnvelope();
+
+ java.lang.Object object = fromOM(resultEnv.getBody().getFirstElement(),
+ com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.GetModulesForCustomerResponse.class,
+ getEnvelopeNamespaces(resultEnv));
+ callback.receiveResultgetModulesForCustomer(
+ (com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.GetModulesForCustomerResponse)object);
+
+ } catch (org.apache.axis2.AxisFault e) {
+ callback.receiveErrorgetModulesForCustomer(e);
+ }
+ }
+
+ public void onError(java.lang.Exception error) {
+ if (error instanceof org.apache.axis2.AxisFault) {
+ org.apache.axis2.AxisFault f = (org.apache.axis2.AxisFault) error;
+ org.apache.axiom.om.OMElement faultElt = f.getDetail();
+ if (faultElt!=null){
+ if (faultExceptionNameMap.containsKey(faultElt.getQName())){
+ //make the fault by reflection
+ try{
+ java.lang.String exceptionClassName = (java.lang.String)faultExceptionClassNameMap.get(faultElt.getQName());
+ java.lang.Class exceptionClass = java.lang.Class.forName(exceptionClassName);
+ java.lang.Exception ex=
+ (java.lang.Exception) exceptionClass.newInstance();
+ //message class
+ java.lang.String messageClassName = (java.lang.String)faultMessageMap.get(faultElt.getQName());
+ java.lang.Class messageClass = java.lang.Class.forName(messageClassName);
+ java.lang.Object messageObject = fromOM(faultElt,messageClass,null);
+ java.lang.reflect.Method m = exceptionClass.getMethod("setFaultMessage",
+ new java.lang.Class[]{messageClass});
+ m.invoke(ex,new java.lang.Object[]{messageObject});
+
+
+ callback.receiveErrorgetModulesForCustomer(new java.rmi.RemoteException(ex.getMessage(), ex));
+ } catch(java.lang.ClassCastException e){
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetModulesForCustomer(f);
+ } catch (java.lang.ClassNotFoundException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetModulesForCustomer(f);
+ } catch (java.lang.NoSuchMethodException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetModulesForCustomer(f);
+ } catch (java.lang.reflect.InvocationTargetException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetModulesForCustomer(f);
+ } catch (java.lang.IllegalAccessException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetModulesForCustomer(f);
+ } catch (java.lang.InstantiationException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetModulesForCustomer(f);
+ } catch (org.apache.axis2.AxisFault e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetModulesForCustomer(f);
+ }
+ } else {
+ callback.receiveErrorgetModulesForCustomer(f);
+ }
+ } else {
+ callback.receiveErrorgetModulesForCustomer(f);
+ }
+ } else {
+ callback.receiveErrorgetModulesForCustomer(error);
+ }
+ }
+
+ public void onFault(org.apache.axis2.context.MessageContext faultContext) {
+ org.apache.axis2.AxisFault fault = org.apache.axis2.util.Utils.getInboundFaultFromMessageContext(faultContext);
+ onError(fault);
+ }
+
+ public void onComplete() {
+ try {
+ _messageContext.getTransportOut().getSender().cleanup(_messageContext);
+ } catch (org.apache.axis2.AxisFault axisFault) {
+ callback.receiveErrorgetModulesForCustomer(axisFault);
+ }
+ }
+ });
+
+
+ org.apache.axis2.util.CallbackReceiver _callbackReceiver = null;
+ if ( _operations[4].getMessageReceiver()==null && _operationClient.getOptions().isUseSeparateListener()) {
+ _callbackReceiver = new org.apache.axis2.util.CallbackReceiver();
+ _operations[4].setMessageReceiver(
+ _callbackReceiver);
+ }
+
+ //execute the operation client
+ _operationClient.execute(false);
+
+ }
+
+ /**
+ * Auto generated method signature
+ *
+ * @see com.frentix.olat.vc.provider.vitero.stubs.LicenceService#isPhoneAvailable
+ * @param isPhoneAvailableRequest9
+
+ */
+
+
+
+ public com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.IsPhoneAvailableResponse isPhoneAvailable(
+
+ com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.IsPhoneAvailableRequest isPhoneAvailableRequest9)
+
+
+ throws java.rmi.RemoteException
+
+ {
+ org.apache.axis2.context.MessageContext _messageContext = null;
+ try{
+ org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[5].getName());
+ _operationClient.getOptions().setAction("\"\"");
+ _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true);
+
+
+
+ addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&");
+
+
+ // create a message context
+ _messageContext = new org.apache.axis2.context.MessageContext();
+
+
+
+ // create SOAP envelope with that payload
+ org.apache.axiom.soap.SOAPEnvelope env = null;
+
+
+ env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()),
+ isPhoneAvailableRequest9,
+ optimizeContent(new javax.xml.namespace.QName("http://www.vitero.de/schema/licence",
+ "isPhoneAvailable")));
+
+ //adding SOAP soap_headers
+ _serviceClient.addHeadersToEnvelope(env);
+ // set the message context with that soap envelope
+ _messageContext.setEnvelope(env);
+
+ // add the message contxt to the operation client
+ _operationClient.addMessageContext(_messageContext);
+
+ //execute the operation client
+ _operationClient.execute(true);
+
+
+ org.apache.axis2.context.MessageContext _returnMessageContext = _operationClient.getMessageContext(
+ org.apache.axis2.wsdl.WSDLConstants.MESSAGE_LABEL_IN_VALUE);
+ org.apache.axiom.soap.SOAPEnvelope _returnEnv = _returnMessageContext.getEnvelope();
+
+
+ java.lang.Object object = fromOM(
+ _returnEnv.getBody().getFirstElement() ,
+ com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.IsPhoneAvailableResponse.class,
+ getEnvelopeNamespaces(_returnEnv));
+
+
+ return (com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.IsPhoneAvailableResponse)object;
+
+ }catch(org.apache.axis2.AxisFault f){
+
+ org.apache.axiom.om.OMElement faultElt = f.getDetail();
+ if (faultElt!=null){
+ if (faultExceptionNameMap.containsKey(faultElt.getQName())){
+ //make the fault by reflection
+ try{
+ java.lang.String exceptionClassName = (java.lang.String)faultExceptionClassNameMap.get(faultElt.getQName());
+ java.lang.Class exceptionClass = java.lang.Class.forName(exceptionClassName);
+ java.lang.Exception ex=
+ (java.lang.Exception) exceptionClass.newInstance();
+ //message class
+ java.lang.String messageClassName = (java.lang.String)faultMessageMap.get(faultElt.getQName());
+ java.lang.Class messageClass = java.lang.Class.forName(messageClassName);
+ java.lang.Object messageObject = fromOM(faultElt,messageClass,null);
+ java.lang.reflect.Method m = exceptionClass.getMethod("setFaultMessage",
+ new java.lang.Class[]{messageClass});
+ m.invoke(ex,new java.lang.Object[]{messageObject});
+
+
+ throw new java.rmi.RemoteException(ex.getMessage(), ex);
+ }catch(java.lang.ClassCastException e){
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.ClassNotFoundException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ }catch (java.lang.NoSuchMethodException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.reflect.InvocationTargetException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.IllegalAccessException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.InstantiationException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ }
+ }else{
+ throw f;
+ }
+ }else{
+ throw f;
+ }
+ } finally {
+ _messageContext.getTransportOut().getSender().cleanup(_messageContext);
+ }
+ }
+
+ /**
+ * Auto generated method signature for Asynchronous Invocations
+ *
+ * @see com.frentix.olat.vc.provider.vitero.stubs.LicenceService#startisPhoneAvailable
+ * @param isPhoneAvailableRequest9
+
+ */
+ public void startisPhoneAvailable(
+
+ com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.IsPhoneAvailableRequest isPhoneAvailableRequest9,
+
+ final com.frentix.olat.vitero.manager.stubs.LicenceServiceCallbackHandler callback)
+
+ throws java.rmi.RemoteException{
+
+ org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[5].getName());
+ _operationClient.getOptions().setAction("\"\"");
+ _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true);
+
+
+
+ addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&");
+
+
+
+ // create SOAP envelope with that payload
+ org.apache.axiom.soap.SOAPEnvelope env=null;
+ final org.apache.axis2.context.MessageContext _messageContext = new org.apache.axis2.context.MessageContext();
+
+
+ //Style is Doc.
+
+
+ env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()),
+ isPhoneAvailableRequest9,
+ optimizeContent(new javax.xml.namespace.QName("http://www.vitero.de/schema/licence",
+ "isPhoneAvailable")));
+
+ // adding SOAP soap_headers
+ _serviceClient.addHeadersToEnvelope(env);
+ // create message context with that soap envelope
+ _messageContext.setEnvelope(env);
+
+ // add the message context to the operation client
+ _operationClient.addMessageContext(_messageContext);
+
+
+
+ _operationClient.setCallback(new org.apache.axis2.client.async.AxisCallback() {
+ public void onMessage(org.apache.axis2.context.MessageContext resultContext) {
+ try {
+ org.apache.axiom.soap.SOAPEnvelope resultEnv = resultContext.getEnvelope();
+
+ java.lang.Object object = fromOM(resultEnv.getBody().getFirstElement(),
+ com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.IsPhoneAvailableResponse.class,
+ getEnvelopeNamespaces(resultEnv));
+ callback.receiveResultisPhoneAvailable(
+ (com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.IsPhoneAvailableResponse)object);
+
+ } catch (org.apache.axis2.AxisFault e) {
+ callback.receiveErrorisPhoneAvailable(e);
+ }
+ }
+
+ public void onError(java.lang.Exception error) {
+ if (error instanceof org.apache.axis2.AxisFault) {
+ org.apache.axis2.AxisFault f = (org.apache.axis2.AxisFault) error;
+ org.apache.axiom.om.OMElement faultElt = f.getDetail();
+ if (faultElt!=null){
+ if (faultExceptionNameMap.containsKey(faultElt.getQName())){
+ //make the fault by reflection
+ try{
+ java.lang.String exceptionClassName = (java.lang.String)faultExceptionClassNameMap.get(faultElt.getQName());
+ java.lang.Class exceptionClass = java.lang.Class.forName(exceptionClassName);
+ java.lang.Exception ex=
+ (java.lang.Exception) exceptionClass.newInstance();
+ //message class
+ java.lang.String messageClassName = (java.lang.String)faultMessageMap.get(faultElt.getQName());
+ java.lang.Class messageClass = java.lang.Class.forName(messageClassName);
+ java.lang.Object messageObject = fromOM(faultElt,messageClass,null);
+ java.lang.reflect.Method m = exceptionClass.getMethod("setFaultMessage",
+ new java.lang.Class[]{messageClass});
+ m.invoke(ex,new java.lang.Object[]{messageObject});
+
+
+ callback.receiveErrorisPhoneAvailable(new java.rmi.RemoteException(ex.getMessage(), ex));
+ } catch(java.lang.ClassCastException e){
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorisPhoneAvailable(f);
+ } catch (java.lang.ClassNotFoundException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorisPhoneAvailable(f);
+ } catch (java.lang.NoSuchMethodException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorisPhoneAvailable(f);
+ } catch (java.lang.reflect.InvocationTargetException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorisPhoneAvailable(f);
+ } catch (java.lang.IllegalAccessException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorisPhoneAvailable(f);
+ } catch (java.lang.InstantiationException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorisPhoneAvailable(f);
+ } catch (org.apache.axis2.AxisFault e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorisPhoneAvailable(f);
+ }
+ } else {
+ callback.receiveErrorisPhoneAvailable(f);
+ }
+ } else {
+ callback.receiveErrorisPhoneAvailable(f);
+ }
+ } else {
+ callback.receiveErrorisPhoneAvailable(error);
+ }
+ }
+
+ public void onFault(org.apache.axis2.context.MessageContext faultContext) {
+ org.apache.axis2.AxisFault fault = org.apache.axis2.util.Utils.getInboundFaultFromMessageContext(faultContext);
+ onError(fault);
+ }
+
+ public void onComplete() {
+ try {
+ _messageContext.getTransportOut().getSender().cleanup(_messageContext);
+ } catch (org.apache.axis2.AxisFault axisFault) {
+ callback.receiveErrorisPhoneAvailable(axisFault);
+ }
+ }
+ });
+
+
+ org.apache.axis2.util.CallbackReceiver _callbackReceiver = null;
+ if ( _operations[5].getMessageReceiver()==null && _operationClient.getOptions().isUseSeparateListener()) {
+ _callbackReceiver = new org.apache.axis2.util.CallbackReceiver();
+ _operations[5].setMessageReceiver(
+ _callbackReceiver);
+ }
+
+ //execute the operation client
+ _operationClient.execute(false);
+
+ }
+
+ /**
+ * Auto generated method signature
+ *
+ * @see com.frentix.olat.vc.provider.vitero.stubs.LicenceService#getBookableRoomsForGroup
+ * @param getBookableRoomsForGroupRequest11
+
+ */
+
+
+
+ public com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.GetBookableRoomsForGroupResponse getBookableRoomsForGroup(
+
+ com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.GetBookableRoomsForGroupRequest getBookableRoomsForGroupRequest11)
+
+
+ throws java.rmi.RemoteException
+
+ {
+ org.apache.axis2.context.MessageContext _messageContext = null;
+ try{
+ org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[6].getName());
+ _operationClient.getOptions().setAction("\"\"");
+ _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true);
+
+
+
+ addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&");
+
+
+ // create a message context
+ _messageContext = new org.apache.axis2.context.MessageContext();
+
+
+
+ // create SOAP envelope with that payload
+ org.apache.axiom.soap.SOAPEnvelope env = null;
+
+
+ env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()),
+ getBookableRoomsForGroupRequest11,
+ optimizeContent(new javax.xml.namespace.QName("http://www.vitero.de/schema/licence",
+ "getBookableRoomsForGroup")));
+
+ //adding SOAP soap_headers
+ _serviceClient.addHeadersToEnvelope(env);
+ // set the message context with that soap envelope
+ _messageContext.setEnvelope(env);
+
+ // add the message contxt to the operation client
+ _operationClient.addMessageContext(_messageContext);
+
+ //execute the operation client
+ _operationClient.execute(true);
+
+
+ org.apache.axis2.context.MessageContext _returnMessageContext = _operationClient.getMessageContext(
+ org.apache.axis2.wsdl.WSDLConstants.MESSAGE_LABEL_IN_VALUE);
+ org.apache.axiom.soap.SOAPEnvelope _returnEnv = _returnMessageContext.getEnvelope();
+
+
+ java.lang.Object object = fromOM(
+ _returnEnv.getBody().getFirstElement() ,
+ com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.GetBookableRoomsForGroupResponse.class,
+ getEnvelopeNamespaces(_returnEnv));
+
+
+ return (com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.GetBookableRoomsForGroupResponse)object;
+
+ }catch(org.apache.axis2.AxisFault f){
+
+ org.apache.axiom.om.OMElement faultElt = f.getDetail();
+ if (faultElt!=null){
+ if (faultExceptionNameMap.containsKey(faultElt.getQName())){
+ //make the fault by reflection
+ try{
+ java.lang.String exceptionClassName = (java.lang.String)faultExceptionClassNameMap.get(faultElt.getQName());
+ java.lang.Class exceptionClass = java.lang.Class.forName(exceptionClassName);
+ java.lang.Exception ex=
+ (java.lang.Exception) exceptionClass.newInstance();
+ //message class
+ java.lang.String messageClassName = (java.lang.String)faultMessageMap.get(faultElt.getQName());
+ java.lang.Class messageClass = java.lang.Class.forName(messageClassName);
+ java.lang.Object messageObject = fromOM(faultElt,messageClass,null);
+ java.lang.reflect.Method m = exceptionClass.getMethod("setFaultMessage",
+ new java.lang.Class[]{messageClass});
+ m.invoke(ex,new java.lang.Object[]{messageObject});
+
+
+ throw new java.rmi.RemoteException(ex.getMessage(), ex);
+ }catch(java.lang.ClassCastException e){
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.ClassNotFoundException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ }catch (java.lang.NoSuchMethodException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.reflect.InvocationTargetException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.IllegalAccessException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.InstantiationException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ }
+ }else{
+ throw f;
+ }
+ }else{
+ throw f;
+ }
+ } finally {
+ _messageContext.getTransportOut().getSender().cleanup(_messageContext);
+ }
+ }
+
+ /**
+ * Auto generated method signature for Asynchronous Invocations
+ *
+ * @see com.frentix.olat.vc.provider.vitero.stubs.LicenceService#startgetBookableRoomsForGroup
+ * @param getBookableRoomsForGroupRequest11
+
+ */
+ public void startgetBookableRoomsForGroup(
+
+ com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.GetBookableRoomsForGroupRequest getBookableRoomsForGroupRequest11,
+
+ final com.frentix.olat.vitero.manager.stubs.LicenceServiceCallbackHandler callback)
+
+ throws java.rmi.RemoteException{
+
+ org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[6].getName());
+ _operationClient.getOptions().setAction("\"\"");
+ _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true);
+
+
+
+ addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&");
+
+
+
+ // create SOAP envelope with that payload
+ org.apache.axiom.soap.SOAPEnvelope env=null;
+ final org.apache.axis2.context.MessageContext _messageContext = new org.apache.axis2.context.MessageContext();
+
+
+ //Style is Doc.
+
+
+ env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()),
+ getBookableRoomsForGroupRequest11,
+ optimizeContent(new javax.xml.namespace.QName("http://www.vitero.de/schema/licence",
+ "getBookableRoomsForGroup")));
+
+ // adding SOAP soap_headers
+ _serviceClient.addHeadersToEnvelope(env);
+ // create message context with that soap envelope
+ _messageContext.setEnvelope(env);
+
+ // add the message context to the operation client
+ _operationClient.addMessageContext(_messageContext);
+
+
+
+ _operationClient.setCallback(new org.apache.axis2.client.async.AxisCallback() {
+ public void onMessage(org.apache.axis2.context.MessageContext resultContext) {
+ try {
+ org.apache.axiom.soap.SOAPEnvelope resultEnv = resultContext.getEnvelope();
+
+ java.lang.Object object = fromOM(resultEnv.getBody().getFirstElement(),
+ com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.GetBookableRoomsForGroupResponse.class,
+ getEnvelopeNamespaces(resultEnv));
+ callback.receiveResultgetBookableRoomsForGroup(
+ (com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.GetBookableRoomsForGroupResponse)object);
+
+ } catch (org.apache.axis2.AxisFault e) {
+ callback.receiveErrorgetBookableRoomsForGroup(e);
+ }
+ }
+
+ public void onError(java.lang.Exception error) {
+ if (error instanceof org.apache.axis2.AxisFault) {
+ org.apache.axis2.AxisFault f = (org.apache.axis2.AxisFault) error;
+ org.apache.axiom.om.OMElement faultElt = f.getDetail();
+ if (faultElt!=null){
+ if (faultExceptionNameMap.containsKey(faultElt.getQName())){
+ //make the fault by reflection
+ try{
+ java.lang.String exceptionClassName = (java.lang.String)faultExceptionClassNameMap.get(faultElt.getQName());
+ java.lang.Class exceptionClass = java.lang.Class.forName(exceptionClassName);
+ java.lang.Exception ex=
+ (java.lang.Exception) exceptionClass.newInstance();
+ //message class
+ java.lang.String messageClassName = (java.lang.String)faultMessageMap.get(faultElt.getQName());
+ java.lang.Class messageClass = java.lang.Class.forName(messageClassName);
+ java.lang.Object messageObject = fromOM(faultElt,messageClass,null);
+ java.lang.reflect.Method m = exceptionClass.getMethod("setFaultMessage",
+ new java.lang.Class[]{messageClass});
+ m.invoke(ex,new java.lang.Object[]{messageObject});
+
+
+ callback.receiveErrorgetBookableRoomsForGroup(new java.rmi.RemoteException(ex.getMessage(), ex));
+ } catch(java.lang.ClassCastException e){
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetBookableRoomsForGroup(f);
+ } catch (java.lang.ClassNotFoundException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetBookableRoomsForGroup(f);
+ } catch (java.lang.NoSuchMethodException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetBookableRoomsForGroup(f);
+ } catch (java.lang.reflect.InvocationTargetException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetBookableRoomsForGroup(f);
+ } catch (java.lang.IllegalAccessException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetBookableRoomsForGroup(f);
+ } catch (java.lang.InstantiationException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetBookableRoomsForGroup(f);
+ } catch (org.apache.axis2.AxisFault e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetBookableRoomsForGroup(f);
+ }
+ } else {
+ callback.receiveErrorgetBookableRoomsForGroup(f);
+ }
+ } else {
+ callback.receiveErrorgetBookableRoomsForGroup(f);
+ }
+ } else {
+ callback.receiveErrorgetBookableRoomsForGroup(error);
+ }
+ }
+
+ public void onFault(org.apache.axis2.context.MessageContext faultContext) {
+ org.apache.axis2.AxisFault fault = org.apache.axis2.util.Utils.getInboundFaultFromMessageContext(faultContext);
+ onError(fault);
+ }
+
+ public void onComplete() {
+ try {
+ _messageContext.getTransportOut().getSender().cleanup(_messageContext);
+ } catch (org.apache.axis2.AxisFault axisFault) {
+ callback.receiveErrorgetBookableRoomsForGroup(axisFault);
+ }
+ }
+ });
+
+
+ org.apache.axis2.util.CallbackReceiver _callbackReceiver = null;
+ if ( _operations[6].getMessageReceiver()==null && _operationClient.getOptions().isUseSeparateListener()) {
+ _callbackReceiver = new org.apache.axis2.util.CallbackReceiver();
+ _operations[6].setMessageReceiver(
+ _callbackReceiver);
+ }
+
+ //execute the operation client
+ _operationClient.execute(false);
+
+ }
+
+
+
+ /**
+ * A utility method that copies the namepaces from the SOAPEnvelope
+ */
+ private java.util.Map getEnvelopeNamespaces(org.apache.axiom.soap.SOAPEnvelope env){
+ java.util.Map returnMap = new java.util.HashMap();
+ java.util.Iterator namespaceIterator = env.getAllDeclaredNamespaces();
+ while (namespaceIterator.hasNext()) {
+ org.apache.axiom.om.OMNamespace ns = (org.apache.axiom.om.OMNamespace) namespaceIterator.next();
+ returnMap.put(ns.getPrefix(),ns.getNamespaceURI());
+ }
+ return returnMap;
+ }
+
+
+
+ private javax.xml.namespace.QName[] opNameArray = null;
+ private boolean optimizeContent(javax.xml.namespace.QName opName) {
+
+
+ if (opNameArray == null) {
+ return false;
+ }
+ for (int i = 0; i < opNameArray.length; i++) {
+ if (opName.equals(opNameArray[i])) {
+ return true;
+ }
+ }
+ return false;
+ }
+ //http://192.168.1.54:8080/vitero/services/
+ public static class GetBookableRoomsForGroupRequest
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/licence",
+ "getBookableRoomsForGroupRequest",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/licence")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for GetBookableRoomsForGroupRequest
+ */
+
+
+ protected Grouprequesttype localGetBookableRoomsForGroupRequest ;
+
+
+ /**
+ * Auto generated getter method
+ * @return Grouprequesttype
+ */
+ public Grouprequesttype getGetBookableRoomsForGroupRequest(){
+ return localGetBookableRoomsForGroupRequest;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param GetBookableRoomsForGroupRequest
+ */
+ public void setGetBookableRoomsForGroupRequest(Grouprequesttype param){
+
+ this.localGetBookableRoomsForGroupRequest=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ GetBookableRoomsForGroupRequest.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+ //We can safely assume an element has only one type associated with it
+
+ if (localGetBookableRoomsForGroupRequest==null){
+ throw new org.apache.axis2.databinding.ADBException("Property cannot be null!");
+ }
+ localGetBookableRoomsForGroupRequest.serialize(MY_QNAME,factory,xmlWriter);
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+
+ //We can safely assume an element has only one type associated with it
+ return localGetBookableRoomsForGroupRequest.getPullParser(MY_QNAME);
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static GetBookableRoomsForGroupRequest parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ GetBookableRoomsForGroupRequest object =
+ new GetBookableRoomsForGroupRequest();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/licence","getBookableRoomsForGroupRequest").equals(reader.getName())){
+
+ object.setGetBookableRoomsForGroupRequest(Grouprequesttype.Factory.parse(reader));
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class GetAllModulesRequest
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/licence",
+ "getAllModulesRequest",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/licence")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for End
+ */
+
+
+ protected java.lang.String localEnd ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localEndTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getEnd(){
+ return localEnd;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param End
+ */
+ public void setEnd(java.lang.String param){
+
+ if (param != null){
+ //update the setting tracker
+ localEndTracker = true;
+ } else {
+ localEndTracker = false;
+
+ }
+
+ this.localEnd=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ GetAllModulesRequest.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/licence");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":getAllModulesRequest",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "getAllModulesRequest",
+ xmlWriter);
+ }
+
+
+ }
+ if (localEndTracker){
+ namespace = "http://www.vitero.de/schema/licence";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"end", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"end");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("end");
+ }
+
+
+ if (localEnd==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("end cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localEnd);
+
+ }
+
+ xmlWriter.writeEndElement();
+ }
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+ if (localEndTracker){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/licence",
+ "end"));
+
+ if (localEnd != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localEnd));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("end cannot be null!!");
+ }
+ }
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static GetAllModulesRequest parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ GetAllModulesRequest object =
+ new GetAllModulesRequest();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"getAllModulesRequest".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (GetAllModulesRequest)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/licence","end").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setEnd(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class IsPhoneAvailableRequest
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/licence",
+ "isPhoneAvailableRequest",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/licence")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for IsPhoneAvailableRequest
+ */
+
+
+ protected Grouprequesttype localIsPhoneAvailableRequest ;
+
+
+ /**
+ * Auto generated getter method
+ * @return Grouprequesttype
+ */
+ public Grouprequesttype getIsPhoneAvailableRequest(){
+ return localIsPhoneAvailableRequest;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param IsPhoneAvailableRequest
+ */
+ public void setIsPhoneAvailableRequest(Grouprequesttype param){
+
+ this.localIsPhoneAvailableRequest=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ IsPhoneAvailableRequest.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+ //We can safely assume an element has only one type associated with it
+
+ if (localIsPhoneAvailableRequest==null){
+ throw new org.apache.axis2.databinding.ADBException("Property cannot be null!");
+ }
+ localIsPhoneAvailableRequest.serialize(MY_QNAME,factory,xmlWriter);
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+
+ //We can safely assume an element has only one type associated with it
+ return localIsPhoneAvailableRequest.getPullParser(MY_QNAME);
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static IsPhoneAvailableRequest parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ IsPhoneAvailableRequest object =
+ new IsPhoneAvailableRequest();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/licence","isPhoneAvailableRequest").equals(reader.getName())){
+
+ object.setIsPhoneAvailableRequest(Grouprequesttype.Factory.parse(reader));
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class Modulestype
+ implements org.apache.axis2.databinding.ADBBean{
+ /* This type was generated from the piece of schema that had
+ name = modulestype
+ Namespace URI = http://www.vitero.de/schema/licence
+ Namespace Prefix = ns1
+ */
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/licence")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for Modules
+ */
+
+
+ protected Modules_type0 localModules ;
+
+
+ /**
+ * Auto generated getter method
+ * @return Modules_type0
+ */
+ public Modules_type0 getModules(){
+ return localModules;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Modules
+ */
+ public void setModules(Modules_type0 param){
+
+ this.localModules=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,parentQName){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ Modulestype.this.serialize(parentQName,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ parentQName,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/licence");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":modulestype",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "modulestype",
+ xmlWriter);
+ }
+
+
+ }
+
+ if (localModules==null){
+ throw new org.apache.axis2.databinding.ADBException("modules cannot be null!!");
+ }
+ localModules.serialize(new javax.xml.namespace.QName("http://www.vitero.de/schema/licence","modules"),
+ factory,xmlWriter);
+
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/licence",
+ "modules"));
+
+
+ if (localModules==null){
+ throw new org.apache.axis2.databinding.ADBException("modules cannot be null!!");
+ }
+ elementList.add(localModules);
+
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static Modulestype parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ Modulestype object =
+ new Modulestype();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"modulestype".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (Modulestype)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/licence","modules").equals(reader.getName())){
+
+ object.setModules(Modules_type0.Factory.parse(reader));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class GroupHasBookableModuleResponse
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/licence",
+ "groupHasBookableModuleResponse",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/licence")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for Hasmodule
+ */
+
+
+ protected boolean localHasmodule ;
+
+
+ /**
+ * Auto generated getter method
+ * @return boolean
+ */
+ public boolean getHasmodule(){
+ return localHasmodule;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Hasmodule
+ */
+ public void setHasmodule(boolean param){
+
+ this.localHasmodule=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ GroupHasBookableModuleResponse.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/licence");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":groupHasBookableModuleResponse",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "groupHasBookableModuleResponse",
+ xmlWriter);
+ }
+
+
+ }
+
+ namespace = "http://www.vitero.de/schema/licence";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"hasmodule", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"hasmodule");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("hasmodule");
+ }
+
+ if (false) {
+
+ throw new org.apache.axis2.databinding.ADBException("hasmodule cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localHasmodule));
+ }
+
+ xmlWriter.writeEndElement();
+
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/licence",
+ "hasmodule"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localHasmodule));
+
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static GroupHasBookableModuleResponse parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ GroupHasBookableModuleResponse object =
+ new GroupHasBookableModuleResponse();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"groupHasBookableModuleResponse".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (GroupHasBookableModuleResponse)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/licence","hasmodule").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setHasmodule(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToBoolean(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class IsPhoneAvailableResponse
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/licence",
+ "isPhoneAvailableResponse",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/licence")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for Phoneavailable
+ */
+
+
+ protected boolean localPhoneavailable ;
+
+
+ /**
+ * Auto generated getter method
+ * @return boolean
+ */
+ public boolean getPhoneavailable(){
+ return localPhoneavailable;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Phoneavailable
+ */
+ public void setPhoneavailable(boolean param){
+
+ this.localPhoneavailable=param;
+
+
+ }
+
+
+ /**
+ * field for Hybrid
+ */
+
+
+ protected boolean localHybrid ;
+
+
+ /**
+ * Auto generated getter method
+ * @return boolean
+ */
+ public boolean getHybrid(){
+ return localHybrid;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Hybrid
+ */
+ public void setHybrid(boolean param){
+
+ this.localHybrid=param;
+
+
+ }
+
+
+ /**
+ * field for Dialout
+ */
+
+
+ protected boolean localDialout ;
+
+
+ /**
+ * Auto generated getter method
+ * @return boolean
+ */
+ public boolean getDialout(){
+ return localDialout;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Dialout
+ */
+ public void setDialout(boolean param){
+
+ this.localDialout=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ IsPhoneAvailableResponse.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/licence");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":isPhoneAvailableResponse",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "isPhoneAvailableResponse",
+ xmlWriter);
+ }
+
+
+ }
+
+ namespace = "http://www.vitero.de/schema/licence";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"phoneavailable", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"phoneavailable");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("phoneavailable");
+ }
+
+ if (false) {
+
+ throw new org.apache.axis2.databinding.ADBException("phoneavailable cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localPhoneavailable));
+ }
+
+ xmlWriter.writeEndElement();
+
+ namespace = "http://www.vitero.de/schema/licence";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"hybrid", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"hybrid");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("hybrid");
+ }
+
+ if (false) {
+
+ throw new org.apache.axis2.databinding.ADBException("hybrid cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localHybrid));
+ }
+
+ xmlWriter.writeEndElement();
+
+ namespace = "http://www.vitero.de/schema/licence";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"dialout", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"dialout");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("dialout");
+ }
+
+ if (false) {
+
+ throw new org.apache.axis2.databinding.ADBException("dialout cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localDialout));
+ }
+
+ xmlWriter.writeEndElement();
+
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/licence",
+ "phoneavailable"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localPhoneavailable));
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/licence",
+ "hybrid"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localHybrid));
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/licence",
+ "dialout"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localDialout));
+
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static IsPhoneAvailableResponse parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ IsPhoneAvailableResponse object =
+ new IsPhoneAvailableResponse();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"isPhoneAvailableResponse".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (IsPhoneAvailableResponse)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/licence","phoneavailable").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setPhoneavailable(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToBoolean(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/licence","hybrid").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setHybrid(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToBoolean(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/licence","dialout").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setDialout(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToBoolean(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class GetBookableModulesForGroupResponse
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/licence",
+ "getBookableModulesForGroupResponse",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/licence")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for GetBookableModulesForGroupResponse
+ */
+
+
+ protected Modulestype localGetBookableModulesForGroupResponse ;
+
+
+ /**
+ * Auto generated getter method
+ * @return Modulestype
+ */
+ public Modulestype getGetBookableModulesForGroupResponse(){
+ return localGetBookableModulesForGroupResponse;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param GetBookableModulesForGroupResponse
+ */
+ public void setGetBookableModulesForGroupResponse(Modulestype param){
+
+ this.localGetBookableModulesForGroupResponse=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ GetBookableModulesForGroupResponse.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+ //We can safely assume an element has only one type associated with it
+
+ if (localGetBookableModulesForGroupResponse==null){
+ throw new org.apache.axis2.databinding.ADBException("Property cannot be null!");
+ }
+ localGetBookableModulesForGroupResponse.serialize(MY_QNAME,factory,xmlWriter);
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+
+ //We can safely assume an element has only one type associated with it
+ return localGetBookableModulesForGroupResponse.getPullParser(MY_QNAME);
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static GetBookableModulesForGroupResponse parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ GetBookableModulesForGroupResponse object =
+ new GetBookableModulesForGroupResponse();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/licence","getBookableModulesForGroupResponse").equals(reader.getName())){
+
+ object.setGetBookableModulesForGroupResponse(Modulestype.Factory.parse(reader));
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class GetModulesForCustomerResponse
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/licence",
+ "getModulesForCustomerResponse",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/licence")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for GetModulesForCustomerResponse
+ */
+
+
+ protected Modulestype localGetModulesForCustomerResponse ;
+
+
+ /**
+ * Auto generated getter method
+ * @return Modulestype
+ */
+ public Modulestype getGetModulesForCustomerResponse(){
+ return localGetModulesForCustomerResponse;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param GetModulesForCustomerResponse
+ */
+ public void setGetModulesForCustomerResponse(Modulestype param){
+
+ this.localGetModulesForCustomerResponse=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ GetModulesForCustomerResponse.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+ //We can safely assume an element has only one type associated with it
+
+ if (localGetModulesForCustomerResponse==null){
+ throw new org.apache.axis2.databinding.ADBException("Property cannot be null!");
+ }
+ localGetModulesForCustomerResponse.serialize(MY_QNAME,factory,xmlWriter);
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+
+ //We can safely assume an element has only one type associated with it
+ return localGetModulesForCustomerResponse.getPullParser(MY_QNAME);
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static GetModulesForCustomerResponse parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ GetModulesForCustomerResponse object =
+ new GetModulesForCustomerResponse();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/licence","getModulesForCustomerResponse").equals(reader.getName())){
+
+ object.setGetModulesForCustomerResponse(Modulestype.Factory.parse(reader));
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class GetModulesForCustomerRequest
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/licence",
+ "getModulesForCustomerRequest",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/licence")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for Customerid
+ */
+
+
+ protected int localCustomerid ;
+
+
+ /**
+ * Auto generated getter method
+ * @return int
+ */
+ public int getCustomerid(){
+ return localCustomerid;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Customerid
+ */
+ public void setCustomerid(int param){
+
+ this.localCustomerid=param;
+
+
+ }
+
+
+ /**
+ * field for End
+ */
+
+
+ protected java.lang.String localEnd ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localEndTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getEnd(){
+ return localEnd;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param End
+ */
+ public void setEnd(java.lang.String param){
+
+ if (param != null){
+ //update the setting tracker
+ localEndTracker = true;
+ } else {
+ localEndTracker = false;
+
+ }
+
+ this.localEnd=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ GetModulesForCustomerRequest.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/licence");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":getModulesForCustomerRequest",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "getModulesForCustomerRequest",
+ xmlWriter);
+ }
+
+
+ }
+
+ namespace = "http://www.vitero.de/schema/licence";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"customerid", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"customerid");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("customerid");
+ }
+
+ if (localCustomerid==java.lang.Integer.MIN_VALUE) {
+
+ throw new org.apache.axis2.databinding.ADBException("customerid cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localCustomerid));
+ }
+
+ xmlWriter.writeEndElement();
+ if (localEndTracker){
+ namespace = "http://www.vitero.de/schema/licence";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"end", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"end");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("end");
+ }
+
+
+ if (localEnd==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("end cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localEnd);
+
+ }
+
+ xmlWriter.writeEndElement();
+ }
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/licence",
+ "customerid"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localCustomerid));
+ if (localEndTracker){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/licence",
+ "end"));
+
+ if (localEnd != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localEnd));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("end cannot be null!!");
+ }
+ }
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static GetModulesForCustomerRequest parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ GetModulesForCustomerRequest object =
+ new GetModulesForCustomerRequest();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"getModulesForCustomerRequest".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (GetModulesForCustomerRequest)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/licence","customerid").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setCustomerid(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToInt(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/licence","end").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setEnd(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class Rooms_type0
+ implements org.apache.axis2.databinding.ADBBean{
+ /* This type was generated from the piece of schema that had
+ name = rooms_type0
+ Namespace URI = http://www.vitero.de/schema/licence
+ Namespace Prefix = ns1
+ */
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/licence")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for Roomsize
+ * This was an Array!
+ */
+
+
+ protected int[] localRoomsize ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localRoomsizeTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return int[]
+ */
+ public int[] getRoomsize(){
+ return localRoomsize;
+ }
+
+
+
+
+
+
+ /**
+ * validate the array for Roomsize
+ */
+ protected void validateRoomsize(int[] param){
+
+ }
+
+
+ /**
+ * Auto generated setter method
+ * @param param Roomsize
+ */
+ public void setRoomsize(int[] param){
+
+ validateRoomsize(param);
+
+
+ if (param != null){
+ //update the setting tracker
+ localRoomsizeTracker = true;
+ } else {
+ localRoomsizeTracker = false;
+
+ }
+
+ this.localRoomsize=param;
+ }
+
+
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,parentQName){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ Rooms_type0.this.serialize(parentQName,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ parentQName,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/licence");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":rooms_type0",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "rooms_type0",
+ xmlWriter);
+ }
+
+
+ }
+ if (localRoomsizeTracker){
+ if (localRoomsize!=null) {
+ namespace = "http://www.vitero.de/schema/licence";
+ boolean emptyNamespace = namespace == null || namespace.length() == 0;
+ prefix = emptyNamespace ? null : xmlWriter.getPrefix(namespace);
+ for (int i = 0;i < localRoomsize.length;i++){
+
+ if (localRoomsize[i]!=java.lang.Integer.MIN_VALUE) {
+
+ if (!emptyNamespace) {
+ if (prefix == null) {
+ java.lang.String prefix2 = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix2,"roomsize", namespace);
+ xmlWriter.writeNamespace(prefix2, namespace);
+ xmlWriter.setPrefix(prefix2, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"roomsize");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("roomsize");
+ }
+
+
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localRoomsize[i]));
+ xmlWriter.writeEndElement();
+
+ } else {
+
+ // we have to do nothing since minOccurs is zero
+
+ }
+
+ }
+ } else {
+
+ throw new org.apache.axis2.databinding.ADBException("roomsize cannot be null!!");
+
+ }
+
+ }
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+ if (localRoomsizeTracker){
+ if (localRoomsize!=null){
+ for (int i = 0;i < localRoomsize.length;i++){
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/licence",
+ "roomsize"));
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localRoomsize[i]));
+
+
+
+ }
+ } else {
+
+ throw new org.apache.axis2.databinding.ADBException("roomsize cannot be null!!");
+
+ }
+
+ }
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static Rooms_type0 parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ Rooms_type0 object =
+ new Rooms_type0();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"rooms_type0".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (Rooms_type0)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+ java.util.ArrayList list1 = new java.util.ArrayList();
+
+
+ while (!reader.isStartElement() && !reader.isEndElement()) reader.next();
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/licence","roomsize").equals(reader.getName())){
+
+
+
+ // Process the array and step past its final element's end.
+ list1.add(reader.getElementText());
+
+ //loop until we find a start element that is not part of this array
+ boolean loopDone1 = false;
+ while(!loopDone1){
+ // Ensure we are at the EndElement
+ while (!reader.isEndElement()){
+ reader.next();
+ }
+ // Step out of this element
+ reader.next();
+ // Step to next element event.
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+ if (reader.isEndElement()){
+ //two continuous end elements means we are exiting the xml structure
+ loopDone1 = true;
+ } else {
+ if (new javax.xml.namespace.QName("http://www.vitero.de/schema/licence","roomsize").equals(reader.getName())){
+ list1.add(reader.getElementText());
+
+ }else{
+ loopDone1 = true;
+ }
+ }
+ }
+ // call the converter utility to convert and set the array
+
+ object.setRoomsize((int[])
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToArray(
+ int.class,list1));
+
+ } // End of if for expected property start element
+
+ else {
+
+ }
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+ if (reader.isStartElement())
+ // A start element we are not expecting indicates a trailing invalid property
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class GetBookableModulesForGroupRequest
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/licence",
+ "getBookableModulesForGroupRequest",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/licence")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for GetBookableModulesForGroupRequest
+ */
+
+
+ protected Grouprequesttype localGetBookableModulesForGroupRequest ;
+
+
+ /**
+ * Auto generated getter method
+ * @return Grouprequesttype
+ */
+ public Grouprequesttype getGetBookableModulesForGroupRequest(){
+ return localGetBookableModulesForGroupRequest;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param GetBookableModulesForGroupRequest
+ */
+ public void setGetBookableModulesForGroupRequest(Grouprequesttype param){
+
+ this.localGetBookableModulesForGroupRequest=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ GetBookableModulesForGroupRequest.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+ //We can safely assume an element has only one type associated with it
+
+ if (localGetBookableModulesForGroupRequest==null){
+ throw new org.apache.axis2.databinding.ADBException("Property cannot be null!");
+ }
+ localGetBookableModulesForGroupRequest.serialize(MY_QNAME,factory,xmlWriter);
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+
+ //We can safely assume an element has only one type associated with it
+ return localGetBookableModulesForGroupRequest.getPullParser(MY_QNAME);
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static GetBookableModulesForGroupRequest parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ GetBookableModulesForGroupRequest object =
+ new GetBookableModulesForGroupRequest();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/licence","getBookableModulesForGroupRequest").equals(reader.getName())){
+
+ object.setGetBookableModulesForGroupRequest(Grouprequesttype.Factory.parse(reader));
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class ExtensionMapper{
+
+ public static java.lang.Object getTypeObject(java.lang.String namespaceURI,
+ java.lang.String typeName,
+ javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+
+
+ if (
+ "http://www.vitero.de/schema/licence".equals(namespaceURI) &&
+ "grouprequesttype".equals(typeName)){
+
+ return Grouprequesttype.Factory.parse(reader);
+
+
+ }
+
+
+ if (
+ "http://www.vitero.de/schema/licence".equals(namespaceURI) &&
+ "modules_type0".equals(typeName)){
+
+ return Modules_type0.Factory.parse(reader);
+
+
+ }
+
+
+ if (
+ "http://www.vitero.de/schema/licence".equals(namespaceURI) &&
+ "module_type0".equals(typeName)){
+
+ return Module_type0.Factory.parse(reader);
+
+
+ }
+
+
+ if (
+ "http://www.vitero.de/schema/licence".equals(namespaceURI) &&
+ "modulestype".equals(typeName)){
+
+ return Modulestype.Factory.parse(reader);
+
+
+ }
+
+
+ if (
+ "http://www.vitero.de/schema/licence".equals(namespaceURI) &&
+ "rooms_type0".equals(typeName)){
+
+ return Rooms_type0.Factory.parse(reader);
+
+
+ }
+
+
+ throw new org.apache.axis2.databinding.ADBException("Unsupported type " + namespaceURI + " " + typeName);
+ }
+
+ }
+
+ public static class Module_type0
+ implements org.apache.axis2.databinding.ADBBean{
+ /* This type was generated from the piece of schema that had
+ name = module_type0
+ Namespace URI = http://www.vitero.de/schema/licence
+ Namespace Prefix = ns1
+ */
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/licence")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for Type
+ */
+
+
+ protected java.lang.String localType ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getType(){
+ return localType;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Type
+ */
+ public void setType(java.lang.String param){
+
+ this.localType=param;
+
+
+ }
+
+
+ /**
+ * field for Enddate
+ */
+
+
+ protected java.lang.String localEnddate ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localEnddateTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getEnddate(){
+ return localEnddate;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Enddate
+ */
+ public void setEnddate(java.lang.String param){
+
+ if (param != null){
+ //update the setting tracker
+ localEnddateTracker = true;
+ } else {
+ localEnddateTracker = false;
+
+ }
+
+ this.localEnddate=param;
+
+
+ }
+
+
+ /**
+ * field for Roomsize
+ */
+
+
+ protected int localRoomsize ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localRoomsizeTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return int
+ */
+ public int getRoomsize(){
+ return localRoomsize;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Roomsize
+ */
+ public void setRoomsize(int param){
+
+ // setting primitive attribute tracker to true
+
+ if (param==java.lang.Integer.MIN_VALUE) {
+ localRoomsizeTracker = false;
+
+ } else {
+ localRoomsizeTracker = true;
+ }
+
+ this.localRoomsize=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,parentQName){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ Module_type0.this.serialize(parentQName,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ parentQName,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/licence");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":module_type0",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "module_type0",
+ xmlWriter);
+ }
+
+
+ }
+
+ namespace = "http://www.vitero.de/schema/licence";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"type", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"type");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("type");
+ }
+
+
+ if (localType==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("type cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localType);
+
+ }
+
+ xmlWriter.writeEndElement();
+ if (localEnddateTracker){
+ namespace = "http://www.vitero.de/schema/licence";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"enddate", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"enddate");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("enddate");
+ }
+
+
+ if (localEnddate==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("enddate cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localEnddate);
+
+ }
+
+ xmlWriter.writeEndElement();
+ } if (localRoomsizeTracker){
+ namespace = "http://www.vitero.de/schema/licence";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"roomsize", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"roomsize");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("roomsize");
+ }
+
+ if (localRoomsize==java.lang.Integer.MIN_VALUE) {
+
+ throw new org.apache.axis2.databinding.ADBException("roomsize cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localRoomsize));
+ }
+
+ xmlWriter.writeEndElement();
+ }
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/licence",
+ "type"));
+
+ if (localType != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localType));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("type cannot be null!!");
+ }
+ if (localEnddateTracker){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/licence",
+ "enddate"));
+
+ if (localEnddate != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localEnddate));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("enddate cannot be null!!");
+ }
+ } if (localRoomsizeTracker){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/licence",
+ "roomsize"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localRoomsize));
+ }
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static Module_type0 parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ Module_type0 object =
+ new Module_type0();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"module_type0".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (Module_type0)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/licence","type").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setType(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/licence","enddate").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setEnddate(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/licence","roomsize").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setRoomsize(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToInt(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class Grouprequesttype
+ implements org.apache.axis2.databinding.ADBBean{
+ /* This type was generated from the piece of schema that had
+ name = grouprequesttype
+ Namespace URI = http://www.vitero.de/schema/licence
+ Namespace Prefix = ns1
+ */
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/licence")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for Groupid
+ */
+
+
+ protected int localGroupid ;
+
+
+ /**
+ * Auto generated getter method
+ * @return int
+ */
+ public int getGroupid(){
+ return localGroupid;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Groupid
+ */
+ public void setGroupid(int param){
+
+ this.localGroupid=param;
+
+
+ }
+
+
+ /**
+ * field for Start
+ */
+
+
+ protected java.lang.String localStart ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localStartTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getStart(){
+ return localStart;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Start
+ */
+ public void setStart(java.lang.String param){
+
+ if (param != null){
+ //update the setting tracker
+ localStartTracker = true;
+ } else {
+ localStartTracker = false;
+
+ }
+
+ this.localStart=param;
+
+
+ }
+
+
+ /**
+ * field for End
+ */
+
+
+ protected java.lang.String localEnd ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localEndTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getEnd(){
+ return localEnd;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param End
+ */
+ public void setEnd(java.lang.String param){
+
+ if (param != null){
+ //update the setting tracker
+ localEndTracker = true;
+ } else {
+ localEndTracker = false;
+
+ }
+
+ this.localEnd=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,parentQName){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ Grouprequesttype.this.serialize(parentQName,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ parentQName,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/licence");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":grouprequesttype",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "grouprequesttype",
+ xmlWriter);
+ }
+
+
+ }
+
+ namespace = "http://www.vitero.de/schema/licence";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"groupid", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"groupid");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("groupid");
+ }
+
+ if (localGroupid==java.lang.Integer.MIN_VALUE) {
+
+ throw new org.apache.axis2.databinding.ADBException("groupid cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localGroupid));
+ }
+
+ xmlWriter.writeEndElement();
+ if (localStartTracker){
+ namespace = "http://www.vitero.de/schema/licence";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"start", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"start");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("start");
+ }
+
+
+ if (localStart==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("start cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localStart);
+
+ }
+
+ xmlWriter.writeEndElement();
+ } if (localEndTracker){
+ namespace = "http://www.vitero.de/schema/licence";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"end", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"end");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("end");
+ }
+
+
+ if (localEnd==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("end cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localEnd);
+
+ }
+
+ xmlWriter.writeEndElement();
+ }
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/licence",
+ "groupid"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localGroupid));
+ if (localStartTracker){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/licence",
+ "start"));
+
+ if (localStart != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localStart));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("start cannot be null!!");
+ }
+ } if (localEndTracker){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/licence",
+ "end"));
+
+ if (localEnd != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localEnd));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("end cannot be null!!");
+ }
+ }
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static Grouprequesttype parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ Grouprequesttype object =
+ new Grouprequesttype();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"grouprequesttype".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (Grouprequesttype)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/licence","groupid").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setGroupid(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToInt(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/licence","start").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setStart(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/licence","end").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setEnd(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class GetAllModulesResponse
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/licence",
+ "getAllModulesResponse",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/licence")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for GetAllModulesResponse
+ */
+
+
+ protected Modulestype localGetAllModulesResponse ;
+
+
+ /**
+ * Auto generated getter method
+ * @return Modulestype
+ */
+ public Modulestype getGetAllModulesResponse(){
+ return localGetAllModulesResponse;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param GetAllModulesResponse
+ */
+ public void setGetAllModulesResponse(Modulestype param){
+
+ this.localGetAllModulesResponse=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ GetAllModulesResponse.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+ //We can safely assume an element has only one type associated with it
+
+ if (localGetAllModulesResponse==null){
+ throw new org.apache.axis2.databinding.ADBException("Property cannot be null!");
+ }
+ localGetAllModulesResponse.serialize(MY_QNAME,factory,xmlWriter);
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+
+ //We can safely assume an element has only one type associated with it
+ return localGetAllModulesResponse.getPullParser(MY_QNAME);
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static GetAllModulesResponse parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ GetAllModulesResponse object =
+ new GetAllModulesResponse();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/licence","getAllModulesResponse").equals(reader.getName())){
+
+ object.setGetAllModulesResponse(Modulestype.Factory.parse(reader));
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class SuccessResponse
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/licence",
+ "successResponse",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/licence")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for Request
+ */
+
+
+ protected java.lang.String localRequest ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getRequest(){
+ return localRequest;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Request
+ */
+ public void setRequest(java.lang.String param){
+
+ this.localRequest=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ SuccessResponse.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/licence");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":successResponse",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "successResponse",
+ xmlWriter);
+ }
+
+
+ }
+
+ namespace = "http://www.vitero.de/schema/licence";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"request", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"request");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("request");
+ }
+
+
+ if (localRequest==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("request cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localRequest);
+
+ }
+
+ xmlWriter.writeEndElement();
+
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/licence",
+ "request"));
+
+ if (localRequest != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localRequest));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("request cannot be null!!");
+ }
+
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static SuccessResponse parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ SuccessResponse object =
+ new SuccessResponse();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"successResponse".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (SuccessResponse)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/licence","request").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setRequest(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class GetBookableRoomsForGroupResponse
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/licence",
+ "getBookableRoomsForGroupResponse",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/licence")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for Rooms
+ */
+
+
+ protected Rooms_type0 localRooms ;
+
+
+ /**
+ * Auto generated getter method
+ * @return Rooms_type0
+ */
+ public Rooms_type0 getRooms(){
+ return localRooms;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Rooms
+ */
+ public void setRooms(Rooms_type0 param){
+
+ this.localRooms=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ GetBookableRoomsForGroupResponse.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/licence");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":getBookableRoomsForGroupResponse",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "getBookableRoomsForGroupResponse",
+ xmlWriter);
+ }
+
+
+ }
+
+ if (localRooms==null){
+ throw new org.apache.axis2.databinding.ADBException("rooms cannot be null!!");
+ }
+ localRooms.serialize(new javax.xml.namespace.QName("http://www.vitero.de/schema/licence","rooms"),
+ factory,xmlWriter);
+
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/licence",
+ "rooms"));
+
+
+ if (localRooms==null){
+ throw new org.apache.axis2.databinding.ADBException("rooms cannot be null!!");
+ }
+ elementList.add(localRooms);
+
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static GetBookableRoomsForGroupResponse parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ GetBookableRoomsForGroupResponse object =
+ new GetBookableRoomsForGroupResponse();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"getBookableRoomsForGroupResponse".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (GetBookableRoomsForGroupResponse)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/licence","rooms").equals(reader.getName())){
+
+ object.setRooms(Rooms_type0.Factory.parse(reader));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class Modules_type0
+ implements org.apache.axis2.databinding.ADBBean{
+ /* This type was generated from the piece of schema that had
+ name = modules_type0
+ Namespace URI = http://www.vitero.de/schema/licence
+ Namespace Prefix = ns1
+ */
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/licence")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for Module
+ * This was an Array!
+ */
+
+
+ protected Module_type0[] localModule ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localModuleTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return Module_type0[]
+ */
+ public Module_type0[] getModule(){
+ return localModule;
+ }
+
+
+
+
+
+
+ /**
+ * validate the array for Module
+ */
+ protected void validateModule(Module_type0[] param){
+
+ }
+
+
+ /**
+ * Auto generated setter method
+ * @param param Module
+ */
+ public void setModule(Module_type0[] param){
+
+ validateModule(param);
+
+
+ if (param != null){
+ //update the setting tracker
+ localModuleTracker = true;
+ } else {
+ localModuleTracker = false;
+
+ }
+
+ this.localModule=param;
+ }
+
+
+
+ /**
+ * Auto generated add method for the array for convenience
+ * @param param Module_type0
+ */
+ public void addModule(Module_type0 param){
+ if (localModule == null){
+ localModule = new Module_type0[]{};
+ }
+
+
+ //update the setting tracker
+ localModuleTracker = true;
+
+
+ java.util.List list =
+ org.apache.axis2.databinding.utils.ConverterUtil.toList(localModule);
+ list.add(param);
+ this.localModule =
+ (Module_type0[])list.toArray(
+ new Module_type0[list.size()]);
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,parentQName){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ Modules_type0.this.serialize(parentQName,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ parentQName,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/licence");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":modules_type0",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "modules_type0",
+ xmlWriter);
+ }
+
+
+ }
+ if (localModuleTracker){
+ if (localModule!=null){
+ for (int i = 0;i < localModule.length;i++){
+ if (localModule[i] != null){
+ localModule[i].serialize(new javax.xml.namespace.QName("http://www.vitero.de/schema/licence","module"),
+ factory,xmlWriter);
+ } else {
+
+ // we don't have to do any thing since minOccures is zero
+
+ }
+
+ }
+ } else {
+
+ throw new org.apache.axis2.databinding.ADBException("module cannot be null!!");
+
+ }
+ }
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+ if (localModuleTracker){
+ if (localModule!=null) {
+ for (int i = 0;i < localModule.length;i++){
+
+ if (localModule[i] != null){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/licence",
+ "module"));
+ elementList.add(localModule[i]);
+ } else {
+
+ // nothing to do
+
+ }
+
+ }
+ } else {
+
+ throw new org.apache.axis2.databinding.ADBException("module cannot be null!!");
+
+ }
+
+ }
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static Modules_type0 parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ Modules_type0 object =
+ new Modules_type0();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"modules_type0".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (Modules_type0)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+ java.util.ArrayList list1 = new java.util.ArrayList();
+
+
+ while (!reader.isStartElement() && !reader.isEndElement()) reader.next();
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/licence","module").equals(reader.getName())){
+
+
+
+ // Process the array and step past its final element's end.
+ list1.add(Module_type0.Factory.parse(reader));
+
+ //loop until we find a start element that is not part of this array
+ boolean loopDone1 = false;
+ while(!loopDone1){
+ // We should be at the end element, but make sure
+ while (!reader.isEndElement())
+ reader.next();
+ // Step out of this element
+ reader.next();
+ // Step to next element event.
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+ if (reader.isEndElement()){
+ //two continuous end elements means we are exiting the xml structure
+ loopDone1 = true;
+ } else {
+ if (new javax.xml.namespace.QName("http://www.vitero.de/schema/licence","module").equals(reader.getName())){
+ list1.add(Module_type0.Factory.parse(reader));
+
+ }else{
+ loopDone1 = true;
+ }
+ }
+ }
+ // call the converter utility to convert and set the array
+
+ object.setModule((Module_type0[])
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToArray(
+ Module_type0.class,
+ list1));
+
+ } // End of if for expected property start element
+
+ else {
+
+ }
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+ if (reader.isStartElement())
+ // A start element we are not expecting indicates a trailing invalid property
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class GroupHasBookableModuleRequest
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/licence",
+ "groupHasBookableModuleRequest",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/licence")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for Groupid
+ */
+
+
+ protected int localGroupid ;
+
+
+ /**
+ * Auto generated getter method
+ * @return int
+ */
+ public int getGroupid(){
+ return localGroupid;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Groupid
+ */
+ public void setGroupid(int param){
+
+ this.localGroupid=param;
+
+
+ }
+
+
+ /**
+ * field for Type
+ */
+
+
+ protected java.lang.String localType ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getType(){
+ return localType;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Type
+ */
+ public void setType(java.lang.String param){
+
+ this.localType=param;
+
+
+ }
+
+
+ /**
+ * field for Start
+ */
+
+
+ protected java.lang.String localStart ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localStartTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getStart(){
+ return localStart;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Start
+ */
+ public void setStart(java.lang.String param){
+
+ if (param != null){
+ //update the setting tracker
+ localStartTracker = true;
+ } else {
+ localStartTracker = false;
+
+ }
+
+ this.localStart=param;
+
+
+ }
+
+
+ /**
+ * field for End
+ */
+
+
+ protected java.lang.String localEnd ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localEndTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getEnd(){
+ return localEnd;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param End
+ */
+ public void setEnd(java.lang.String param){
+
+ if (param != null){
+ //update the setting tracker
+ localEndTracker = true;
+ } else {
+ localEndTracker = false;
+
+ }
+
+ this.localEnd=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ GroupHasBookableModuleRequest.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/licence");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":groupHasBookableModuleRequest",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "groupHasBookableModuleRequest",
+ xmlWriter);
+ }
+
+
+ }
+
+ namespace = "http://www.vitero.de/schema/licence";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"groupid", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"groupid");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("groupid");
+ }
+
+ if (localGroupid==java.lang.Integer.MIN_VALUE) {
+
+ throw new org.apache.axis2.databinding.ADBException("groupid cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localGroupid));
+ }
+
+ xmlWriter.writeEndElement();
+
+ namespace = "http://www.vitero.de/schema/licence";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"type", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"type");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("type");
+ }
+
+
+ if (localType==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("type cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localType);
+
+ }
+
+ xmlWriter.writeEndElement();
+ if (localStartTracker){
+ namespace = "http://www.vitero.de/schema/licence";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"start", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"start");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("start");
+ }
+
+
+ if (localStart==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("start cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localStart);
+
+ }
+
+ xmlWriter.writeEndElement();
+ } if (localEndTracker){
+ namespace = "http://www.vitero.de/schema/licence";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"end", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"end");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("end");
+ }
+
+
+ if (localEnd==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("end cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localEnd);
+
+ }
+
+ xmlWriter.writeEndElement();
+ }
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/licence",
+ "groupid"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localGroupid));
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/licence",
+ "type"));
+
+ if (localType != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localType));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("type cannot be null!!");
+ }
+ if (localStartTracker){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/licence",
+ "start"));
+
+ if (localStart != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localStart));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("start cannot be null!!");
+ }
+ } if (localEndTracker){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/licence",
+ "end"));
+
+ if (localEnd != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localEnd));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("end cannot be null!!");
+ }
+ }
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static GroupHasBookableModuleRequest parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ GroupHasBookableModuleRequest object =
+ new GroupHasBookableModuleRequest();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"groupHasBookableModuleRequest".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (GroupHasBookableModuleRequest)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/licence","groupid").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setGroupid(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToInt(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/licence","type").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setType(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/licence","start").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setStart(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/licence","end").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setEnd(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.GetBookableModulesForGroupRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.GetBookableModulesForGroupRequest.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.GetBookableModulesForGroupResponse param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.GetBookableModulesForGroupResponse.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.SuccessResponse param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.SuccessResponse.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.GroupHasBookableModuleRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.GroupHasBookableModuleRequest.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.GroupHasBookableModuleResponse param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.GroupHasBookableModuleResponse.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.GetAllModulesRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.GetAllModulesRequest.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.GetAllModulesResponse param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.GetAllModulesResponse.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.GetModulesForCustomerRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.GetModulesForCustomerRequest.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.GetModulesForCustomerResponse param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.GetModulesForCustomerResponse.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.IsPhoneAvailableRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.IsPhoneAvailableRequest.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.IsPhoneAvailableResponse param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.IsPhoneAvailableResponse.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.GetBookableRoomsForGroupRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.GetBookableRoomsForGroupRequest.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.GetBookableRoomsForGroupResponse param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.GetBookableRoomsForGroupResponse.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+
+ private org.apache.axiom.soap.SOAPEnvelope toEnvelope(org.apache.axiom.soap.SOAPFactory factory, com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.GetBookableModulesForGroupRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault{
+
+
+ try{
+
+ org.apache.axiom.soap.SOAPEnvelope emptyEnvelope = factory.getDefaultEnvelope();
+ emptyEnvelope.getBody().addChild(param.getOMElement(com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.GetBookableModulesForGroupRequest.MY_QNAME,factory));
+ return emptyEnvelope;
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+
+ /* methods to provide back word compatibility */
+
+
+
+ private org.apache.axiom.soap.SOAPEnvelope toEnvelope(org.apache.axiom.soap.SOAPFactory factory, com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.GroupHasBookableModuleRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault{
+
+
+ try{
+
+ org.apache.axiom.soap.SOAPEnvelope emptyEnvelope = factory.getDefaultEnvelope();
+ emptyEnvelope.getBody().addChild(param.getOMElement(com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.GroupHasBookableModuleRequest.MY_QNAME,factory));
+ return emptyEnvelope;
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+
+ /* methods to provide back word compatibility */
+
+
+
+ private org.apache.axiom.soap.SOAPEnvelope toEnvelope(org.apache.axiom.soap.SOAPFactory factory, com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.GetAllModulesRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault{
+
+
+ try{
+
+ org.apache.axiom.soap.SOAPEnvelope emptyEnvelope = factory.getDefaultEnvelope();
+ emptyEnvelope.getBody().addChild(param.getOMElement(com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.GetAllModulesRequest.MY_QNAME,factory));
+ return emptyEnvelope;
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+
+ /* methods to provide back word compatibility */
+
+
+
+ private org.apache.axiom.soap.SOAPEnvelope toEnvelope(org.apache.axiom.soap.SOAPFactory factory, com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.GetModulesForCustomerRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault{
+
+
+ try{
+
+ org.apache.axiom.soap.SOAPEnvelope emptyEnvelope = factory.getDefaultEnvelope();
+ emptyEnvelope.getBody().addChild(param.getOMElement(com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.GetModulesForCustomerRequest.MY_QNAME,factory));
+ return emptyEnvelope;
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+
+ /* methods to provide back word compatibility */
+
+
+
+ private org.apache.axiom.soap.SOAPEnvelope toEnvelope(org.apache.axiom.soap.SOAPFactory factory, com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.IsPhoneAvailableRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault{
+
+
+ try{
+
+ org.apache.axiom.soap.SOAPEnvelope emptyEnvelope = factory.getDefaultEnvelope();
+ emptyEnvelope.getBody().addChild(param.getOMElement(com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.IsPhoneAvailableRequest.MY_QNAME,factory));
+ return emptyEnvelope;
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+
+ /* methods to provide back word compatibility */
+
+
+
+ private org.apache.axiom.soap.SOAPEnvelope toEnvelope(org.apache.axiom.soap.SOAPFactory factory, com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.GetBookableRoomsForGroupRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault{
+
+
+ try{
+
+ org.apache.axiom.soap.SOAPEnvelope emptyEnvelope = factory.getDefaultEnvelope();
+ emptyEnvelope.getBody().addChild(param.getOMElement(com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.GetBookableRoomsForGroupRequest.MY_QNAME,factory));
+ return emptyEnvelope;
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+
+ /* methods to provide back word compatibility */
+
+
+
+
+ /**
+ * get the default envelope
+ */
+ private org.apache.axiom.soap.SOAPEnvelope toEnvelope(org.apache.axiom.soap.SOAPFactory factory){
+ return factory.getDefaultEnvelope();
+ }
+
+
+ private java.lang.Object fromOM(
+ org.apache.axiom.om.OMElement param,
+ java.lang.Class type,
+ java.util.Map extraNamespaces) throws org.apache.axis2.AxisFault{
+
+ try {
+
+ if (com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.GetBookableModulesForGroupRequest.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.GetBookableModulesForGroupRequest.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ if (com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.GetBookableModulesForGroupResponse.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.GetBookableModulesForGroupResponse.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ if (com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.SuccessResponse.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.SuccessResponse.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ if (com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.GroupHasBookableModuleRequest.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.GroupHasBookableModuleRequest.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ if (com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.GroupHasBookableModuleResponse.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.GroupHasBookableModuleResponse.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ if (com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.GetAllModulesRequest.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.GetAllModulesRequest.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ if (com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.GetAllModulesResponse.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.GetAllModulesResponse.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ if (com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.GetModulesForCustomerRequest.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.GetModulesForCustomerRequest.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ if (com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.GetModulesForCustomerResponse.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.GetModulesForCustomerResponse.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ if (com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.IsPhoneAvailableRequest.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.IsPhoneAvailableRequest.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ if (com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.IsPhoneAvailableResponse.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.IsPhoneAvailableResponse.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ if (com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.GetBookableRoomsForGroupRequest.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.GetBookableRoomsForGroupRequest.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ if (com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.GetBookableRoomsForGroupResponse.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.LicenceServiceStub.GetBookableRoomsForGroupResponse.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ } catch (java.lang.Exception e) {
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+ return null;
+ }
+
+
+
+
+ }
+
\ No newline at end of file
diff --git a/src/main/java/com/frentix/olat/vitero/manager/stubs/MtomServiceCallbackHandler.java b/src/main/java/com/frentix/olat/vitero/manager/stubs/MtomServiceCallbackHandler.java
new file mode 100644
index 0000000000000000000000000000000000000000..8312bce960aece329f1800574775eae1a0da5c2c
--- /dev/null
+++ b/src/main/java/com/frentix/olat/vitero/manager/stubs/MtomServiceCallbackHandler.java
@@ -0,0 +1,102 @@
+
+/**
+ * MtomServiceCallbackHandler.java
+ *
+ * This file was auto-generated from WSDL
+ * by the Apache Axis2 version: 1.4.1 Built on : Aug 13, 2008 (05:03:35 LKT)
+ */
+
+ package com.frentix.olat.vitero.manager.stubs;
+
+ /**
+ * MtomServiceCallbackHandler Callback class, Users can extend this class and implement
+ * their own receiveResult and receiveError methods.
+ */
+ public abstract class MtomServiceCallbackHandler{
+
+
+
+ protected Object clientData;
+
+ /**
+ * User can pass in any object that needs to be accessed once the NonBlocking
+ * Web service call is finished and appropriate method of this CallBack is called.
+ * @param clientData Object mechanism by which the user can pass in user data
+ * that will be avilable at the time this callback is called.
+ */
+ public MtomServiceCallbackHandler(Object clientData){
+ this.clientData = clientData;
+ }
+
+ /**
+ * Please use this constructor if you don't want to set any clientData
+ */
+ public MtomServiceCallbackHandler(){
+ this.clientData = null;
+ }
+
+ /**
+ * Get the client data
+ */
+
+ public Object getClientData() {
+ return clientData;
+ }
+
+
+ /**
+ * auto generated Axis2 call back method for loadFile method
+ * override this method for handling normal response from loadFile operation
+ */
+ public void receiveResultloadFile(
+ com.frentix.olat.vitero.manager.stubs.MtomServiceStub.LoadFileResponse result
+ ) {
+ }
+
+ /**
+ * auto generated Axis2 Error handler
+ * override this method for handling error response from loadFile operation
+ */
+ public void receiveErrorloadFile(java.lang.Exception e) {
+ }
+
+ // No methods generated for meps other than in-out
+
+ /**
+ * auto generated Axis2 call back method for loadAvatar method
+ * override this method for handling normal response from loadAvatar operation
+ */
+ public void receiveResultloadAvatar(
+ com.frentix.olat.vitero.manager.stubs.MtomServiceStub.LoadAvatarResponse result
+ ) {
+ }
+
+ /**
+ * auto generated Axis2 Error handler
+ * override this method for handling error response from loadAvatar operation
+ */
+ public void receiveErrorloadAvatar(java.lang.Exception e) {
+ }
+
+ /**
+ * auto generated Axis2 call back method for storeFile method
+ * override this method for handling normal response from storeFile operation
+ */
+ public void receiveResultstoreFile(
+ com.frentix.olat.vitero.manager.stubs.MtomServiceStub.StoreFileResponse result
+ ) {
+ }
+
+ /**
+ * auto generated Axis2 Error handler
+ * override this method for handling error response from storeFile operation
+ */
+ public void receiveErrorstoreFile(java.lang.Exception e) {
+ }
+
+ // No methods generated for meps other than in-out
+
+
+
+ }
+
\ No newline at end of file
diff --git a/src/main/java/com/frentix/olat/vitero/manager/stubs/MtomServiceStub.java b/src/main/java/com/frentix/olat/vitero/manager/stubs/MtomServiceStub.java
new file mode 100644
index 0000000000000000000000000000000000000000..8608b469fb54e184cc25b911cd8623c247b3fcc4
--- /dev/null
+++ b/src/main/java/com/frentix/olat/vitero/manager/stubs/MtomServiceStub.java
@@ -0,0 +1,7747 @@
+
+/**
+ * MtomServiceStub.java
+ *
+ * This file was auto-generated from WSDL
+ * by the Apache Axis2 version: 1.4.1 Built on : Aug 13, 2008 (05:03:35 LKT)
+ */
+ package com.frentix.olat.vitero.manager.stubs;
+
+
+
+ /*
+ * MtomServiceStub java implementation
+ */
+
+
+ public class MtomServiceStub extends org.apache.axis2.client.Stub
+ {
+ protected org.apache.axis2.description.AxisOperation[] _operations;
+
+ //hashmaps to keep the fault mapping
+ private java.util.HashMap faultExceptionNameMap = new java.util.HashMap();
+ private java.util.HashMap faultExceptionClassNameMap = new java.util.HashMap();
+ private java.util.HashMap faultMessageMap = new java.util.HashMap();
+
+ private static int counter = 0;
+
+ private static synchronized String getUniqueSuffix(){
+ // reset the counter if it is greater than 99999
+ if (counter > 99999){
+ counter = 0;
+ }
+ counter = counter + 1;
+ return Long.toString(System.currentTimeMillis()) + "_" + counter;
+ }
+
+
+ private void populateAxisService() throws org.apache.axis2.AxisFault {
+
+ //creating the Service with a unique name
+ _service = new org.apache.axis2.description.AxisService("MtomService" + getUniqueSuffix());
+ addAnonymousOperations();
+
+ //creating the operations
+ org.apache.axis2.description.AxisOperation __operation;
+
+ _operations = new org.apache.axis2.description.AxisOperation[5];
+
+ __operation = new org.apache.axis2.description.OutInAxisOperation();
+
+
+ __operation.setName(new javax.xml.namespace.QName("http://www.vitero.de/schema/mtom", "loadFile"));
+ _service.addOperation(__operation);
+
+
+
+
+ _operations[0]=__operation;
+
+
+ __operation = new org.apache.axis2.description.OutOnlyAxisOperation();
+
+
+ __operation.setName(new javax.xml.namespace.QName("http://www.vitero.de/schema/mtom", "storeAvatar"));
+ _service.addOperation(__operation);
+
+
+
+
+ _operations[1]=__operation;
+
+
+ __operation = new org.apache.axis2.description.OutInAxisOperation();
+
+
+ __operation.setName(new javax.xml.namespace.QName("http://www.vitero.de/schema/mtom", "loadAvatar"));
+ _service.addOperation(__operation);
+
+
+
+
+ _operations[2]=__operation;
+
+
+ __operation = new org.apache.axis2.description.OutInAxisOperation();
+
+
+ __operation.setName(new javax.xml.namespace.QName("http://www.vitero.de/schema/mtom", "storeFile"));
+ _service.addOperation(__operation);
+
+
+
+
+ _operations[3]=__operation;
+
+
+ __operation = new org.apache.axis2.description.OutInAxisOperation();
+
+
+ __operation.setName(new javax.xml.namespace.QName("http://www.vitero.de/schema/mtom", "success"));
+ _service.addOperation(__operation);
+
+
+
+
+ _operations[4]=__operation;
+
+
+ }
+
+ //populates the faults
+ private void populateFaults(){
+
+
+
+ }
+
+ /**
+ *Constructor that takes in a configContext
+ */
+
+ public MtomServiceStub(org.apache.axis2.context.ConfigurationContext configurationContext,
+ java.lang.String targetEndpoint)
+ throws org.apache.axis2.AxisFault {
+ this(configurationContext,targetEndpoint,false);
+ }
+
+
+ /**
+ * Constructor that takes in a configContext and useseperate listner
+ */
+ public MtomServiceStub(org.apache.axis2.context.ConfigurationContext configurationContext,
+ java.lang.String targetEndpoint, boolean useSeparateListener)
+ throws org.apache.axis2.AxisFault {
+ //To populate AxisService
+ populateAxisService();
+ populateFaults();
+
+ _serviceClient = new org.apache.axis2.client.ServiceClient(configurationContext,_service);
+
+
+ configurationContext = _serviceClient.getServiceContext().getConfigurationContext();
+
+ _serviceClient.getOptions().setTo(new org.apache.axis2.addressing.EndpointReference(
+ targetEndpoint));
+ _serviceClient.getOptions().setUseSeparateListener(useSeparateListener);
+
+
+ }
+
+ /**
+ * Default Constructor
+ */
+ public MtomServiceStub(org.apache.axis2.context.ConfigurationContext configurationContext) throws org.apache.axis2.AxisFault {
+
+ this(configurationContext,"http://192.168.1.54:8080/vitero/services/" );
+
+ }
+
+ /**
+ * Default Constructor
+ */
+ public MtomServiceStub() throws org.apache.axis2.AxisFault {
+
+ this("http://192.168.1.54:8080/vitero/services/" );
+
+ }
+
+ /**
+ * Constructor taking the target endpoint
+ */
+ public MtomServiceStub(java.lang.String targetEndpoint) throws org.apache.axis2.AxisFault {
+ this(null,targetEndpoint);
+ }
+
+
+
+
+ /**
+ * Auto generated method signature
+ *
+ * @see com.frentix.olat.vc.provider.vitero.stubs.MtomService#loadFile
+ * @param loadFileRequest0
+
+ */
+
+
+
+ public com.frentix.olat.vitero.manager.stubs.MtomServiceStub.LoadFileResponse loadFile(
+
+ com.frentix.olat.vitero.manager.stubs.MtomServiceStub.LoadFileRequest loadFileRequest0)
+
+
+ throws java.rmi.RemoteException
+
+ {
+ org.apache.axis2.context.MessageContext _messageContext = null;
+ try{
+ org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[0].getName());
+ _operationClient.getOptions().setAction("\"\"");
+ _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true);
+
+
+
+ addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&");
+
+
+ // create a message context
+ _messageContext = new org.apache.axis2.context.MessageContext();
+
+
+
+ // create SOAP envelope with that payload
+ org.apache.axiom.soap.SOAPEnvelope env = null;
+
+
+ env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()),
+ loadFileRequest0,
+ optimizeContent(new javax.xml.namespace.QName("http://www.vitero.de/schema/mtom",
+ "loadFile")));
+
+ //adding SOAP soap_headers
+ _serviceClient.addHeadersToEnvelope(env);
+ // set the message context with that soap envelope
+ _messageContext.setEnvelope(env);
+
+ // add the message contxt to the operation client
+ _operationClient.addMessageContext(_messageContext);
+
+ //execute the operation client
+ _operationClient.execute(true);
+
+
+ org.apache.axis2.context.MessageContext _returnMessageContext = _operationClient.getMessageContext(
+ org.apache.axis2.wsdl.WSDLConstants.MESSAGE_LABEL_IN_VALUE);
+ org.apache.axiom.soap.SOAPEnvelope _returnEnv = _returnMessageContext.getEnvelope();
+
+
+ java.lang.Object object = fromOM(
+ _returnEnv.getBody().getFirstElement() ,
+ com.frentix.olat.vitero.manager.stubs.MtomServiceStub.LoadFileResponse.class,
+ getEnvelopeNamespaces(_returnEnv));
+
+
+ return (com.frentix.olat.vitero.manager.stubs.MtomServiceStub.LoadFileResponse)object;
+
+ }catch(org.apache.axis2.AxisFault f){
+
+ org.apache.axiom.om.OMElement faultElt = f.getDetail();
+ if (faultElt!=null){
+ if (faultExceptionNameMap.containsKey(faultElt.getQName())){
+ //make the fault by reflection
+ try{
+ java.lang.String exceptionClassName = (java.lang.String)faultExceptionClassNameMap.get(faultElt.getQName());
+ java.lang.Class exceptionClass = java.lang.Class.forName(exceptionClassName);
+ java.lang.Exception ex=
+ (java.lang.Exception) exceptionClass.newInstance();
+ //message class
+ java.lang.String messageClassName = (java.lang.String)faultMessageMap.get(faultElt.getQName());
+ java.lang.Class messageClass = java.lang.Class.forName(messageClassName);
+ java.lang.Object messageObject = fromOM(faultElt,messageClass,null);
+ java.lang.reflect.Method m = exceptionClass.getMethod("setFaultMessage",
+ new java.lang.Class[]{messageClass});
+ m.invoke(ex,new java.lang.Object[]{messageObject});
+
+
+ throw new java.rmi.RemoteException(ex.getMessage(), ex);
+ }catch(java.lang.ClassCastException e){
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.ClassNotFoundException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ }catch (java.lang.NoSuchMethodException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.reflect.InvocationTargetException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.IllegalAccessException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.InstantiationException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ }
+ }else{
+ throw f;
+ }
+ }else{
+ throw f;
+ }
+ } finally {
+ _messageContext.getTransportOut().getSender().cleanup(_messageContext);
+ }
+ }
+
+ /**
+ * Auto generated method signature for Asynchronous Invocations
+ *
+ * @see com.frentix.olat.vc.provider.vitero.stubs.MtomService#startloadFile
+ * @param loadFileRequest0
+
+ */
+ public void startloadFile(
+
+ com.frentix.olat.vitero.manager.stubs.MtomServiceStub.LoadFileRequest loadFileRequest0,
+
+ final com.frentix.olat.vitero.manager.stubs.MtomServiceCallbackHandler callback)
+
+ throws java.rmi.RemoteException{
+
+ org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[0].getName());
+ _operationClient.getOptions().setAction("\"\"");
+ _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true);
+
+
+
+ addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&");
+
+
+
+ // create SOAP envelope with that payload
+ org.apache.axiom.soap.SOAPEnvelope env=null;
+ final org.apache.axis2.context.MessageContext _messageContext = new org.apache.axis2.context.MessageContext();
+
+
+ //Style is Doc.
+
+
+ env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()),
+ loadFileRequest0,
+ optimizeContent(new javax.xml.namespace.QName("http://www.vitero.de/schema/mtom",
+ "loadFile")));
+
+ // adding SOAP soap_headers
+ _serviceClient.addHeadersToEnvelope(env);
+ // create message context with that soap envelope
+ _messageContext.setEnvelope(env);
+
+ // add the message context to the operation client
+ _operationClient.addMessageContext(_messageContext);
+
+
+
+ _operationClient.setCallback(new org.apache.axis2.client.async.AxisCallback() {
+ public void onMessage(org.apache.axis2.context.MessageContext resultContext) {
+ try {
+ org.apache.axiom.soap.SOAPEnvelope resultEnv = resultContext.getEnvelope();
+
+ java.lang.Object object = fromOM(resultEnv.getBody().getFirstElement(),
+ com.frentix.olat.vitero.manager.stubs.MtomServiceStub.LoadFileResponse.class,
+ getEnvelopeNamespaces(resultEnv));
+ callback.receiveResultloadFile(
+ (com.frentix.olat.vitero.manager.stubs.MtomServiceStub.LoadFileResponse)object);
+
+ } catch (org.apache.axis2.AxisFault e) {
+ callback.receiveErrorloadFile(e);
+ }
+ }
+
+ public void onError(java.lang.Exception error) {
+ if (error instanceof org.apache.axis2.AxisFault) {
+ org.apache.axis2.AxisFault f = (org.apache.axis2.AxisFault) error;
+ org.apache.axiom.om.OMElement faultElt = f.getDetail();
+ if (faultElt!=null){
+ if (faultExceptionNameMap.containsKey(faultElt.getQName())){
+ //make the fault by reflection
+ try{
+ java.lang.String exceptionClassName = (java.lang.String)faultExceptionClassNameMap.get(faultElt.getQName());
+ java.lang.Class exceptionClass = java.lang.Class.forName(exceptionClassName);
+ java.lang.Exception ex=
+ (java.lang.Exception) exceptionClass.newInstance();
+ //message class
+ java.lang.String messageClassName = (java.lang.String)faultMessageMap.get(faultElt.getQName());
+ java.lang.Class messageClass = java.lang.Class.forName(messageClassName);
+ java.lang.Object messageObject = fromOM(faultElt,messageClass,null);
+ java.lang.reflect.Method m = exceptionClass.getMethod("setFaultMessage",
+ new java.lang.Class[]{messageClass});
+ m.invoke(ex,new java.lang.Object[]{messageObject});
+
+
+ callback.receiveErrorloadFile(new java.rmi.RemoteException(ex.getMessage(), ex));
+ } catch(java.lang.ClassCastException e){
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorloadFile(f);
+ } catch (java.lang.ClassNotFoundException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorloadFile(f);
+ } catch (java.lang.NoSuchMethodException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorloadFile(f);
+ } catch (java.lang.reflect.InvocationTargetException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorloadFile(f);
+ } catch (java.lang.IllegalAccessException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorloadFile(f);
+ } catch (java.lang.InstantiationException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorloadFile(f);
+ } catch (org.apache.axis2.AxisFault e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorloadFile(f);
+ }
+ } else {
+ callback.receiveErrorloadFile(f);
+ }
+ } else {
+ callback.receiveErrorloadFile(f);
+ }
+ } else {
+ callback.receiveErrorloadFile(error);
+ }
+ }
+
+ public void onFault(org.apache.axis2.context.MessageContext faultContext) {
+ org.apache.axis2.AxisFault fault = org.apache.axis2.util.Utils.getInboundFaultFromMessageContext(faultContext);
+ onError(fault);
+ }
+
+ public void onComplete() {
+ try {
+ _messageContext.getTransportOut().getSender().cleanup(_messageContext);
+ } catch (org.apache.axis2.AxisFault axisFault) {
+ callback.receiveErrorloadFile(axisFault);
+ }
+ }
+ });
+
+
+ org.apache.axis2.util.CallbackReceiver _callbackReceiver = null;
+ if ( _operations[0].getMessageReceiver()==null && _operationClient.getOptions().isUseSeparateListener()) {
+ _callbackReceiver = new org.apache.axis2.util.CallbackReceiver();
+ _operations[0].setMessageReceiver(
+ _callbackReceiver);
+ }
+
+ //execute the operation client
+ _operationClient.execute(false);
+
+ }
+
+
+ /**
+ * Auto generated method signature
+ *
+ */
+ public void storeAvatar(
+ com.frentix.olat.vitero.manager.stubs.MtomServiceStub.StoreAvatarRequest storeAvatarRequest2
+
+ ) throws java.rmi.RemoteException
+
+
+ {
+ org.apache.axis2.context.MessageContext _messageContext = null;
+
+
+ org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[1].getName());
+ _operationClient.getOptions().setAction("\"\"");
+ _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true);
+
+
+
+ addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&");
+
+ org.apache.axiom.soap.SOAPEnvelope env = null;
+ _messageContext = new org.apache.axis2.context.MessageContext();
+
+
+ //Style is Doc.
+
+
+ env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()),
+ storeAvatarRequest2,
+ optimizeContent(new javax.xml.namespace.QName("http://www.vitero.de/schema/mtom",
+ "storeAvatar")));
+
+
+ //adding SOAP soap_headers
+ _serviceClient.addHeadersToEnvelope(env);
+ // create message context with that soap envelope
+
+ _messageContext.setEnvelope(env);
+
+ // add the message contxt to the operation client
+ _operationClient.addMessageContext(_messageContext);
+
+ _operationClient.execute(true);
+
+
+ _messageContext.getTransportOut().getSender().cleanup(_messageContext);
+
+ return;
+ }
+
+ /**
+ * Auto generated method signature
+ *
+ * @see com.frentix.olat.vc.provider.vitero.stubs.MtomService#loadAvatar
+ * @param loadAvatarRequest3
+
+ */
+
+
+
+ public com.frentix.olat.vitero.manager.stubs.MtomServiceStub.LoadAvatarResponse loadAvatar(
+
+ com.frentix.olat.vitero.manager.stubs.MtomServiceStub.LoadAvatarRequest loadAvatarRequest3)
+
+
+ throws java.rmi.RemoteException
+
+ {
+ org.apache.axis2.context.MessageContext _messageContext = null;
+ try{
+ org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[2].getName());
+ _operationClient.getOptions().setAction("\"\"");
+ _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true);
+
+
+
+ addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&");
+
+
+ // create a message context
+ _messageContext = new org.apache.axis2.context.MessageContext();
+
+
+
+ // create SOAP envelope with that payload
+ org.apache.axiom.soap.SOAPEnvelope env = null;
+
+
+ env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()),
+ loadAvatarRequest3,
+ optimizeContent(new javax.xml.namespace.QName("http://www.vitero.de/schema/mtom",
+ "loadAvatar")));
+
+ //adding SOAP soap_headers
+ _serviceClient.addHeadersToEnvelope(env);
+ // set the message context with that soap envelope
+ _messageContext.setEnvelope(env);
+
+ // add the message contxt to the operation client
+ _operationClient.addMessageContext(_messageContext);
+
+ //execute the operation client
+ _operationClient.execute(true);
+
+
+ org.apache.axis2.context.MessageContext _returnMessageContext = _operationClient.getMessageContext(
+ org.apache.axis2.wsdl.WSDLConstants.MESSAGE_LABEL_IN_VALUE);
+ org.apache.axiom.soap.SOAPEnvelope _returnEnv = _returnMessageContext.getEnvelope();
+
+
+ java.lang.Object object = fromOM(
+ _returnEnv.getBody().getFirstElement() ,
+ com.frentix.olat.vitero.manager.stubs.MtomServiceStub.LoadAvatarResponse.class,
+ getEnvelopeNamespaces(_returnEnv));
+
+
+ return (com.frentix.olat.vitero.manager.stubs.MtomServiceStub.LoadAvatarResponse)object;
+
+ }catch(org.apache.axis2.AxisFault f){
+
+ org.apache.axiom.om.OMElement faultElt = f.getDetail();
+ if (faultElt!=null){
+ if (faultExceptionNameMap.containsKey(faultElt.getQName())){
+ //make the fault by reflection
+ try{
+ java.lang.String exceptionClassName = (java.lang.String)faultExceptionClassNameMap.get(faultElt.getQName());
+ java.lang.Class exceptionClass = java.lang.Class.forName(exceptionClassName);
+ java.lang.Exception ex=
+ (java.lang.Exception) exceptionClass.newInstance();
+ //message class
+ java.lang.String messageClassName = (java.lang.String)faultMessageMap.get(faultElt.getQName());
+ java.lang.Class messageClass = java.lang.Class.forName(messageClassName);
+ java.lang.Object messageObject = fromOM(faultElt,messageClass,null);
+ java.lang.reflect.Method m = exceptionClass.getMethod("setFaultMessage",
+ new java.lang.Class[]{messageClass});
+ m.invoke(ex,new java.lang.Object[]{messageObject});
+
+
+ throw new java.rmi.RemoteException(ex.getMessage(), ex);
+ }catch(java.lang.ClassCastException e){
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.ClassNotFoundException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ }catch (java.lang.NoSuchMethodException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.reflect.InvocationTargetException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.IllegalAccessException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.InstantiationException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ }
+ }else{
+ throw f;
+ }
+ }else{
+ throw f;
+ }
+ } finally {
+ _messageContext.getTransportOut().getSender().cleanup(_messageContext);
+ }
+ }
+
+ /**
+ * Auto generated method signature for Asynchronous Invocations
+ *
+ * @see com.frentix.olat.vc.provider.vitero.stubs.MtomService#startloadAvatar
+ * @param loadAvatarRequest3
+
+ */
+ public void startloadAvatar(
+
+ com.frentix.olat.vitero.manager.stubs.MtomServiceStub.LoadAvatarRequest loadAvatarRequest3,
+
+ final com.frentix.olat.vitero.manager.stubs.MtomServiceCallbackHandler callback)
+
+ throws java.rmi.RemoteException{
+
+ org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[2].getName());
+ _operationClient.getOptions().setAction("\"\"");
+ _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true);
+
+
+
+ addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&");
+
+
+
+ // create SOAP envelope with that payload
+ org.apache.axiom.soap.SOAPEnvelope env=null;
+ final org.apache.axis2.context.MessageContext _messageContext = new org.apache.axis2.context.MessageContext();
+
+
+ //Style is Doc.
+
+
+ env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()),
+ loadAvatarRequest3,
+ optimizeContent(new javax.xml.namespace.QName("http://www.vitero.de/schema/mtom",
+ "loadAvatar")));
+
+ // adding SOAP soap_headers
+ _serviceClient.addHeadersToEnvelope(env);
+ // create message context with that soap envelope
+ _messageContext.setEnvelope(env);
+
+ // add the message context to the operation client
+ _operationClient.addMessageContext(_messageContext);
+
+
+
+ _operationClient.setCallback(new org.apache.axis2.client.async.AxisCallback() {
+ public void onMessage(org.apache.axis2.context.MessageContext resultContext) {
+ try {
+ org.apache.axiom.soap.SOAPEnvelope resultEnv = resultContext.getEnvelope();
+
+ java.lang.Object object = fromOM(resultEnv.getBody().getFirstElement(),
+ com.frentix.olat.vitero.manager.stubs.MtomServiceStub.LoadAvatarResponse.class,
+ getEnvelopeNamespaces(resultEnv));
+ callback.receiveResultloadAvatar(
+ (com.frentix.olat.vitero.manager.stubs.MtomServiceStub.LoadAvatarResponse)object);
+
+ } catch (org.apache.axis2.AxisFault e) {
+ callback.receiveErrorloadAvatar(e);
+ }
+ }
+
+ public void onError(java.lang.Exception error) {
+ if (error instanceof org.apache.axis2.AxisFault) {
+ org.apache.axis2.AxisFault f = (org.apache.axis2.AxisFault) error;
+ org.apache.axiom.om.OMElement faultElt = f.getDetail();
+ if (faultElt!=null){
+ if (faultExceptionNameMap.containsKey(faultElt.getQName())){
+ //make the fault by reflection
+ try{
+ java.lang.String exceptionClassName = (java.lang.String)faultExceptionClassNameMap.get(faultElt.getQName());
+ java.lang.Class exceptionClass = java.lang.Class.forName(exceptionClassName);
+ java.lang.Exception ex=
+ (java.lang.Exception) exceptionClass.newInstance();
+ //message class
+ java.lang.String messageClassName = (java.lang.String)faultMessageMap.get(faultElt.getQName());
+ java.lang.Class messageClass = java.lang.Class.forName(messageClassName);
+ java.lang.Object messageObject = fromOM(faultElt,messageClass,null);
+ java.lang.reflect.Method m = exceptionClass.getMethod("setFaultMessage",
+ new java.lang.Class[]{messageClass});
+ m.invoke(ex,new java.lang.Object[]{messageObject});
+
+
+ callback.receiveErrorloadAvatar(new java.rmi.RemoteException(ex.getMessage(), ex));
+ } catch(java.lang.ClassCastException e){
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorloadAvatar(f);
+ } catch (java.lang.ClassNotFoundException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorloadAvatar(f);
+ } catch (java.lang.NoSuchMethodException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorloadAvatar(f);
+ } catch (java.lang.reflect.InvocationTargetException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorloadAvatar(f);
+ } catch (java.lang.IllegalAccessException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorloadAvatar(f);
+ } catch (java.lang.InstantiationException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorloadAvatar(f);
+ } catch (org.apache.axis2.AxisFault e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorloadAvatar(f);
+ }
+ } else {
+ callback.receiveErrorloadAvatar(f);
+ }
+ } else {
+ callback.receiveErrorloadAvatar(f);
+ }
+ } else {
+ callback.receiveErrorloadAvatar(error);
+ }
+ }
+
+ public void onFault(org.apache.axis2.context.MessageContext faultContext) {
+ org.apache.axis2.AxisFault fault = org.apache.axis2.util.Utils.getInboundFaultFromMessageContext(faultContext);
+ onError(fault);
+ }
+
+ public void onComplete() {
+ try {
+ _messageContext.getTransportOut().getSender().cleanup(_messageContext);
+ } catch (org.apache.axis2.AxisFault axisFault) {
+ callback.receiveErrorloadAvatar(axisFault);
+ }
+ }
+ });
+
+
+ org.apache.axis2.util.CallbackReceiver _callbackReceiver = null;
+ if ( _operations[2].getMessageReceiver()==null && _operationClient.getOptions().isUseSeparateListener()) {
+ _callbackReceiver = new org.apache.axis2.util.CallbackReceiver();
+ _operations[2].setMessageReceiver(
+ _callbackReceiver);
+ }
+
+ //execute the operation client
+ _operationClient.execute(false);
+
+ }
+
+ /**
+ * Auto generated method signature
+ *
+ * @see com.frentix.olat.vc.provider.vitero.stubs.MtomService#storeFile
+ * @param storeFileRequest5
+
+ */
+
+
+
+ public com.frentix.olat.vitero.manager.stubs.MtomServiceStub.StoreFileResponse storeFile(
+
+ com.frentix.olat.vitero.manager.stubs.MtomServiceStub.StoreFileRequest storeFileRequest5)
+
+
+ throws java.rmi.RemoteException
+
+ {
+ org.apache.axis2.context.MessageContext _messageContext = null;
+ try{
+ org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[3].getName());
+ _operationClient.getOptions().setAction("\"\"");
+ _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true);
+
+
+
+ addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&");
+
+
+ // create a message context
+ _messageContext = new org.apache.axis2.context.MessageContext();
+
+
+
+ // create SOAP envelope with that payload
+ org.apache.axiom.soap.SOAPEnvelope env = null;
+
+
+ env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()),
+ storeFileRequest5,
+ optimizeContent(new javax.xml.namespace.QName("http://www.vitero.de/schema/mtom",
+ "storeFile")));
+
+ //adding SOAP soap_headers
+ _serviceClient.addHeadersToEnvelope(env);
+ // set the message context with that soap envelope
+ _messageContext.setEnvelope(env);
+
+ // add the message contxt to the operation client
+ _operationClient.addMessageContext(_messageContext);
+
+ //execute the operation client
+ _operationClient.execute(true);
+
+
+ org.apache.axis2.context.MessageContext _returnMessageContext = _operationClient.getMessageContext(
+ org.apache.axis2.wsdl.WSDLConstants.MESSAGE_LABEL_IN_VALUE);
+ org.apache.axiom.soap.SOAPEnvelope _returnEnv = _returnMessageContext.getEnvelope();
+
+
+ java.lang.Object object = fromOM(
+ _returnEnv.getBody().getFirstElement() ,
+ com.frentix.olat.vitero.manager.stubs.MtomServiceStub.StoreFileResponse.class,
+ getEnvelopeNamespaces(_returnEnv));
+
+
+ return (com.frentix.olat.vitero.manager.stubs.MtomServiceStub.StoreFileResponse)object;
+
+ }catch(org.apache.axis2.AxisFault f){
+
+ org.apache.axiom.om.OMElement faultElt = f.getDetail();
+ if (faultElt!=null){
+ if (faultExceptionNameMap.containsKey(faultElt.getQName())){
+ //make the fault by reflection
+ try{
+ java.lang.String exceptionClassName = (java.lang.String)faultExceptionClassNameMap.get(faultElt.getQName());
+ java.lang.Class exceptionClass = java.lang.Class.forName(exceptionClassName);
+ java.lang.Exception ex=
+ (java.lang.Exception) exceptionClass.newInstance();
+ //message class
+ java.lang.String messageClassName = (java.lang.String)faultMessageMap.get(faultElt.getQName());
+ java.lang.Class messageClass = java.lang.Class.forName(messageClassName);
+ java.lang.Object messageObject = fromOM(faultElt,messageClass,null);
+ java.lang.reflect.Method m = exceptionClass.getMethod("setFaultMessage",
+ new java.lang.Class[]{messageClass});
+ m.invoke(ex,new java.lang.Object[]{messageObject});
+
+
+ throw new java.rmi.RemoteException(ex.getMessage(), ex);
+ }catch(java.lang.ClassCastException e){
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.ClassNotFoundException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ }catch (java.lang.NoSuchMethodException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.reflect.InvocationTargetException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.IllegalAccessException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.InstantiationException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ }
+ }else{
+ throw f;
+ }
+ }else{
+ throw f;
+ }
+ } finally {
+ _messageContext.getTransportOut().getSender().cleanup(_messageContext);
+ }
+ }
+
+ /**
+ * Auto generated method signature for Asynchronous Invocations
+ *
+ * @see com.frentix.olat.vc.provider.vitero.stubs.MtomService#startstoreFile
+ * @param storeFileRequest5
+
+ */
+ public void startstoreFile(
+
+ com.frentix.olat.vitero.manager.stubs.MtomServiceStub.StoreFileRequest storeFileRequest5,
+
+ final com.frentix.olat.vitero.manager.stubs.MtomServiceCallbackHandler callback)
+
+ throws java.rmi.RemoteException{
+
+ org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[3].getName());
+ _operationClient.getOptions().setAction("\"\"");
+ _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true);
+
+
+
+ addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&");
+
+
+
+ // create SOAP envelope with that payload
+ org.apache.axiom.soap.SOAPEnvelope env=null;
+ final org.apache.axis2.context.MessageContext _messageContext = new org.apache.axis2.context.MessageContext();
+
+
+ //Style is Doc.
+
+
+ env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()),
+ storeFileRequest5,
+ optimizeContent(new javax.xml.namespace.QName("http://www.vitero.de/schema/mtom",
+ "storeFile")));
+
+ // adding SOAP soap_headers
+ _serviceClient.addHeadersToEnvelope(env);
+ // create message context with that soap envelope
+ _messageContext.setEnvelope(env);
+
+ // add the message context to the operation client
+ _operationClient.addMessageContext(_messageContext);
+
+
+
+ _operationClient.setCallback(new org.apache.axis2.client.async.AxisCallback() {
+ public void onMessage(org.apache.axis2.context.MessageContext resultContext) {
+ try {
+ org.apache.axiom.soap.SOAPEnvelope resultEnv = resultContext.getEnvelope();
+
+ java.lang.Object object = fromOM(resultEnv.getBody().getFirstElement(),
+ com.frentix.olat.vitero.manager.stubs.MtomServiceStub.StoreFileResponse.class,
+ getEnvelopeNamespaces(resultEnv));
+ callback.receiveResultstoreFile(
+ (com.frentix.olat.vitero.manager.stubs.MtomServiceStub.StoreFileResponse)object);
+
+ } catch (org.apache.axis2.AxisFault e) {
+ callback.receiveErrorstoreFile(e);
+ }
+ }
+
+ public void onError(java.lang.Exception error) {
+ if (error instanceof org.apache.axis2.AxisFault) {
+ org.apache.axis2.AxisFault f = (org.apache.axis2.AxisFault) error;
+ org.apache.axiom.om.OMElement faultElt = f.getDetail();
+ if (faultElt!=null){
+ if (faultExceptionNameMap.containsKey(faultElt.getQName())){
+ //make the fault by reflection
+ try{
+ java.lang.String exceptionClassName = (java.lang.String)faultExceptionClassNameMap.get(faultElt.getQName());
+ java.lang.Class exceptionClass = java.lang.Class.forName(exceptionClassName);
+ java.lang.Exception ex=
+ (java.lang.Exception) exceptionClass.newInstance();
+ //message class
+ java.lang.String messageClassName = (java.lang.String)faultMessageMap.get(faultElt.getQName());
+ java.lang.Class messageClass = java.lang.Class.forName(messageClassName);
+ java.lang.Object messageObject = fromOM(faultElt,messageClass,null);
+ java.lang.reflect.Method m = exceptionClass.getMethod("setFaultMessage",
+ new java.lang.Class[]{messageClass});
+ m.invoke(ex,new java.lang.Object[]{messageObject});
+
+
+ callback.receiveErrorstoreFile(new java.rmi.RemoteException(ex.getMessage(), ex));
+ } catch(java.lang.ClassCastException e){
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorstoreFile(f);
+ } catch (java.lang.ClassNotFoundException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorstoreFile(f);
+ } catch (java.lang.NoSuchMethodException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorstoreFile(f);
+ } catch (java.lang.reflect.InvocationTargetException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorstoreFile(f);
+ } catch (java.lang.IllegalAccessException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorstoreFile(f);
+ } catch (java.lang.InstantiationException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorstoreFile(f);
+ } catch (org.apache.axis2.AxisFault e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorstoreFile(f);
+ }
+ } else {
+ callback.receiveErrorstoreFile(f);
+ }
+ } else {
+ callback.receiveErrorstoreFile(f);
+ }
+ } else {
+ callback.receiveErrorstoreFile(error);
+ }
+ }
+
+ public void onFault(org.apache.axis2.context.MessageContext faultContext) {
+ org.apache.axis2.AxisFault fault = org.apache.axis2.util.Utils.getInboundFaultFromMessageContext(faultContext);
+ onError(fault);
+ }
+
+ public void onComplete() {
+ try {
+ _messageContext.getTransportOut().getSender().cleanup(_messageContext);
+ } catch (org.apache.axis2.AxisFault axisFault) {
+ callback.receiveErrorstoreFile(axisFault);
+ }
+ }
+ });
+
+
+ org.apache.axis2.util.CallbackReceiver _callbackReceiver = null;
+ if ( _operations[3].getMessageReceiver()==null && _operationClient.getOptions().isUseSeparateListener()) {
+ _callbackReceiver = new org.apache.axis2.util.CallbackReceiver();
+ _operations[3].setMessageReceiver(
+ _callbackReceiver);
+ }
+
+ //execute the operation client
+ _operationClient.execute(false);
+
+ }
+
+
+
+ /**
+ * A utility method that copies the namepaces from the SOAPEnvelope
+ */
+ private java.util.Map getEnvelopeNamespaces(org.apache.axiom.soap.SOAPEnvelope env){
+ java.util.Map returnMap = new java.util.HashMap();
+ java.util.Iterator namespaceIterator = env.getAllDeclaredNamespaces();
+ while (namespaceIterator.hasNext()) {
+ org.apache.axiom.om.OMNamespace ns = (org.apache.axiom.om.OMNamespace) namespaceIterator.next();
+ returnMap.put(ns.getPrefix(),ns.getNamespaceURI());
+ }
+ return returnMap;
+ }
+
+
+
+ private javax.xml.namespace.QName[] opNameArray = null;
+ private boolean optimizeContent(javax.xml.namespace.QName opName) {
+
+
+ if (opNameArray == null) {
+ return false;
+ }
+ for (int i = 0; i < opNameArray.length; i++) {
+ if (opName.equals(opNameArray[i])) {
+ return true;
+ }
+ }
+ return false;
+ }
+ //http://192.168.1.54:8080/vitero/services/
+ public static class StoreFileRequest
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/mtom",
+ "storeFileRequest",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/mtom")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for StoreFileRequest
+ */
+
+
+ protected FileWrapper localStoreFileRequest ;
+
+
+ /**
+ * Auto generated getter method
+ * @return FileWrapper
+ */
+ public FileWrapper getStoreFileRequest(){
+ return localStoreFileRequest;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param StoreFileRequest
+ */
+ public void setStoreFileRequest(FileWrapper param){
+
+ this.localStoreFileRequest=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ StoreFileRequest.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+ //We can safely assume an element has only one type associated with it
+
+ if (localStoreFileRequest==null){
+ throw new org.apache.axis2.databinding.ADBException("Property cannot be null!");
+ }
+ localStoreFileRequest.serialize(MY_QNAME,factory,xmlWriter);
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+
+ //We can safely assume an element has only one type associated with it
+ return localStoreFileRequest.getPullParser(MY_QNAME);
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static StoreFileRequest parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ StoreFileRequest object =
+ new StoreFileRequest();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/mtom","storeFileRequest").equals(reader.getName())){
+
+ object.setStoreFileRequest(FileWrapper.Factory.parse(reader));
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class SuccessResponse
+ implements org.apache.axis2.databinding.ADBBean{
+ /* This type was generated from the piece of schema that had
+ name = SuccessResponse
+ Namespace URI = http://www.vitero.de/schema/mtom
+ Namespace Prefix = ns1
+ */
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/mtom")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for Request
+ */
+
+
+ protected java.lang.String localRequest ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getRequest(){
+ return localRequest;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Request
+ */
+ public void setRequest(java.lang.String param){
+
+ this.localRequest=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,parentQName){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ SuccessResponse.this.serialize(parentQName,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ parentQName,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/mtom");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":SuccessResponse",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "SuccessResponse",
+ xmlWriter);
+ }
+
+
+ }
+
+ namespace = "http://www.vitero.de/schema/mtom";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"request", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"request");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("request");
+ }
+
+
+ if (localRequest==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("request cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localRequest);
+
+ }
+
+ xmlWriter.writeEndElement();
+
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/mtom",
+ "request"));
+
+ if (localRequest != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localRequest));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("request cannot be null!!");
+ }
+
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static SuccessResponse parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ SuccessResponse object =
+ new SuccessResponse();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"SuccessResponse".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (SuccessResponse)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/mtom","request").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setRequest(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class LoadAvatarRequest
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/mtom",
+ "loadAvatarRequest",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/mtom")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for LoadAvatarRequest
+ */
+
+
+ protected AvatarInformation localLoadAvatarRequest ;
+
+
+ /**
+ * Auto generated getter method
+ * @return AvatarInformation
+ */
+ public AvatarInformation getLoadAvatarRequest(){
+ return localLoadAvatarRequest;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param LoadAvatarRequest
+ */
+ public void setLoadAvatarRequest(AvatarInformation param){
+
+ this.localLoadAvatarRequest=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ LoadAvatarRequest.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+ //We can safely assume an element has only one type associated with it
+
+ if (localLoadAvatarRequest==null){
+ throw new org.apache.axis2.databinding.ADBException("Property cannot be null!");
+ }
+ localLoadAvatarRequest.serialize(MY_QNAME,factory,xmlWriter);
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+
+ //We can safely assume an element has only one type associated with it
+ return localLoadAvatarRequest.getPullParser(MY_QNAME);
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static LoadAvatarRequest parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ LoadAvatarRequest object =
+ new LoadAvatarRequest();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/mtom","loadAvatarRequest").equals(reader.getName())){
+
+ object.setLoadAvatarRequest(AvatarInformation.Factory.parse(reader));
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class AvatarInformation
+ implements org.apache.axis2.databinding.ADBBean{
+ /* This type was generated from the piece of schema that had
+ name = AvatarInformation
+ Namespace URI = http://www.vitero.de/schema/mtom
+ Namespace Prefix = ns1
+ */
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/mtom")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for Userid
+ */
+
+
+ protected java.math.BigInteger localUserid ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.math.BigInteger
+ */
+ public java.math.BigInteger getUserid(){
+ return localUserid;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Userid
+ */
+ public void setUserid(java.math.BigInteger param){
+
+ this.localUserid=param;
+
+
+ }
+
+
+ /**
+ * field for Type
+ */
+
+
+ protected java.math.BigInteger localType ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localTypeTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.math.BigInteger
+ */
+ public java.math.BigInteger getType(){
+ return localType;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Type
+ */
+ public void setType(java.math.BigInteger param){
+
+ if (param != null){
+ //update the setting tracker
+ localTypeTracker = true;
+ } else {
+ localTypeTracker = false;
+
+ }
+
+ this.localType=param;
+
+
+ }
+
+
+ /**
+ * field for Size
+ */
+
+
+ protected java.math.BigInteger localSize ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localSizeTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.math.BigInteger
+ */
+ public java.math.BigInteger getSize(){
+ return localSize;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Size
+ */
+ public void setSize(java.math.BigInteger param){
+
+ if (param != null){
+ //update the setting tracker
+ localSizeTracker = true;
+ } else {
+ localSizeTracker = false;
+
+ }
+
+ this.localSize=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,parentQName){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ AvatarInformation.this.serialize(parentQName,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ parentQName,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/mtom");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":AvatarInformation",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "AvatarInformation",
+ xmlWriter);
+ }
+
+
+ }
+
+ namespace = "http://www.vitero.de/schema/mtom";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"userid", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"userid");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("userid");
+ }
+
+
+ if (localUserid==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("userid cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localUserid));
+
+ }
+
+ xmlWriter.writeEndElement();
+ if (localTypeTracker){
+ namespace = "http://www.vitero.de/schema/mtom";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"type", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"type");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("type");
+ }
+
+
+ if (localType==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("type cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localType));
+
+ }
+
+ xmlWriter.writeEndElement();
+ } if (localSizeTracker){
+ namespace = "http://www.vitero.de/schema/mtom";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"size", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"size");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("size");
+ }
+
+
+ if (localSize==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("size cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localSize));
+
+ }
+
+ xmlWriter.writeEndElement();
+ }
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/mtom",
+ "userid"));
+
+ if (localUserid != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localUserid));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("userid cannot be null!!");
+ }
+ if (localTypeTracker){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/mtom",
+ "type"));
+
+ if (localType != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localType));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("type cannot be null!!");
+ }
+ } if (localSizeTracker){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/mtom",
+ "size"));
+
+ if (localSize != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localSize));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("size cannot be null!!");
+ }
+ }
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static AvatarInformation parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ AvatarInformation object =
+ new AvatarInformation();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"AvatarInformation".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (AvatarInformation)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/mtom","userid").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setUserid(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToInteger(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/mtom","type").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setType(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToInteger(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/mtom","size").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setSize(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToInteger(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class SuccessResponseE
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/mtom",
+ "successResponse",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/mtom")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for SuccessResponse
+ */
+
+
+ protected SuccessResponse localSuccessResponse ;
+
+
+ /**
+ * Auto generated getter method
+ * @return SuccessResponse
+ */
+ public SuccessResponse getSuccessResponse(){
+ return localSuccessResponse;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param SuccessResponse
+ */
+ public void setSuccessResponse(SuccessResponse param){
+
+ this.localSuccessResponse=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ SuccessResponseE.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+ //We can safely assume an element has only one type associated with it
+
+ if (localSuccessResponse==null){
+ throw new org.apache.axis2.databinding.ADBException("Property cannot be null!");
+ }
+ localSuccessResponse.serialize(MY_QNAME,factory,xmlWriter);
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+
+ //We can safely assume an element has only one type associated with it
+ return localSuccessResponse.getPullParser(MY_QNAME);
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static SuccessResponseE parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ SuccessResponseE object =
+ new SuccessResponseE();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/mtom","successResponse").equals(reader.getName())){
+
+ object.setSuccessResponse(SuccessResponse.Factory.parse(reader));
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class AvatarWrapper
+ implements org.apache.axis2.databinding.ADBBean{
+ /* This type was generated from the piece of schema that had
+ name = AvatarWrapper
+ Namespace URI = http://www.vitero.de/schema/mtom
+ Namespace Prefix = ns1
+ */
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/mtom")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for Filename
+ */
+
+
+ protected java.lang.String localFilename ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getFilename(){
+ return localFilename;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Filename
+ */
+ public void setFilename(java.lang.String param){
+
+ this.localFilename=param;
+
+
+ }
+
+
+ /**
+ * field for File
+ */
+
+
+ protected javax.activation.DataHandler localFile ;
+
+
+ /**
+ * Auto generated getter method
+ * @return javax.activation.DataHandler
+ */
+ public javax.activation.DataHandler getFile(){
+ return localFile;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param File
+ */
+ public void setFile(javax.activation.DataHandler param){
+
+ this.localFile=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,parentQName){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ AvatarWrapper.this.serialize(parentQName,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ parentQName,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/mtom");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":AvatarWrapper",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "AvatarWrapper",
+ xmlWriter);
+ }
+
+
+ }
+
+ namespace = "http://www.vitero.de/schema/mtom";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"filename", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"filename");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("filename");
+ }
+
+
+ if (localFilename==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("filename cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localFilename);
+
+ }
+
+ xmlWriter.writeEndElement();
+
+ namespace = "http://www.vitero.de/schema/mtom";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"file", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"file");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("file");
+ }
+
+
+ if (localFile!=null)
+ {
+ xmlWriter.writeDataHandler(localFile);
+ }
+
+ xmlWriter.writeEndElement();
+
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/mtom",
+ "filename"));
+
+ if (localFilename != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localFilename));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("filename cannot be null!!");
+ }
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/mtom",
+ "file"));
+
+ elementList.add(localFile);
+
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static AvatarWrapper parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ AvatarWrapper object =
+ new AvatarWrapper();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"AvatarWrapper".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (AvatarWrapper)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/mtom","filename").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setFilename(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/mtom","file").equals(reader.getName())){
+ reader.next();
+ if (isReaderMTOMAware(reader)
+ &&
+ java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_BINARY)))
+ {
+ //MTOM aware reader - get the datahandler directly and put it in the object
+ object.setFile(
+ (javax.activation.DataHandler) reader.getProperty(org.apache.axiom.om.OMConstants.DATA_HANDLER));
+ } else {
+ if (reader.getEventType() == javax.xml.stream.XMLStreamConstants.START_ELEMENT && reader.getName().equals(new javax.xml.namespace.QName(org.apache.axiom.om.impl.MTOMConstants.XOP_NAMESPACE_URI, org.apache.axiom.om.impl.MTOMConstants.XOP_INCLUDE)))
+ {
+ java.lang.String id = org.apache.axiom.om.util.ElementHelper.getContentID(reader, "UTF-8");
+ object.setFile(((org.apache.axiom.soap.impl.builder.MTOMStAXSOAPModelBuilder) ((org.apache.axiom.om.impl.llom.OMStAXWrapper) reader).getBuilder()).getDataHandler(id));
+ reader.next();
+
+ reader.next();
+
+ } else if(reader.hasText()) {
+ //Do the usual conversion
+ java.lang.String content = reader.getText();
+ object.setFile(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToBase64Binary(content));
+
+ reader.next();
+
+ }
+ }
+
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class StoreAvatarRequest
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/mtom",
+ "storeAvatarRequest",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/mtom")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for StoreAvatarRequest
+ */
+
+
+ protected CompleteAvatarWrapper localStoreAvatarRequest ;
+
+
+ /**
+ * Auto generated getter method
+ * @return CompleteAvatarWrapper
+ */
+ public CompleteAvatarWrapper getStoreAvatarRequest(){
+ return localStoreAvatarRequest;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param StoreAvatarRequest
+ */
+ public void setStoreAvatarRequest(CompleteAvatarWrapper param){
+
+ this.localStoreAvatarRequest=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ StoreAvatarRequest.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+ //We can safely assume an element has only one type associated with it
+
+ if (localStoreAvatarRequest==null){
+ throw new org.apache.axis2.databinding.ADBException("Property cannot be null!");
+ }
+ localStoreAvatarRequest.serialize(MY_QNAME,factory,xmlWriter);
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+
+ //We can safely assume an element has only one type associated with it
+ return localStoreAvatarRequest.getPullParser(MY_QNAME);
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static StoreAvatarRequest parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ StoreAvatarRequest object =
+ new StoreAvatarRequest();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/mtom","storeAvatarRequest").equals(reader.getName())){
+
+ object.setStoreAvatarRequest(CompleteAvatarWrapper.Factory.parse(reader));
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class LoadAvatarResponse
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/mtom",
+ "loadAvatarResponse",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/mtom")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for LoadAvatarResponse
+ */
+
+
+ protected AvatarWrapper localLoadAvatarResponse ;
+
+
+ /**
+ * Auto generated getter method
+ * @return AvatarWrapper
+ */
+ public AvatarWrapper getLoadAvatarResponse(){
+ return localLoadAvatarResponse;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param LoadAvatarResponse
+ */
+ public void setLoadAvatarResponse(AvatarWrapper param){
+
+ this.localLoadAvatarResponse=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ LoadAvatarResponse.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+ //We can safely assume an element has only one type associated with it
+
+ if (localLoadAvatarResponse==null){
+ throw new org.apache.axis2.databinding.ADBException("Property cannot be null!");
+ }
+ localLoadAvatarResponse.serialize(MY_QNAME,factory,xmlWriter);
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+
+ //We can safely assume an element has only one type associated with it
+ return localLoadAvatarResponse.getPullParser(MY_QNAME);
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static LoadAvatarResponse parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ LoadAvatarResponse object =
+ new LoadAvatarResponse();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/mtom","loadAvatarResponse").equals(reader.getName())){
+
+ object.setLoadAvatarResponse(AvatarWrapper.Factory.parse(reader));
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class LoadFileResponse
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/mtom",
+ "loadFileResponse",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/mtom")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for LoadFileResponse
+ */
+
+
+ protected FileWrapper localLoadFileResponse ;
+
+
+ /**
+ * Auto generated getter method
+ * @return FileWrapper
+ */
+ public FileWrapper getLoadFileResponse(){
+ return localLoadFileResponse;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param LoadFileResponse
+ */
+ public void setLoadFileResponse(FileWrapper param){
+
+ this.localLoadFileResponse=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ LoadFileResponse.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+ //We can safely assume an element has only one type associated with it
+
+ if (localLoadFileResponse==null){
+ throw new org.apache.axis2.databinding.ADBException("Property cannot be null!");
+ }
+ localLoadFileResponse.serialize(MY_QNAME,factory,xmlWriter);
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+
+ //We can safely assume an element has only one type associated with it
+ return localLoadFileResponse.getPullParser(MY_QNAME);
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static LoadFileResponse parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ LoadFileResponse object =
+ new LoadFileResponse();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/mtom","loadFileResponse").equals(reader.getName())){
+
+ object.setLoadFileResponse(FileWrapper.Factory.parse(reader));
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class LoadFileRequest
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/mtom",
+ "loadFileRequest",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/mtom")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for LoadFileRequest
+ */
+
+
+ protected IdWrapper localLoadFileRequest ;
+
+
+ /**
+ * Auto generated getter method
+ * @return IdWrapper
+ */
+ public IdWrapper getLoadFileRequest(){
+ return localLoadFileRequest;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param LoadFileRequest
+ */
+ public void setLoadFileRequest(IdWrapper param){
+
+ this.localLoadFileRequest=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ LoadFileRequest.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+ //We can safely assume an element has only one type associated with it
+
+ if (localLoadFileRequest==null){
+ throw new org.apache.axis2.databinding.ADBException("Property cannot be null!");
+ }
+ localLoadFileRequest.serialize(MY_QNAME,factory,xmlWriter);
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+
+ //We can safely assume an element has only one type associated with it
+ return localLoadFileRequest.getPullParser(MY_QNAME);
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static LoadFileRequest parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ LoadFileRequest object =
+ new LoadFileRequest();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/mtom","loadFileRequest").equals(reader.getName())){
+
+ object.setLoadFileRequest(IdWrapper.Factory.parse(reader));
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class CompleteAvatarWrapper
+ implements org.apache.axis2.databinding.ADBBean{
+ /* This type was generated from the piece of schema that had
+ name = CompleteAvatarWrapper
+ Namespace URI = http://www.vitero.de/schema/mtom
+ Namespace Prefix = ns1
+ */
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/mtom")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for Userid
+ */
+
+
+ protected java.math.BigInteger localUserid ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.math.BigInteger
+ */
+ public java.math.BigInteger getUserid(){
+ return localUserid;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Userid
+ */
+ public void setUserid(java.math.BigInteger param){
+
+ this.localUserid=param;
+
+
+ }
+
+
+ /**
+ * field for Type
+ */
+
+
+ protected java.math.BigInteger localType ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localTypeTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.math.BigInteger
+ */
+ public java.math.BigInteger getType(){
+ return localType;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Type
+ */
+ public void setType(java.math.BigInteger param){
+
+ if (param != null){
+ //update the setting tracker
+ localTypeTracker = true;
+ } else {
+ localTypeTracker = false;
+
+ }
+
+ this.localType=param;
+
+
+ }
+
+
+ /**
+ * field for Filename
+ */
+
+
+ protected java.lang.String localFilename ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getFilename(){
+ return localFilename;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Filename
+ */
+ public void setFilename(java.lang.String param){
+
+ this.localFilename=param;
+
+
+ }
+
+
+ /**
+ * field for File
+ */
+
+
+ protected javax.activation.DataHandler localFile ;
+
+
+ /**
+ * Auto generated getter method
+ * @return javax.activation.DataHandler
+ */
+ public javax.activation.DataHandler getFile(){
+ return localFile;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param File
+ */
+ public void setFile(javax.activation.DataHandler param){
+
+ this.localFile=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,parentQName){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ CompleteAvatarWrapper.this.serialize(parentQName,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ parentQName,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/mtom");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":CompleteAvatarWrapper",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "CompleteAvatarWrapper",
+ xmlWriter);
+ }
+
+
+ }
+
+ namespace = "http://www.vitero.de/schema/mtom";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"userid", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"userid");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("userid");
+ }
+
+
+ if (localUserid==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("userid cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localUserid));
+
+ }
+
+ xmlWriter.writeEndElement();
+ if (localTypeTracker){
+ namespace = "http://www.vitero.de/schema/mtom";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"type", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"type");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("type");
+ }
+
+
+ if (localType==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("type cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localType));
+
+ }
+
+ xmlWriter.writeEndElement();
+ }
+ namespace = "http://www.vitero.de/schema/mtom";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"filename", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"filename");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("filename");
+ }
+
+
+ if (localFilename==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("filename cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localFilename);
+
+ }
+
+ xmlWriter.writeEndElement();
+
+ namespace = "http://www.vitero.de/schema/mtom";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"file", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"file");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("file");
+ }
+
+
+ if (localFile!=null)
+ {
+ xmlWriter.writeDataHandler(localFile);
+ }
+
+ xmlWriter.writeEndElement();
+
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/mtom",
+ "userid"));
+
+ if (localUserid != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localUserid));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("userid cannot be null!!");
+ }
+ if (localTypeTracker){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/mtom",
+ "type"));
+
+ if (localType != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localType));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("type cannot be null!!");
+ }
+ }
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/mtom",
+ "filename"));
+
+ if (localFilename != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localFilename));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("filename cannot be null!!");
+ }
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/mtom",
+ "file"));
+
+ elementList.add(localFile);
+
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static CompleteAvatarWrapper parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ CompleteAvatarWrapper object =
+ new CompleteAvatarWrapper();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"CompleteAvatarWrapper".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (CompleteAvatarWrapper)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/mtom","userid").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setUserid(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToInteger(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/mtom","type").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setType(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToInteger(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/mtom","filename").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setFilename(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/mtom","file").equals(reader.getName())){
+ reader.next();
+ if (isReaderMTOMAware(reader)
+ &&
+ java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_BINARY)))
+ {
+ //MTOM aware reader - get the datahandler directly and put it in the object
+ object.setFile(
+ (javax.activation.DataHandler) reader.getProperty(org.apache.axiom.om.OMConstants.DATA_HANDLER));
+ } else {
+ if (reader.getEventType() == javax.xml.stream.XMLStreamConstants.START_ELEMENT && reader.getName().equals(new javax.xml.namespace.QName(org.apache.axiom.om.impl.MTOMConstants.XOP_NAMESPACE_URI, org.apache.axiom.om.impl.MTOMConstants.XOP_INCLUDE)))
+ {
+ java.lang.String id = org.apache.axiom.om.util.ElementHelper.getContentID(reader, "UTF-8");
+ object.setFile(((org.apache.axiom.soap.impl.builder.MTOMStAXSOAPModelBuilder) ((org.apache.axiom.om.impl.llom.OMStAXWrapper) reader).getBuilder()).getDataHandler(id));
+ reader.next();
+
+ reader.next();
+
+ } else if(reader.hasText()) {
+ //Do the usual conversion
+ java.lang.String content = reader.getText();
+ object.setFile(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToBase64Binary(content));
+
+ reader.next();
+
+ }
+ }
+
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class IdWrapper
+ implements org.apache.axis2.databinding.ADBBean{
+ /* This type was generated from the piece of schema that had
+ name = IdWrapper
+ Namespace URI = http://www.vitero.de/schema/mtom
+ Namespace Prefix = ns1
+ */
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/mtom")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for Nodeid
+ */
+
+
+ protected long localNodeid ;
+
+
+ /**
+ * Auto generated getter method
+ * @return long
+ */
+ public long getNodeid(){
+ return localNodeid;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Nodeid
+ */
+ public void setNodeid(long param){
+
+ this.localNodeid=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,parentQName){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ IdWrapper.this.serialize(parentQName,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ parentQName,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/mtom");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":IdWrapper",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "IdWrapper",
+ xmlWriter);
+ }
+
+
+ }
+
+ namespace = "http://www.vitero.de/schema/mtom";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"nodeid", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"nodeid");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("nodeid");
+ }
+
+ if (localNodeid==java.lang.Long.MIN_VALUE) {
+
+ throw new org.apache.axis2.databinding.ADBException("nodeid cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localNodeid));
+ }
+
+ xmlWriter.writeEndElement();
+
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/mtom",
+ "nodeid"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localNodeid));
+
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static IdWrapper parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ IdWrapper object =
+ new IdWrapper();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"IdWrapper".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (IdWrapper)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/mtom","nodeid").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setNodeid(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToLong(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class ExtensionMapper{
+
+ public static java.lang.Object getTypeObject(java.lang.String namespaceURI,
+ java.lang.String typeName,
+ javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+
+
+ if (
+ "http://www.vitero.de/schema/mtom".equals(namespaceURI) &&
+ "CompleteAvatarWrapper".equals(typeName)){
+
+ return CompleteAvatarWrapper.Factory.parse(reader);
+
+
+ }
+
+
+ if (
+ "http://www.vitero.de/schema/mtom".equals(namespaceURI) &&
+ "IdWrapper".equals(typeName)){
+
+ return IdWrapper.Factory.parse(reader);
+
+
+ }
+
+
+ if (
+ "http://www.vitero.de/schema/mtom".equals(namespaceURI) &&
+ "SuccessResponse".equals(typeName)){
+
+ return SuccessResponse.Factory.parse(reader);
+
+
+ }
+
+
+ if (
+ "http://www.vitero.de/schema/mtom".equals(namespaceURI) &&
+ "AvatarInformation".equals(typeName)){
+
+ return AvatarInformation.Factory.parse(reader);
+
+
+ }
+
+
+ if (
+ "http://www.vitero.de/schema/mtom".equals(namespaceURI) &&
+ "AvatarWrapper".equals(typeName)){
+
+ return AvatarWrapper.Factory.parse(reader);
+
+
+ }
+
+
+ if (
+ "http://www.vitero.de/schema/mtom".equals(namespaceURI) &&
+ "FileWrapper".equals(typeName)){
+
+ return FileWrapper.Factory.parse(reader);
+
+
+ }
+
+
+ throw new org.apache.axis2.databinding.ADBException("Unsupported type " + namespaceURI + " " + typeName);
+ }
+
+ }
+
+ public static class StoreFileResponse
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/mtom",
+ "storeFileResponse",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/mtom")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for StoreFileResponse
+ */
+
+
+ protected IdWrapper localStoreFileResponse ;
+
+
+ /**
+ * Auto generated getter method
+ * @return IdWrapper
+ */
+ public IdWrapper getStoreFileResponse(){
+ return localStoreFileResponse;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param StoreFileResponse
+ */
+ public void setStoreFileResponse(IdWrapper param){
+
+ this.localStoreFileResponse=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ StoreFileResponse.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+ //We can safely assume an element has only one type associated with it
+
+ if (localStoreFileResponse==null){
+ throw new org.apache.axis2.databinding.ADBException("Property cannot be null!");
+ }
+ localStoreFileResponse.serialize(MY_QNAME,factory,xmlWriter);
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+
+ //We can safely assume an element has only one type associated with it
+ return localStoreFileResponse.getPullParser(MY_QNAME);
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static StoreFileResponse parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ StoreFileResponse object =
+ new StoreFileResponse();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/mtom","storeFileResponse").equals(reader.getName())){
+
+ object.setStoreFileResponse(IdWrapper.Factory.parse(reader));
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class FileWrapper
+ implements org.apache.axis2.databinding.ADBBean{
+ /* This type was generated from the piece of schema that had
+ name = FileWrapper
+ Namespace URI = http://www.vitero.de/schema/mtom
+ Namespace Prefix = ns1
+ */
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/mtom")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for Filename
+ */
+
+
+ protected java.lang.String localFilename ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getFilename(){
+ return localFilename;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Filename
+ */
+ public void setFilename(java.lang.String param){
+
+ this.localFilename=param;
+
+
+ }
+
+
+ /**
+ * field for Foldernodeid
+ */
+
+
+ protected long localFoldernodeid ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localFoldernodeidTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return long
+ */
+ public long getFoldernodeid(){
+ return localFoldernodeid;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Foldernodeid
+ */
+ public void setFoldernodeid(long param){
+
+ // setting primitive attribute tracker to true
+
+ if (param==java.lang.Long.MIN_VALUE) {
+ localFoldernodeidTracker = false;
+
+ } else {
+ localFoldernodeidTracker = true;
+ }
+
+ this.localFoldernodeid=param;
+
+
+ }
+
+
+ /**
+ * field for File
+ */
+
+
+ protected javax.activation.DataHandler localFile ;
+
+
+ /**
+ * Auto generated getter method
+ * @return javax.activation.DataHandler
+ */
+ public javax.activation.DataHandler getFile(){
+ return localFile;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param File
+ */
+ public void setFile(javax.activation.DataHandler param){
+
+ this.localFile=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,parentQName){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ FileWrapper.this.serialize(parentQName,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ parentQName,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/mtom");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":FileWrapper",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "FileWrapper",
+ xmlWriter);
+ }
+
+
+ }
+
+ namespace = "http://www.vitero.de/schema/mtom";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"filename", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"filename");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("filename");
+ }
+
+
+ if (localFilename==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("filename cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localFilename);
+
+ }
+
+ xmlWriter.writeEndElement();
+ if (localFoldernodeidTracker){
+ namespace = "http://www.vitero.de/schema/mtom";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"foldernodeid", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"foldernodeid");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("foldernodeid");
+ }
+
+ if (localFoldernodeid==java.lang.Long.MIN_VALUE) {
+
+ throw new org.apache.axis2.databinding.ADBException("foldernodeid cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localFoldernodeid));
+ }
+
+ xmlWriter.writeEndElement();
+ }
+ namespace = "http://www.vitero.de/schema/mtom";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"file", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"file");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("file");
+ }
+
+
+ if (localFile!=null)
+ {
+ xmlWriter.writeDataHandler(localFile);
+ }
+
+ xmlWriter.writeEndElement();
+
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/mtom",
+ "filename"));
+
+ if (localFilename != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localFilename));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("filename cannot be null!!");
+ }
+ if (localFoldernodeidTracker){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/mtom",
+ "foldernodeid"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localFoldernodeid));
+ }
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/mtom",
+ "file"));
+
+ elementList.add(localFile);
+
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static FileWrapper parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ FileWrapper object =
+ new FileWrapper();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"FileWrapper".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (FileWrapper)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/mtom","filename").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setFilename(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/mtom","foldernodeid").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setFoldernodeid(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToLong(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/mtom","file").equals(reader.getName())){
+ reader.next();
+ if (isReaderMTOMAware(reader)
+ &&
+ java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_BINARY)))
+ {
+ //MTOM aware reader - get the datahandler directly and put it in the object
+ object.setFile(
+ (javax.activation.DataHandler) reader.getProperty(org.apache.axiom.om.OMConstants.DATA_HANDLER));
+ } else {
+ if (reader.getEventType() == javax.xml.stream.XMLStreamConstants.START_ELEMENT && reader.getName().equals(new javax.xml.namespace.QName(org.apache.axiom.om.impl.MTOMConstants.XOP_NAMESPACE_URI, org.apache.axiom.om.impl.MTOMConstants.XOP_INCLUDE)))
+ {
+ java.lang.String id = org.apache.axiom.om.util.ElementHelper.getContentID(reader, "UTF-8");
+ object.setFile(((org.apache.axiom.soap.impl.builder.MTOMStAXSOAPModelBuilder) ((org.apache.axiom.om.impl.llom.OMStAXWrapper) reader).getBuilder()).getDataHandler(id));
+ reader.next();
+
+ reader.next();
+
+ } else if(reader.hasText()) {
+ //Do the usual conversion
+ java.lang.String content = reader.getText();
+ object.setFile(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToBase64Binary(content));
+
+ reader.next();
+
+ }
+ }
+
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.MtomServiceStub.LoadFileRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.MtomServiceStub.LoadFileRequest.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.MtomServiceStub.LoadFileResponse param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.MtomServiceStub.LoadFileResponse.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.MtomServiceStub.StoreAvatarRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.MtomServiceStub.StoreAvatarRequest.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.MtomServiceStub.LoadAvatarRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.MtomServiceStub.LoadAvatarRequest.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.MtomServiceStub.LoadAvatarResponse param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.MtomServiceStub.LoadAvatarResponse.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.MtomServiceStub.StoreFileRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.MtomServiceStub.StoreFileRequest.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.MtomServiceStub.StoreFileResponse param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.MtomServiceStub.StoreFileResponse.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.MtomServiceStub.SuccessResponseE param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.MtomServiceStub.SuccessResponseE.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+
+ private org.apache.axiom.soap.SOAPEnvelope toEnvelope(org.apache.axiom.soap.SOAPFactory factory, com.frentix.olat.vitero.manager.stubs.MtomServiceStub.LoadFileRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault{
+
+
+ try{
+
+ org.apache.axiom.soap.SOAPEnvelope emptyEnvelope = factory.getDefaultEnvelope();
+ emptyEnvelope.getBody().addChild(param.getOMElement(com.frentix.olat.vitero.manager.stubs.MtomServiceStub.LoadFileRequest.MY_QNAME,factory));
+ return emptyEnvelope;
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+
+ /* methods to provide back word compatibility */
+
+
+
+ private org.apache.axiom.soap.SOAPEnvelope toEnvelope(org.apache.axiom.soap.SOAPFactory factory, com.frentix.olat.vitero.manager.stubs.MtomServiceStub.StoreAvatarRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault{
+
+
+ try{
+
+ org.apache.axiom.soap.SOAPEnvelope emptyEnvelope = factory.getDefaultEnvelope();
+ emptyEnvelope.getBody().addChild(param.getOMElement(com.frentix.olat.vitero.manager.stubs.MtomServiceStub.StoreAvatarRequest.MY_QNAME,factory));
+ return emptyEnvelope;
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+
+ /* methods to provide back word compatibility */
+
+
+
+ private org.apache.axiom.soap.SOAPEnvelope toEnvelope(org.apache.axiom.soap.SOAPFactory factory, com.frentix.olat.vitero.manager.stubs.MtomServiceStub.LoadAvatarRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault{
+
+
+ try{
+
+ org.apache.axiom.soap.SOAPEnvelope emptyEnvelope = factory.getDefaultEnvelope();
+ emptyEnvelope.getBody().addChild(param.getOMElement(com.frentix.olat.vitero.manager.stubs.MtomServiceStub.LoadAvatarRequest.MY_QNAME,factory));
+ return emptyEnvelope;
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+
+ /* methods to provide back word compatibility */
+
+
+
+ private org.apache.axiom.soap.SOAPEnvelope toEnvelope(org.apache.axiom.soap.SOAPFactory factory, com.frentix.olat.vitero.manager.stubs.MtomServiceStub.StoreFileRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault{
+
+
+ try{
+
+ org.apache.axiom.soap.SOAPEnvelope emptyEnvelope = factory.getDefaultEnvelope();
+ emptyEnvelope.getBody().addChild(param.getOMElement(com.frentix.olat.vitero.manager.stubs.MtomServiceStub.StoreFileRequest.MY_QNAME,factory));
+ return emptyEnvelope;
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+
+ /* methods to provide back word compatibility */
+
+
+
+
+ /**
+ * get the default envelope
+ */
+ private org.apache.axiom.soap.SOAPEnvelope toEnvelope(org.apache.axiom.soap.SOAPFactory factory){
+ return factory.getDefaultEnvelope();
+ }
+
+
+ private java.lang.Object fromOM(
+ org.apache.axiom.om.OMElement param,
+ java.lang.Class type,
+ java.util.Map extraNamespaces) throws org.apache.axis2.AxisFault{
+
+ try {
+
+ if (com.frentix.olat.vitero.manager.stubs.MtomServiceStub.LoadFileRequest.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.MtomServiceStub.LoadFileRequest.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ if (com.frentix.olat.vitero.manager.stubs.MtomServiceStub.LoadFileResponse.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.MtomServiceStub.LoadFileResponse.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ if (com.frentix.olat.vitero.manager.stubs.MtomServiceStub.StoreAvatarRequest.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.MtomServiceStub.StoreAvatarRequest.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ if (com.frentix.olat.vitero.manager.stubs.MtomServiceStub.LoadAvatarRequest.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.MtomServiceStub.LoadAvatarRequest.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ if (com.frentix.olat.vitero.manager.stubs.MtomServiceStub.LoadAvatarResponse.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.MtomServiceStub.LoadAvatarResponse.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ if (com.frentix.olat.vitero.manager.stubs.MtomServiceStub.StoreFileRequest.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.MtomServiceStub.StoreFileRequest.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ if (com.frentix.olat.vitero.manager.stubs.MtomServiceStub.StoreFileResponse.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.MtomServiceStub.StoreFileResponse.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ if (com.frentix.olat.vitero.manager.stubs.MtomServiceStub.SuccessResponseE.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.MtomServiceStub.SuccessResponseE.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ } catch (java.lang.Exception e) {
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+ return null;
+ }
+
+
+
+
+ }
+
\ No newline at end of file
diff --git a/src/main/java/com/frentix/olat/vitero/manager/stubs/SessionCodeServiceCallbackHandler.java b/src/main/java/com/frentix/olat/vitero/manager/stubs/SessionCodeServiceCallbackHandler.java
new file mode 100644
index 0000000000000000000000000000000000000000..aeaa69410b852306eeb2c523810eba0fe1a27f14
--- /dev/null
+++ b/src/main/java/com/frentix/olat/vitero/manager/stubs/SessionCodeServiceCallbackHandler.java
@@ -0,0 +1,134 @@
+
+/**
+ * SessionCodeServiceCallbackHandler.java
+ *
+ * This file was auto-generated from WSDL
+ * by the Apache Axis2 version: 1.4.1 Built on : Aug 13, 2008 (05:03:35 LKT)
+ */
+
+ package com.frentix.olat.vitero.manager.stubs;
+
+ /**
+ * SessionCodeServiceCallbackHandler Callback class, Users can extend this class and implement
+ * their own receiveResult and receiveError methods.
+ */
+ public abstract class SessionCodeServiceCallbackHandler{
+
+
+
+ protected Object clientData;
+
+ /**
+ * User can pass in any object that needs to be accessed once the NonBlocking
+ * Web service call is finished and appropriate method of this CallBack is called.
+ * @param clientData Object mechanism by which the user can pass in user data
+ * that will be avilable at the time this callback is called.
+ */
+ public SessionCodeServiceCallbackHandler(Object clientData){
+ this.clientData = clientData;
+ }
+
+ /**
+ * Please use this constructor if you don't want to set any clientData
+ */
+ public SessionCodeServiceCallbackHandler(){
+ this.clientData = null;
+ }
+
+ /**
+ * Get the client data
+ */
+
+ public Object getClientData() {
+ return clientData;
+ }
+
+
+ /**
+ * auto generated Axis2 call back method for createPersonalGroupSessionCode method
+ * override this method for handling normal response from createPersonalGroupSessionCode operation
+ */
+ public void receiveResultcreatePersonalGroupSessionCode(
+ com.frentix.olat.vitero.manager.stubs.SessionCodeServiceStub.CreatePersonalGroupSessionCodeResponse result
+ ) {
+ }
+
+ /**
+ * auto generated Axis2 Error handler
+ * override this method for handling error response from createPersonalGroupSessionCode operation
+ */
+ public void receiveErrorcreatePersonalGroupSessionCode(java.lang.Exception e) {
+ }
+
+ /**
+ * auto generated Axis2 call back method for getSessionCodeInformation method
+ * override this method for handling normal response from getSessionCodeInformation operation
+ */
+ public void receiveResultgetSessionCodeInformation(
+ com.frentix.olat.vitero.manager.stubs.SessionCodeServiceStub.GetSessionCodeInformationResponse result
+ ) {
+ }
+
+ /**
+ * auto generated Axis2 Error handler
+ * override this method for handling error response from getSessionCodeInformation operation
+ */
+ public void receiveErrorgetSessionCodeInformation(java.lang.Exception e) {
+ }
+
+ // No methods generated for meps other than in-out
+
+ /**
+ * auto generated Axis2 call back method for getPersonalGroupSessionCodes method
+ * override this method for handling normal response from getPersonalGroupSessionCodes operation
+ */
+ public void receiveResultgetPersonalGroupSessionCodes(
+ com.frentix.olat.vitero.manager.stubs.SessionCodeServiceStub.GetPersonalGroupSessionCodesResponse result
+ ) {
+ }
+
+ /**
+ * auto generated Axis2 Error handler
+ * override this method for handling error response from getPersonalGroupSessionCodes operation
+ */
+ public void receiveErrorgetPersonalGroupSessionCodes(java.lang.Exception e) {
+ }
+
+ /**
+ * auto generated Axis2 call back method for createPersonalBookingSessionCode method
+ * override this method for handling normal response from createPersonalBookingSessionCode operation
+ */
+ public void receiveResultcreatePersonalBookingSessionCode(
+ com.frentix.olat.vitero.manager.stubs.SessionCodeServiceStub.CreatePersonalBookingSessionCodeResponse result
+ ) {
+ }
+
+ /**
+ * auto generated Axis2 Error handler
+ * override this method for handling error response from createPersonalBookingSessionCode operation
+ */
+ public void receiveErrorcreatePersonalBookingSessionCode(java.lang.Exception e) {
+ }
+
+ /**
+ * auto generated Axis2 call back method for getPersonalBookingSessionCodes method
+ * override this method for handling normal response from getPersonalBookingSessionCodes operation
+ */
+ public void receiveResultgetPersonalBookingSessionCodes(
+ com.frentix.olat.vitero.manager.stubs.SessionCodeServiceStub.GetPersonalBookingSessionCodesResponse result
+ ) {
+ }
+
+ /**
+ * auto generated Axis2 Error handler
+ * override this method for handling error response from getPersonalBookingSessionCodes operation
+ */
+ public void receiveErrorgetPersonalBookingSessionCodes(java.lang.Exception e) {
+ }
+
+ // No methods generated for meps other than in-out
+
+
+
+ }
+
\ No newline at end of file
diff --git a/src/main/java/com/frentix/olat/vitero/manager/stubs/SessionCodeServiceStub.java b/src/main/java/com/frentix/olat/vitero/manager/stubs/SessionCodeServiceStub.java
new file mode 100644
index 0000000000000000000000000000000000000000..e3f5f1b7fd9f84765b59fcd2e2d9dc07fca1ef73
--- /dev/null
+++ b/src/main/java/com/frentix/olat/vitero/manager/stubs/SessionCodeServiceStub.java
@@ -0,0 +1,11784 @@
+
+/**
+ * SessionCodeServiceStub.java
+ *
+ * This file was auto-generated from WSDL
+ * by the Apache Axis2 version: 1.4.1 Built on : Aug 13, 2008 (05:03:35 LKT)
+ */
+ package com.frentix.olat.vitero.manager.stubs;
+
+
+
+ /*
+ * SessionCodeServiceStub java implementation
+ */
+
+
+ public class SessionCodeServiceStub extends org.apache.axis2.client.Stub
+ {
+ protected org.apache.axis2.description.AxisOperation[] _operations;
+
+ //hashmaps to keep the fault mapping
+ private java.util.HashMap faultExceptionNameMap = new java.util.HashMap();
+ private java.util.HashMap faultExceptionClassNameMap = new java.util.HashMap();
+ private java.util.HashMap faultMessageMap = new java.util.HashMap();
+
+ private static int counter = 0;
+
+ private static synchronized String getUniqueSuffix(){
+ // reset the counter if it is greater than 99999
+ if (counter > 99999){
+ counter = 0;
+ }
+ counter = counter + 1;
+ return Long.toString(System.currentTimeMillis()) + "_" + counter;
+ }
+
+
+ private void populateAxisService() throws org.apache.axis2.AxisFault {
+
+ //creating the Service with a unique name
+ _service = new org.apache.axis2.description.AxisService("SessionCodeService" + getUniqueSuffix());
+ addAnonymousOperations();
+
+ //creating the operations
+ org.apache.axis2.description.AxisOperation __operation;
+
+ _operations = new org.apache.axis2.description.AxisOperation[7];
+
+ __operation = new org.apache.axis2.description.OutInAxisOperation();
+
+
+ __operation.setName(new javax.xml.namespace.QName("http://www.vitero.de/schema/sessioncode", "createPersonalGroupSessionCode"));
+ _service.addOperation(__operation);
+
+
+
+
+ _operations[0]=__operation;
+
+
+ __operation = new org.apache.axis2.description.OutInAxisOperation();
+
+
+ __operation.setName(new javax.xml.namespace.QName("http://www.vitero.de/schema/sessioncode", "getSessionCodeInformation"));
+ _service.addOperation(__operation);
+
+
+
+
+ _operations[1]=__operation;
+
+
+ __operation = new org.apache.axis2.description.OutInAxisOperation();
+
+
+ __operation.setName(new javax.xml.namespace.QName("http://www.vitero.de/schema/sessioncode", "success"));
+ _service.addOperation(__operation);
+
+
+
+
+ _operations[2]=__operation;
+
+
+ __operation = new org.apache.axis2.description.OutInAxisOperation();
+
+
+ __operation.setName(new javax.xml.namespace.QName("http://www.vitero.de/schema/sessioncode", "getPersonalGroupSessionCodes"));
+ _service.addOperation(__operation);
+
+
+
+
+ _operations[3]=__operation;
+
+
+ __operation = new org.apache.axis2.description.OutInAxisOperation();
+
+
+ __operation.setName(new javax.xml.namespace.QName("http://www.vitero.de/schema/sessioncode", "createPersonalBookingSessionCode"));
+ _service.addOperation(__operation);
+
+
+
+
+ _operations[4]=__operation;
+
+
+ __operation = new org.apache.axis2.description.OutInAxisOperation();
+
+
+ __operation.setName(new javax.xml.namespace.QName("http://www.vitero.de/schema/sessioncode", "getPersonalBookingSessionCodes"));
+ _service.addOperation(__operation);
+
+
+
+
+ _operations[5]=__operation;
+
+
+ __operation = new org.apache.axis2.description.OutOnlyAxisOperation();
+
+
+ __operation.setName(new javax.xml.namespace.QName("http://www.vitero.de/schema/sessioncode", "deleteSessionCode"));
+ _service.addOperation(__operation);
+
+
+
+
+ _operations[6]=__operation;
+
+
+ }
+
+ //populates the faults
+ private void populateFaults(){
+
+
+
+ }
+
+ /**
+ *Constructor that takes in a configContext
+ */
+
+ public SessionCodeServiceStub(org.apache.axis2.context.ConfigurationContext configurationContext,
+ java.lang.String targetEndpoint)
+ throws org.apache.axis2.AxisFault {
+ this(configurationContext,targetEndpoint,false);
+ }
+
+
+ /**
+ * Constructor that takes in a configContext and useseperate listner
+ */
+ public SessionCodeServiceStub(org.apache.axis2.context.ConfigurationContext configurationContext,
+ java.lang.String targetEndpoint, boolean useSeparateListener)
+ throws org.apache.axis2.AxisFault {
+ //To populate AxisService
+ populateAxisService();
+ populateFaults();
+
+ _serviceClient = new org.apache.axis2.client.ServiceClient(configurationContext,_service);
+
+
+ configurationContext = _serviceClient.getServiceContext().getConfigurationContext();
+
+ _serviceClient.getOptions().setTo(new org.apache.axis2.addressing.EndpointReference(
+ targetEndpoint));
+ _serviceClient.getOptions().setUseSeparateListener(useSeparateListener);
+
+
+ }
+
+ /**
+ * Default Constructor
+ */
+ public SessionCodeServiceStub(org.apache.axis2.context.ConfigurationContext configurationContext) throws org.apache.axis2.AxisFault {
+
+ this(configurationContext,"http://192.168.1.54:8080/vitero/services/" );
+
+ }
+
+ /**
+ * Default Constructor
+ */
+ public SessionCodeServiceStub() throws org.apache.axis2.AxisFault {
+
+ this("http://192.168.1.54:8080/vitero/services/" );
+
+ }
+
+ /**
+ * Constructor taking the target endpoint
+ */
+ public SessionCodeServiceStub(java.lang.String targetEndpoint) throws org.apache.axis2.AxisFault {
+ this(null,targetEndpoint);
+ }
+
+
+
+
+ /**
+ * Auto generated method signature
+ *
+ * @see com.frentix.olat.vitero.manager.stubs.SessionCodeService#createPersonalGroupSessionCode
+ * @param createPersonalGroupSessionCodeRequest0
+
+ */
+
+
+
+ public com.frentix.olat.vitero.manager.stubs.SessionCodeServiceStub.CreatePersonalGroupSessionCodeResponse createPersonalGroupSessionCode(
+
+ com.frentix.olat.vitero.manager.stubs.SessionCodeServiceStub.CreatePersonalGroupSessionCodeRequest createPersonalGroupSessionCodeRequest0)
+
+
+ throws java.rmi.RemoteException
+
+ {
+ org.apache.axis2.context.MessageContext _messageContext = null;
+ try{
+ org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[0].getName());
+ _operationClient.getOptions().setAction("\"\"");
+ _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true);
+
+
+
+ addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&");
+
+
+ // create a message context
+ _messageContext = new org.apache.axis2.context.MessageContext();
+
+
+
+ // create SOAP envelope with that payload
+ org.apache.axiom.soap.SOAPEnvelope env = null;
+
+
+ env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()),
+ createPersonalGroupSessionCodeRequest0,
+ optimizeContent(new javax.xml.namespace.QName("http://www.vitero.de/schema/sessioncode",
+ "createPersonalGroupSessionCode")));
+
+ //adding SOAP soap_headers
+ _serviceClient.addHeadersToEnvelope(env);
+ // set the message context with that soap envelope
+ _messageContext.setEnvelope(env);
+
+ // add the message contxt to the operation client
+ _operationClient.addMessageContext(_messageContext);
+
+ //execute the operation client
+ _operationClient.execute(true);
+
+
+ org.apache.axis2.context.MessageContext _returnMessageContext = _operationClient.getMessageContext(
+ org.apache.axis2.wsdl.WSDLConstants.MESSAGE_LABEL_IN_VALUE);
+ org.apache.axiom.soap.SOAPEnvelope _returnEnv = _returnMessageContext.getEnvelope();
+
+
+ java.lang.Object object = fromOM(
+ _returnEnv.getBody().getFirstElement() ,
+ com.frentix.olat.vitero.manager.stubs.SessionCodeServiceStub.CreatePersonalGroupSessionCodeResponse.class,
+ getEnvelopeNamespaces(_returnEnv));
+
+
+ return (com.frentix.olat.vitero.manager.stubs.SessionCodeServiceStub.CreatePersonalGroupSessionCodeResponse)object;
+
+ }catch(org.apache.axis2.AxisFault f){
+
+ org.apache.axiom.om.OMElement faultElt = f.getDetail();
+ if (faultElt!=null){
+ if (faultExceptionNameMap.containsKey(faultElt.getQName())){
+ //make the fault by reflection
+ try{
+ java.lang.String exceptionClassName = (java.lang.String)faultExceptionClassNameMap.get(faultElt.getQName());
+ java.lang.Class exceptionClass = java.lang.Class.forName(exceptionClassName);
+ java.lang.Exception ex=
+ (java.lang.Exception) exceptionClass.newInstance();
+ //message class
+ java.lang.String messageClassName = (java.lang.String)faultMessageMap.get(faultElt.getQName());
+ java.lang.Class messageClass = java.lang.Class.forName(messageClassName);
+ java.lang.Object messageObject = fromOM(faultElt,messageClass,null);
+ java.lang.reflect.Method m = exceptionClass.getMethod("setFaultMessage",
+ new java.lang.Class[]{messageClass});
+ m.invoke(ex,new java.lang.Object[]{messageObject});
+
+
+ throw new java.rmi.RemoteException(ex.getMessage(), ex);
+ }catch(java.lang.ClassCastException e){
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.ClassNotFoundException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ }catch (java.lang.NoSuchMethodException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.reflect.InvocationTargetException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.IllegalAccessException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.InstantiationException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ }
+ }else{
+ throw f;
+ }
+ }else{
+ throw f;
+ }
+ } finally {
+ _messageContext.getTransportOut().getSender().cleanup(_messageContext);
+ }
+ }
+
+ /**
+ * Auto generated method signature for Asynchronous Invocations
+ *
+ * @see com.frentix.olat.vitero.manager.stubs.SessionCodeService#startcreatePersonalGroupSessionCode
+ * @param createPersonalGroupSessionCodeRequest0
+
+ */
+ public void startcreatePersonalGroupSessionCode(
+
+ com.frentix.olat.vitero.manager.stubs.SessionCodeServiceStub.CreatePersonalGroupSessionCodeRequest createPersonalGroupSessionCodeRequest0,
+
+ final com.frentix.olat.vitero.manager.stubs.SessionCodeServiceCallbackHandler callback)
+
+ throws java.rmi.RemoteException{
+
+ org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[0].getName());
+ _operationClient.getOptions().setAction("\"\"");
+ _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true);
+
+
+
+ addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&");
+
+
+
+ // create SOAP envelope with that payload
+ org.apache.axiom.soap.SOAPEnvelope env=null;
+ final org.apache.axis2.context.MessageContext _messageContext = new org.apache.axis2.context.MessageContext();
+
+
+ //Style is Doc.
+
+
+ env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()),
+ createPersonalGroupSessionCodeRequest0,
+ optimizeContent(new javax.xml.namespace.QName("http://www.vitero.de/schema/sessioncode",
+ "createPersonalGroupSessionCode")));
+
+ // adding SOAP soap_headers
+ _serviceClient.addHeadersToEnvelope(env);
+ // create message context with that soap envelope
+ _messageContext.setEnvelope(env);
+
+ // add the message context to the operation client
+ _operationClient.addMessageContext(_messageContext);
+
+
+
+ _operationClient.setCallback(new org.apache.axis2.client.async.AxisCallback() {
+ public void onMessage(org.apache.axis2.context.MessageContext resultContext) {
+ try {
+ org.apache.axiom.soap.SOAPEnvelope resultEnv = resultContext.getEnvelope();
+
+ java.lang.Object object = fromOM(resultEnv.getBody().getFirstElement(),
+ com.frentix.olat.vitero.manager.stubs.SessionCodeServiceStub.CreatePersonalGroupSessionCodeResponse.class,
+ getEnvelopeNamespaces(resultEnv));
+ callback.receiveResultcreatePersonalGroupSessionCode(
+ (com.frentix.olat.vitero.manager.stubs.SessionCodeServiceStub.CreatePersonalGroupSessionCodeResponse)object);
+
+ } catch (org.apache.axis2.AxisFault e) {
+ callback.receiveErrorcreatePersonalGroupSessionCode(e);
+ }
+ }
+
+ public void onError(java.lang.Exception error) {
+ if (error instanceof org.apache.axis2.AxisFault) {
+ org.apache.axis2.AxisFault f = (org.apache.axis2.AxisFault) error;
+ org.apache.axiom.om.OMElement faultElt = f.getDetail();
+ if (faultElt!=null){
+ if (faultExceptionNameMap.containsKey(faultElt.getQName())){
+ //make the fault by reflection
+ try{
+ java.lang.String exceptionClassName = (java.lang.String)faultExceptionClassNameMap.get(faultElt.getQName());
+ java.lang.Class exceptionClass = java.lang.Class.forName(exceptionClassName);
+ java.lang.Exception ex=
+ (java.lang.Exception) exceptionClass.newInstance();
+ //message class
+ java.lang.String messageClassName = (java.lang.String)faultMessageMap.get(faultElt.getQName());
+ java.lang.Class messageClass = java.lang.Class.forName(messageClassName);
+ java.lang.Object messageObject = fromOM(faultElt,messageClass,null);
+ java.lang.reflect.Method m = exceptionClass.getMethod("setFaultMessage",
+ new java.lang.Class[]{messageClass});
+ m.invoke(ex,new java.lang.Object[]{messageObject});
+
+
+ callback.receiveErrorcreatePersonalGroupSessionCode(new java.rmi.RemoteException(ex.getMessage(), ex));
+ } catch(java.lang.ClassCastException e){
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorcreatePersonalGroupSessionCode(f);
+ } catch (java.lang.ClassNotFoundException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorcreatePersonalGroupSessionCode(f);
+ } catch (java.lang.NoSuchMethodException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorcreatePersonalGroupSessionCode(f);
+ } catch (java.lang.reflect.InvocationTargetException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorcreatePersonalGroupSessionCode(f);
+ } catch (java.lang.IllegalAccessException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorcreatePersonalGroupSessionCode(f);
+ } catch (java.lang.InstantiationException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorcreatePersonalGroupSessionCode(f);
+ } catch (org.apache.axis2.AxisFault e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorcreatePersonalGroupSessionCode(f);
+ }
+ } else {
+ callback.receiveErrorcreatePersonalGroupSessionCode(f);
+ }
+ } else {
+ callback.receiveErrorcreatePersonalGroupSessionCode(f);
+ }
+ } else {
+ callback.receiveErrorcreatePersonalGroupSessionCode(error);
+ }
+ }
+
+ public void onFault(org.apache.axis2.context.MessageContext faultContext) {
+ org.apache.axis2.AxisFault fault = org.apache.axis2.util.Utils.getInboundFaultFromMessageContext(faultContext);
+ onError(fault);
+ }
+
+ public void onComplete() {
+ try {
+ _messageContext.getTransportOut().getSender().cleanup(_messageContext);
+ } catch (org.apache.axis2.AxisFault axisFault) {
+ callback.receiveErrorcreatePersonalGroupSessionCode(axisFault);
+ }
+ }
+ });
+
+
+ org.apache.axis2.util.CallbackReceiver _callbackReceiver = null;
+ if ( _operations[0].getMessageReceiver()==null && _operationClient.getOptions().isUseSeparateListener()) {
+ _callbackReceiver = new org.apache.axis2.util.CallbackReceiver();
+ _operations[0].setMessageReceiver(
+ _callbackReceiver);
+ }
+
+ //execute the operation client
+ _operationClient.execute(false);
+
+ }
+
+ /**
+ * Auto generated method signature
+ *
+ * @see com.frentix.olat.vitero.manager.stubs.SessionCodeService#getSessionCodeInformation
+ * @param getSessionCodeInformationRequest2
+
+ */
+
+
+
+ public com.frentix.olat.vitero.manager.stubs.SessionCodeServiceStub.GetSessionCodeInformationResponse getSessionCodeInformation(
+
+ com.frentix.olat.vitero.manager.stubs.SessionCodeServiceStub.GetSessionCodeInformationRequest getSessionCodeInformationRequest2)
+
+
+ throws java.rmi.RemoteException
+
+ {
+ org.apache.axis2.context.MessageContext _messageContext = null;
+ try{
+ org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[1].getName());
+ _operationClient.getOptions().setAction("\"\"");
+ _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true);
+
+
+
+ addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&");
+
+
+ // create a message context
+ _messageContext = new org.apache.axis2.context.MessageContext();
+
+
+
+ // create SOAP envelope with that payload
+ org.apache.axiom.soap.SOAPEnvelope env = null;
+
+
+ env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()),
+ getSessionCodeInformationRequest2,
+ optimizeContent(new javax.xml.namespace.QName("http://www.vitero.de/schema/sessioncode",
+ "getSessionCodeInformation")));
+
+ //adding SOAP soap_headers
+ _serviceClient.addHeadersToEnvelope(env);
+ // set the message context with that soap envelope
+ _messageContext.setEnvelope(env);
+
+ // add the message contxt to the operation client
+ _operationClient.addMessageContext(_messageContext);
+
+ //execute the operation client
+ _operationClient.execute(true);
+
+
+ org.apache.axis2.context.MessageContext _returnMessageContext = _operationClient.getMessageContext(
+ org.apache.axis2.wsdl.WSDLConstants.MESSAGE_LABEL_IN_VALUE);
+ org.apache.axiom.soap.SOAPEnvelope _returnEnv = _returnMessageContext.getEnvelope();
+
+
+ java.lang.Object object = fromOM(
+ _returnEnv.getBody().getFirstElement() ,
+ com.frentix.olat.vitero.manager.stubs.SessionCodeServiceStub.GetSessionCodeInformationResponse.class,
+ getEnvelopeNamespaces(_returnEnv));
+
+
+ return (com.frentix.olat.vitero.manager.stubs.SessionCodeServiceStub.GetSessionCodeInformationResponse)object;
+
+ }catch(org.apache.axis2.AxisFault f){
+
+ org.apache.axiom.om.OMElement faultElt = f.getDetail();
+ if (faultElt!=null){
+ if (faultExceptionNameMap.containsKey(faultElt.getQName())){
+ //make the fault by reflection
+ try{
+ java.lang.String exceptionClassName = (java.lang.String)faultExceptionClassNameMap.get(faultElt.getQName());
+ java.lang.Class exceptionClass = java.lang.Class.forName(exceptionClassName);
+ java.lang.Exception ex=
+ (java.lang.Exception) exceptionClass.newInstance();
+ //message class
+ java.lang.String messageClassName = (java.lang.String)faultMessageMap.get(faultElt.getQName());
+ java.lang.Class messageClass = java.lang.Class.forName(messageClassName);
+ java.lang.Object messageObject = fromOM(faultElt,messageClass,null);
+ java.lang.reflect.Method m = exceptionClass.getMethod("setFaultMessage",
+ new java.lang.Class[]{messageClass});
+ m.invoke(ex,new java.lang.Object[]{messageObject});
+
+
+ throw new java.rmi.RemoteException(ex.getMessage(), ex);
+ }catch(java.lang.ClassCastException e){
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.ClassNotFoundException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ }catch (java.lang.NoSuchMethodException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.reflect.InvocationTargetException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.IllegalAccessException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.InstantiationException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ }
+ }else{
+ throw f;
+ }
+ }else{
+ throw f;
+ }
+ } finally {
+ _messageContext.getTransportOut().getSender().cleanup(_messageContext);
+ }
+ }
+
+ /**
+ * Auto generated method signature for Asynchronous Invocations
+ *
+ * @see com.frentix.olat.vitero.manager.stubs.SessionCodeService#startgetSessionCodeInformation
+ * @param getSessionCodeInformationRequest2
+
+ */
+ public void startgetSessionCodeInformation(
+
+ com.frentix.olat.vitero.manager.stubs.SessionCodeServiceStub.GetSessionCodeInformationRequest getSessionCodeInformationRequest2,
+
+ final com.frentix.olat.vitero.manager.stubs.SessionCodeServiceCallbackHandler callback)
+
+ throws java.rmi.RemoteException{
+
+ org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[1].getName());
+ _operationClient.getOptions().setAction("\"\"");
+ _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true);
+
+
+
+ addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&");
+
+
+
+ // create SOAP envelope with that payload
+ org.apache.axiom.soap.SOAPEnvelope env=null;
+ final org.apache.axis2.context.MessageContext _messageContext = new org.apache.axis2.context.MessageContext();
+
+
+ //Style is Doc.
+
+
+ env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()),
+ getSessionCodeInformationRequest2,
+ optimizeContent(new javax.xml.namespace.QName("http://www.vitero.de/schema/sessioncode",
+ "getSessionCodeInformation")));
+
+ // adding SOAP soap_headers
+ _serviceClient.addHeadersToEnvelope(env);
+ // create message context with that soap envelope
+ _messageContext.setEnvelope(env);
+
+ // add the message context to the operation client
+ _operationClient.addMessageContext(_messageContext);
+
+
+
+ _operationClient.setCallback(new org.apache.axis2.client.async.AxisCallback() {
+ public void onMessage(org.apache.axis2.context.MessageContext resultContext) {
+ try {
+ org.apache.axiom.soap.SOAPEnvelope resultEnv = resultContext.getEnvelope();
+
+ java.lang.Object object = fromOM(resultEnv.getBody().getFirstElement(),
+ com.frentix.olat.vitero.manager.stubs.SessionCodeServiceStub.GetSessionCodeInformationResponse.class,
+ getEnvelopeNamespaces(resultEnv));
+ callback.receiveResultgetSessionCodeInformation(
+ (com.frentix.olat.vitero.manager.stubs.SessionCodeServiceStub.GetSessionCodeInformationResponse)object);
+
+ } catch (org.apache.axis2.AxisFault e) {
+ callback.receiveErrorgetSessionCodeInformation(e);
+ }
+ }
+
+ public void onError(java.lang.Exception error) {
+ if (error instanceof org.apache.axis2.AxisFault) {
+ org.apache.axis2.AxisFault f = (org.apache.axis2.AxisFault) error;
+ org.apache.axiom.om.OMElement faultElt = f.getDetail();
+ if (faultElt!=null){
+ if (faultExceptionNameMap.containsKey(faultElt.getQName())){
+ //make the fault by reflection
+ try{
+ java.lang.String exceptionClassName = (java.lang.String)faultExceptionClassNameMap.get(faultElt.getQName());
+ java.lang.Class exceptionClass = java.lang.Class.forName(exceptionClassName);
+ java.lang.Exception ex=
+ (java.lang.Exception) exceptionClass.newInstance();
+ //message class
+ java.lang.String messageClassName = (java.lang.String)faultMessageMap.get(faultElt.getQName());
+ java.lang.Class messageClass = java.lang.Class.forName(messageClassName);
+ java.lang.Object messageObject = fromOM(faultElt,messageClass,null);
+ java.lang.reflect.Method m = exceptionClass.getMethod("setFaultMessage",
+ new java.lang.Class[]{messageClass});
+ m.invoke(ex,new java.lang.Object[]{messageObject});
+
+
+ callback.receiveErrorgetSessionCodeInformation(new java.rmi.RemoteException(ex.getMessage(), ex));
+ } catch(java.lang.ClassCastException e){
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetSessionCodeInformation(f);
+ } catch (java.lang.ClassNotFoundException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetSessionCodeInformation(f);
+ } catch (java.lang.NoSuchMethodException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetSessionCodeInformation(f);
+ } catch (java.lang.reflect.InvocationTargetException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetSessionCodeInformation(f);
+ } catch (java.lang.IllegalAccessException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetSessionCodeInformation(f);
+ } catch (java.lang.InstantiationException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetSessionCodeInformation(f);
+ } catch (org.apache.axis2.AxisFault e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetSessionCodeInformation(f);
+ }
+ } else {
+ callback.receiveErrorgetSessionCodeInformation(f);
+ }
+ } else {
+ callback.receiveErrorgetSessionCodeInformation(f);
+ }
+ } else {
+ callback.receiveErrorgetSessionCodeInformation(error);
+ }
+ }
+
+ public void onFault(org.apache.axis2.context.MessageContext faultContext) {
+ org.apache.axis2.AxisFault fault = org.apache.axis2.util.Utils.getInboundFaultFromMessageContext(faultContext);
+ onError(fault);
+ }
+
+ public void onComplete() {
+ try {
+ _messageContext.getTransportOut().getSender().cleanup(_messageContext);
+ } catch (org.apache.axis2.AxisFault axisFault) {
+ callback.receiveErrorgetSessionCodeInformation(axisFault);
+ }
+ }
+ });
+
+
+ org.apache.axis2.util.CallbackReceiver _callbackReceiver = null;
+ if ( _operations[1].getMessageReceiver()==null && _operationClient.getOptions().isUseSeparateListener()) {
+ _callbackReceiver = new org.apache.axis2.util.CallbackReceiver();
+ _operations[1].setMessageReceiver(
+ _callbackReceiver);
+ }
+
+ //execute the operation client
+ _operationClient.execute(false);
+
+ }
+
+ /**
+ * Auto generated method signature
+ *
+ * @see com.frentix.olat.vitero.manager.stubs.SessionCodeService#getPersonalGroupSessionCodes
+ * @param getPersonalGroupSessionCodesRequest5
+
+ */
+
+
+
+ public com.frentix.olat.vitero.manager.stubs.SessionCodeServiceStub.GetPersonalGroupSessionCodesResponse getPersonalGroupSessionCodes(
+
+ com.frentix.olat.vitero.manager.stubs.SessionCodeServiceStub.GetPersonalGroupSessionCodesRequest getPersonalGroupSessionCodesRequest5)
+
+
+ throws java.rmi.RemoteException
+
+ {
+ org.apache.axis2.context.MessageContext _messageContext = null;
+ try{
+ org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[3].getName());
+ _operationClient.getOptions().setAction("\"\"");
+ _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true);
+
+
+
+ addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&");
+
+
+ // create a message context
+ _messageContext = new org.apache.axis2.context.MessageContext();
+
+
+
+ // create SOAP envelope with that payload
+ org.apache.axiom.soap.SOAPEnvelope env = null;
+
+
+ env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()),
+ getPersonalGroupSessionCodesRequest5,
+ optimizeContent(new javax.xml.namespace.QName("http://www.vitero.de/schema/sessioncode",
+ "getPersonalGroupSessionCodes")));
+
+ //adding SOAP soap_headers
+ _serviceClient.addHeadersToEnvelope(env);
+ // set the message context with that soap envelope
+ _messageContext.setEnvelope(env);
+
+ // add the message contxt to the operation client
+ _operationClient.addMessageContext(_messageContext);
+
+ //execute the operation client
+ _operationClient.execute(true);
+
+
+ org.apache.axis2.context.MessageContext _returnMessageContext = _operationClient.getMessageContext(
+ org.apache.axis2.wsdl.WSDLConstants.MESSAGE_LABEL_IN_VALUE);
+ org.apache.axiom.soap.SOAPEnvelope _returnEnv = _returnMessageContext.getEnvelope();
+
+
+ java.lang.Object object = fromOM(
+ _returnEnv.getBody().getFirstElement() ,
+ com.frentix.olat.vitero.manager.stubs.SessionCodeServiceStub.GetPersonalGroupSessionCodesResponse.class,
+ getEnvelopeNamespaces(_returnEnv));
+
+
+ return (com.frentix.olat.vitero.manager.stubs.SessionCodeServiceStub.GetPersonalGroupSessionCodesResponse)object;
+
+ }catch(org.apache.axis2.AxisFault f){
+
+ org.apache.axiom.om.OMElement faultElt = f.getDetail();
+ if (faultElt!=null){
+ if (faultExceptionNameMap.containsKey(faultElt.getQName())){
+ //make the fault by reflection
+ try{
+ java.lang.String exceptionClassName = (java.lang.String)faultExceptionClassNameMap.get(faultElt.getQName());
+ java.lang.Class exceptionClass = java.lang.Class.forName(exceptionClassName);
+ java.lang.Exception ex=
+ (java.lang.Exception) exceptionClass.newInstance();
+ //message class
+ java.lang.String messageClassName = (java.lang.String)faultMessageMap.get(faultElt.getQName());
+ java.lang.Class messageClass = java.lang.Class.forName(messageClassName);
+ java.lang.Object messageObject = fromOM(faultElt,messageClass,null);
+ java.lang.reflect.Method m = exceptionClass.getMethod("setFaultMessage",
+ new java.lang.Class[]{messageClass});
+ m.invoke(ex,new java.lang.Object[]{messageObject});
+
+
+ throw new java.rmi.RemoteException(ex.getMessage(), ex);
+ }catch(java.lang.ClassCastException e){
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.ClassNotFoundException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ }catch (java.lang.NoSuchMethodException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.reflect.InvocationTargetException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.IllegalAccessException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.InstantiationException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ }
+ }else{
+ throw f;
+ }
+ }else{
+ throw f;
+ }
+ } finally {
+ _messageContext.getTransportOut().getSender().cleanup(_messageContext);
+ }
+ }
+
+ /**
+ * Auto generated method signature for Asynchronous Invocations
+ *
+ * @see com.frentix.olat.vitero.manager.stubs.SessionCodeService#startgetPersonalGroupSessionCodes
+ * @param getPersonalGroupSessionCodesRequest5
+
+ */
+ public void startgetPersonalGroupSessionCodes(
+
+ com.frentix.olat.vitero.manager.stubs.SessionCodeServiceStub.GetPersonalGroupSessionCodesRequest getPersonalGroupSessionCodesRequest5,
+
+ final com.frentix.olat.vitero.manager.stubs.SessionCodeServiceCallbackHandler callback)
+
+ throws java.rmi.RemoteException{
+
+ org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[3].getName());
+ _operationClient.getOptions().setAction("\"\"");
+ _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true);
+
+
+
+ addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&");
+
+
+
+ // create SOAP envelope with that payload
+ org.apache.axiom.soap.SOAPEnvelope env=null;
+ final org.apache.axis2.context.MessageContext _messageContext = new org.apache.axis2.context.MessageContext();
+
+
+ //Style is Doc.
+
+
+ env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()),
+ getPersonalGroupSessionCodesRequest5,
+ optimizeContent(new javax.xml.namespace.QName("http://www.vitero.de/schema/sessioncode",
+ "getPersonalGroupSessionCodes")));
+
+ // adding SOAP soap_headers
+ _serviceClient.addHeadersToEnvelope(env);
+ // create message context with that soap envelope
+ _messageContext.setEnvelope(env);
+
+ // add the message context to the operation client
+ _operationClient.addMessageContext(_messageContext);
+
+
+
+ _operationClient.setCallback(new org.apache.axis2.client.async.AxisCallback() {
+ public void onMessage(org.apache.axis2.context.MessageContext resultContext) {
+ try {
+ org.apache.axiom.soap.SOAPEnvelope resultEnv = resultContext.getEnvelope();
+
+ java.lang.Object object = fromOM(resultEnv.getBody().getFirstElement(),
+ com.frentix.olat.vitero.manager.stubs.SessionCodeServiceStub.GetPersonalGroupSessionCodesResponse.class,
+ getEnvelopeNamespaces(resultEnv));
+ callback.receiveResultgetPersonalGroupSessionCodes(
+ (com.frentix.olat.vitero.manager.stubs.SessionCodeServiceStub.GetPersonalGroupSessionCodesResponse)object);
+
+ } catch (org.apache.axis2.AxisFault e) {
+ callback.receiveErrorgetPersonalGroupSessionCodes(e);
+ }
+ }
+
+ public void onError(java.lang.Exception error) {
+ if (error instanceof org.apache.axis2.AxisFault) {
+ org.apache.axis2.AxisFault f = (org.apache.axis2.AxisFault) error;
+ org.apache.axiom.om.OMElement faultElt = f.getDetail();
+ if (faultElt!=null){
+ if (faultExceptionNameMap.containsKey(faultElt.getQName())){
+ //make the fault by reflection
+ try{
+ java.lang.String exceptionClassName = (java.lang.String)faultExceptionClassNameMap.get(faultElt.getQName());
+ java.lang.Class exceptionClass = java.lang.Class.forName(exceptionClassName);
+ java.lang.Exception ex=
+ (java.lang.Exception) exceptionClass.newInstance();
+ //message class
+ java.lang.String messageClassName = (java.lang.String)faultMessageMap.get(faultElt.getQName());
+ java.lang.Class messageClass = java.lang.Class.forName(messageClassName);
+ java.lang.Object messageObject = fromOM(faultElt,messageClass,null);
+ java.lang.reflect.Method m = exceptionClass.getMethod("setFaultMessage",
+ new java.lang.Class[]{messageClass});
+ m.invoke(ex,new java.lang.Object[]{messageObject});
+
+
+ callback.receiveErrorgetPersonalGroupSessionCodes(new java.rmi.RemoteException(ex.getMessage(), ex));
+ } catch(java.lang.ClassCastException e){
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetPersonalGroupSessionCodes(f);
+ } catch (java.lang.ClassNotFoundException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetPersonalGroupSessionCodes(f);
+ } catch (java.lang.NoSuchMethodException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetPersonalGroupSessionCodes(f);
+ } catch (java.lang.reflect.InvocationTargetException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetPersonalGroupSessionCodes(f);
+ } catch (java.lang.IllegalAccessException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetPersonalGroupSessionCodes(f);
+ } catch (java.lang.InstantiationException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetPersonalGroupSessionCodes(f);
+ } catch (org.apache.axis2.AxisFault e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetPersonalGroupSessionCodes(f);
+ }
+ } else {
+ callback.receiveErrorgetPersonalGroupSessionCodes(f);
+ }
+ } else {
+ callback.receiveErrorgetPersonalGroupSessionCodes(f);
+ }
+ } else {
+ callback.receiveErrorgetPersonalGroupSessionCodes(error);
+ }
+ }
+
+ public void onFault(org.apache.axis2.context.MessageContext faultContext) {
+ org.apache.axis2.AxisFault fault = org.apache.axis2.util.Utils.getInboundFaultFromMessageContext(faultContext);
+ onError(fault);
+ }
+
+ public void onComplete() {
+ try {
+ _messageContext.getTransportOut().getSender().cleanup(_messageContext);
+ } catch (org.apache.axis2.AxisFault axisFault) {
+ callback.receiveErrorgetPersonalGroupSessionCodes(axisFault);
+ }
+ }
+ });
+
+
+ org.apache.axis2.util.CallbackReceiver _callbackReceiver = null;
+ if ( _operations[3].getMessageReceiver()==null && _operationClient.getOptions().isUseSeparateListener()) {
+ _callbackReceiver = new org.apache.axis2.util.CallbackReceiver();
+ _operations[3].setMessageReceiver(
+ _callbackReceiver);
+ }
+
+ //execute the operation client
+ _operationClient.execute(false);
+
+ }
+
+ /**
+ * Auto generated method signature
+ *
+ * @see com.frentix.olat.vitero.manager.stubs.SessionCodeService#createPersonalBookingSessionCode
+ * @param createPersonalBookingSessionCodeRequest7
+
+ */
+
+
+
+ public com.frentix.olat.vitero.manager.stubs.SessionCodeServiceStub.CreatePersonalBookingSessionCodeResponse createPersonalBookingSessionCode(
+
+ com.frentix.olat.vitero.manager.stubs.SessionCodeServiceStub.CreatePersonalBookingSessionCodeRequest createPersonalBookingSessionCodeRequest7)
+
+
+ throws java.rmi.RemoteException
+
+ {
+ org.apache.axis2.context.MessageContext _messageContext = null;
+ try{
+ org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[4].getName());
+ _operationClient.getOptions().setAction("\"\"");
+ _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true);
+
+
+
+ addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&");
+
+
+ // create a message context
+ _messageContext = new org.apache.axis2.context.MessageContext();
+
+
+
+ // create SOAP envelope with that payload
+ org.apache.axiom.soap.SOAPEnvelope env = null;
+
+
+ env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()),
+ createPersonalBookingSessionCodeRequest7,
+ optimizeContent(new javax.xml.namespace.QName("http://www.vitero.de/schema/sessioncode",
+ "createPersonalBookingSessionCode")));
+
+ //adding SOAP soap_headers
+ _serviceClient.addHeadersToEnvelope(env);
+ // set the message context with that soap envelope
+ _messageContext.setEnvelope(env);
+
+ // add the message contxt to the operation client
+ _operationClient.addMessageContext(_messageContext);
+
+ //execute the operation client
+ _operationClient.execute(true);
+
+
+ org.apache.axis2.context.MessageContext _returnMessageContext = _operationClient.getMessageContext(
+ org.apache.axis2.wsdl.WSDLConstants.MESSAGE_LABEL_IN_VALUE);
+ org.apache.axiom.soap.SOAPEnvelope _returnEnv = _returnMessageContext.getEnvelope();
+
+
+ java.lang.Object object = fromOM(
+ _returnEnv.getBody().getFirstElement() ,
+ com.frentix.olat.vitero.manager.stubs.SessionCodeServiceStub.CreatePersonalBookingSessionCodeResponse.class,
+ getEnvelopeNamespaces(_returnEnv));
+
+
+ return (com.frentix.olat.vitero.manager.stubs.SessionCodeServiceStub.CreatePersonalBookingSessionCodeResponse)object;
+
+ }catch(org.apache.axis2.AxisFault f){
+
+ org.apache.axiom.om.OMElement faultElt = f.getDetail();
+ if (faultElt!=null){
+ if (faultExceptionNameMap.containsKey(faultElt.getQName())){
+ //make the fault by reflection
+ try{
+ java.lang.String exceptionClassName = (java.lang.String)faultExceptionClassNameMap.get(faultElt.getQName());
+ java.lang.Class exceptionClass = java.lang.Class.forName(exceptionClassName);
+ java.lang.Exception ex=
+ (java.lang.Exception) exceptionClass.newInstance();
+ //message class
+ java.lang.String messageClassName = (java.lang.String)faultMessageMap.get(faultElt.getQName());
+ java.lang.Class messageClass = java.lang.Class.forName(messageClassName);
+ java.lang.Object messageObject = fromOM(faultElt,messageClass,null);
+ java.lang.reflect.Method m = exceptionClass.getMethod("setFaultMessage",
+ new java.lang.Class[]{messageClass});
+ m.invoke(ex,new java.lang.Object[]{messageObject});
+
+
+ throw new java.rmi.RemoteException(ex.getMessage(), ex);
+ }catch(java.lang.ClassCastException e){
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.ClassNotFoundException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ }catch (java.lang.NoSuchMethodException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.reflect.InvocationTargetException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.IllegalAccessException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.InstantiationException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ }
+ }else{
+ throw f;
+ }
+ }else{
+ throw f;
+ }
+ } finally {
+ _messageContext.getTransportOut().getSender().cleanup(_messageContext);
+ }
+ }
+
+ /**
+ * Auto generated method signature for Asynchronous Invocations
+ *
+ * @see com.frentix.olat.vitero.manager.stubs.SessionCodeService#startcreatePersonalBookingSessionCode
+ * @param createPersonalBookingSessionCodeRequest7
+
+ */
+ public void startcreatePersonalBookingSessionCode(
+
+ com.frentix.olat.vitero.manager.stubs.SessionCodeServiceStub.CreatePersonalBookingSessionCodeRequest createPersonalBookingSessionCodeRequest7,
+
+ final com.frentix.olat.vitero.manager.stubs.SessionCodeServiceCallbackHandler callback)
+
+ throws java.rmi.RemoteException{
+
+ org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[4].getName());
+ _operationClient.getOptions().setAction("\"\"");
+ _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true);
+
+
+
+ addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&");
+
+
+
+ // create SOAP envelope with that payload
+ org.apache.axiom.soap.SOAPEnvelope env=null;
+ final org.apache.axis2.context.MessageContext _messageContext = new org.apache.axis2.context.MessageContext();
+
+
+ //Style is Doc.
+
+
+ env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()),
+ createPersonalBookingSessionCodeRequest7,
+ optimizeContent(new javax.xml.namespace.QName("http://www.vitero.de/schema/sessioncode",
+ "createPersonalBookingSessionCode")));
+
+ // adding SOAP soap_headers
+ _serviceClient.addHeadersToEnvelope(env);
+ // create message context with that soap envelope
+ _messageContext.setEnvelope(env);
+
+ // add the message context to the operation client
+ _operationClient.addMessageContext(_messageContext);
+
+
+
+ _operationClient.setCallback(new org.apache.axis2.client.async.AxisCallback() {
+ public void onMessage(org.apache.axis2.context.MessageContext resultContext) {
+ try {
+ org.apache.axiom.soap.SOAPEnvelope resultEnv = resultContext.getEnvelope();
+
+ java.lang.Object object = fromOM(resultEnv.getBody().getFirstElement(),
+ com.frentix.olat.vitero.manager.stubs.SessionCodeServiceStub.CreatePersonalBookingSessionCodeResponse.class,
+ getEnvelopeNamespaces(resultEnv));
+ callback.receiveResultcreatePersonalBookingSessionCode(
+ (com.frentix.olat.vitero.manager.stubs.SessionCodeServiceStub.CreatePersonalBookingSessionCodeResponse)object);
+
+ } catch (org.apache.axis2.AxisFault e) {
+ callback.receiveErrorcreatePersonalBookingSessionCode(e);
+ }
+ }
+
+ public void onError(java.lang.Exception error) {
+ if (error instanceof org.apache.axis2.AxisFault) {
+ org.apache.axis2.AxisFault f = (org.apache.axis2.AxisFault) error;
+ org.apache.axiom.om.OMElement faultElt = f.getDetail();
+ if (faultElt!=null){
+ if (faultExceptionNameMap.containsKey(faultElt.getQName())){
+ //make the fault by reflection
+ try{
+ java.lang.String exceptionClassName = (java.lang.String)faultExceptionClassNameMap.get(faultElt.getQName());
+ java.lang.Class exceptionClass = java.lang.Class.forName(exceptionClassName);
+ java.lang.Exception ex=
+ (java.lang.Exception) exceptionClass.newInstance();
+ //message class
+ java.lang.String messageClassName = (java.lang.String)faultMessageMap.get(faultElt.getQName());
+ java.lang.Class messageClass = java.lang.Class.forName(messageClassName);
+ java.lang.Object messageObject = fromOM(faultElt,messageClass,null);
+ java.lang.reflect.Method m = exceptionClass.getMethod("setFaultMessage",
+ new java.lang.Class[]{messageClass});
+ m.invoke(ex,new java.lang.Object[]{messageObject});
+
+
+ callback.receiveErrorcreatePersonalBookingSessionCode(new java.rmi.RemoteException(ex.getMessage(), ex));
+ } catch(java.lang.ClassCastException e){
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorcreatePersonalBookingSessionCode(f);
+ } catch (java.lang.ClassNotFoundException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorcreatePersonalBookingSessionCode(f);
+ } catch (java.lang.NoSuchMethodException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorcreatePersonalBookingSessionCode(f);
+ } catch (java.lang.reflect.InvocationTargetException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorcreatePersonalBookingSessionCode(f);
+ } catch (java.lang.IllegalAccessException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorcreatePersonalBookingSessionCode(f);
+ } catch (java.lang.InstantiationException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorcreatePersonalBookingSessionCode(f);
+ } catch (org.apache.axis2.AxisFault e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorcreatePersonalBookingSessionCode(f);
+ }
+ } else {
+ callback.receiveErrorcreatePersonalBookingSessionCode(f);
+ }
+ } else {
+ callback.receiveErrorcreatePersonalBookingSessionCode(f);
+ }
+ } else {
+ callback.receiveErrorcreatePersonalBookingSessionCode(error);
+ }
+ }
+
+ public void onFault(org.apache.axis2.context.MessageContext faultContext) {
+ org.apache.axis2.AxisFault fault = org.apache.axis2.util.Utils.getInboundFaultFromMessageContext(faultContext);
+ onError(fault);
+ }
+
+ public void onComplete() {
+ try {
+ _messageContext.getTransportOut().getSender().cleanup(_messageContext);
+ } catch (org.apache.axis2.AxisFault axisFault) {
+ callback.receiveErrorcreatePersonalBookingSessionCode(axisFault);
+ }
+ }
+ });
+
+
+ org.apache.axis2.util.CallbackReceiver _callbackReceiver = null;
+ if ( _operations[4].getMessageReceiver()==null && _operationClient.getOptions().isUseSeparateListener()) {
+ _callbackReceiver = new org.apache.axis2.util.CallbackReceiver();
+ _operations[4].setMessageReceiver(
+ _callbackReceiver);
+ }
+
+ //execute the operation client
+ _operationClient.execute(false);
+
+ }
+
+ /**
+ * Auto generated method signature
+ *
+ * @see com.frentix.olat.vitero.manager.stubs.SessionCodeService#getPersonalBookingSessionCodes
+ * @param getPersonalBookingSessionCodesRequest9
+
+ */
+
+
+
+ public com.frentix.olat.vitero.manager.stubs.SessionCodeServiceStub.GetPersonalBookingSessionCodesResponse getPersonalBookingSessionCodes(
+
+ com.frentix.olat.vitero.manager.stubs.SessionCodeServiceStub.GetPersonalBookingSessionCodesRequest getPersonalBookingSessionCodesRequest9)
+
+
+ throws java.rmi.RemoteException
+
+ {
+ org.apache.axis2.context.MessageContext _messageContext = null;
+ try{
+ org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[5].getName());
+ _operationClient.getOptions().setAction("\"\"");
+ _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true);
+
+
+
+ addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&");
+
+
+ // create a message context
+ _messageContext = new org.apache.axis2.context.MessageContext();
+
+
+
+ // create SOAP envelope with that payload
+ org.apache.axiom.soap.SOAPEnvelope env = null;
+
+
+ env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()),
+ getPersonalBookingSessionCodesRequest9,
+ optimizeContent(new javax.xml.namespace.QName("http://www.vitero.de/schema/sessioncode",
+ "getPersonalBookingSessionCodes")));
+
+ //adding SOAP soap_headers
+ _serviceClient.addHeadersToEnvelope(env);
+ // set the message context with that soap envelope
+ _messageContext.setEnvelope(env);
+
+ // add the message contxt to the operation client
+ _operationClient.addMessageContext(_messageContext);
+
+ //execute the operation client
+ _operationClient.execute(true);
+
+
+ org.apache.axis2.context.MessageContext _returnMessageContext = _operationClient.getMessageContext(
+ org.apache.axis2.wsdl.WSDLConstants.MESSAGE_LABEL_IN_VALUE);
+ org.apache.axiom.soap.SOAPEnvelope _returnEnv = _returnMessageContext.getEnvelope();
+
+
+ java.lang.Object object = fromOM(
+ _returnEnv.getBody().getFirstElement() ,
+ com.frentix.olat.vitero.manager.stubs.SessionCodeServiceStub.GetPersonalBookingSessionCodesResponse.class,
+ getEnvelopeNamespaces(_returnEnv));
+
+
+ return (com.frentix.olat.vitero.manager.stubs.SessionCodeServiceStub.GetPersonalBookingSessionCodesResponse)object;
+
+ }catch(org.apache.axis2.AxisFault f){
+
+ org.apache.axiom.om.OMElement faultElt = f.getDetail();
+ if (faultElt!=null){
+ if (faultExceptionNameMap.containsKey(faultElt.getQName())){
+ //make the fault by reflection
+ try{
+ java.lang.String exceptionClassName = (java.lang.String)faultExceptionClassNameMap.get(faultElt.getQName());
+ java.lang.Class exceptionClass = java.lang.Class.forName(exceptionClassName);
+ java.lang.Exception ex=
+ (java.lang.Exception) exceptionClass.newInstance();
+ //message class
+ java.lang.String messageClassName = (java.lang.String)faultMessageMap.get(faultElt.getQName());
+ java.lang.Class messageClass = java.lang.Class.forName(messageClassName);
+ java.lang.Object messageObject = fromOM(faultElt,messageClass,null);
+ java.lang.reflect.Method m = exceptionClass.getMethod("setFaultMessage",
+ new java.lang.Class[]{messageClass});
+ m.invoke(ex,new java.lang.Object[]{messageObject});
+
+
+ throw new java.rmi.RemoteException(ex.getMessage(), ex);
+ }catch(java.lang.ClassCastException e){
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.ClassNotFoundException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ }catch (java.lang.NoSuchMethodException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.reflect.InvocationTargetException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.IllegalAccessException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.InstantiationException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ }
+ }else{
+ throw f;
+ }
+ }else{
+ throw f;
+ }
+ } finally {
+ _messageContext.getTransportOut().getSender().cleanup(_messageContext);
+ }
+ }
+
+ /**
+ * Auto generated method signature for Asynchronous Invocations
+ *
+ * @see com.frentix.olat.vitero.manager.stubs.SessionCodeService#startgetPersonalBookingSessionCodes
+ * @param getPersonalBookingSessionCodesRequest9
+
+ */
+ public void startgetPersonalBookingSessionCodes(
+
+ com.frentix.olat.vitero.manager.stubs.SessionCodeServiceStub.GetPersonalBookingSessionCodesRequest getPersonalBookingSessionCodesRequest9,
+
+ final com.frentix.olat.vitero.manager.stubs.SessionCodeServiceCallbackHandler callback)
+
+ throws java.rmi.RemoteException{
+
+ org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[5].getName());
+ _operationClient.getOptions().setAction("\"\"");
+ _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true);
+
+
+
+ addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&");
+
+
+
+ // create SOAP envelope with that payload
+ org.apache.axiom.soap.SOAPEnvelope env=null;
+ final org.apache.axis2.context.MessageContext _messageContext = new org.apache.axis2.context.MessageContext();
+
+
+ //Style is Doc.
+
+
+ env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()),
+ getPersonalBookingSessionCodesRequest9,
+ optimizeContent(new javax.xml.namespace.QName("http://www.vitero.de/schema/sessioncode",
+ "getPersonalBookingSessionCodes")));
+
+ // adding SOAP soap_headers
+ _serviceClient.addHeadersToEnvelope(env);
+ // create message context with that soap envelope
+ _messageContext.setEnvelope(env);
+
+ // add the message context to the operation client
+ _operationClient.addMessageContext(_messageContext);
+
+
+
+ _operationClient.setCallback(new org.apache.axis2.client.async.AxisCallback() {
+ public void onMessage(org.apache.axis2.context.MessageContext resultContext) {
+ try {
+ org.apache.axiom.soap.SOAPEnvelope resultEnv = resultContext.getEnvelope();
+
+ java.lang.Object object = fromOM(resultEnv.getBody().getFirstElement(),
+ com.frentix.olat.vitero.manager.stubs.SessionCodeServiceStub.GetPersonalBookingSessionCodesResponse.class,
+ getEnvelopeNamespaces(resultEnv));
+ callback.receiveResultgetPersonalBookingSessionCodes(
+ (com.frentix.olat.vitero.manager.stubs.SessionCodeServiceStub.GetPersonalBookingSessionCodesResponse)object);
+
+ } catch (org.apache.axis2.AxisFault e) {
+ callback.receiveErrorgetPersonalBookingSessionCodes(e);
+ }
+ }
+
+ public void onError(java.lang.Exception error) {
+ if (error instanceof org.apache.axis2.AxisFault) {
+ org.apache.axis2.AxisFault f = (org.apache.axis2.AxisFault) error;
+ org.apache.axiom.om.OMElement faultElt = f.getDetail();
+ if (faultElt!=null){
+ if (faultExceptionNameMap.containsKey(faultElt.getQName())){
+ //make the fault by reflection
+ try{
+ java.lang.String exceptionClassName = (java.lang.String)faultExceptionClassNameMap.get(faultElt.getQName());
+ java.lang.Class exceptionClass = java.lang.Class.forName(exceptionClassName);
+ java.lang.Exception ex=
+ (java.lang.Exception) exceptionClass.newInstance();
+ //message class
+ java.lang.String messageClassName = (java.lang.String)faultMessageMap.get(faultElt.getQName());
+ java.lang.Class messageClass = java.lang.Class.forName(messageClassName);
+ java.lang.Object messageObject = fromOM(faultElt,messageClass,null);
+ java.lang.reflect.Method m = exceptionClass.getMethod("setFaultMessage",
+ new java.lang.Class[]{messageClass});
+ m.invoke(ex,new java.lang.Object[]{messageObject});
+
+
+ callback.receiveErrorgetPersonalBookingSessionCodes(new java.rmi.RemoteException(ex.getMessage(), ex));
+ } catch(java.lang.ClassCastException e){
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetPersonalBookingSessionCodes(f);
+ } catch (java.lang.ClassNotFoundException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetPersonalBookingSessionCodes(f);
+ } catch (java.lang.NoSuchMethodException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetPersonalBookingSessionCodes(f);
+ } catch (java.lang.reflect.InvocationTargetException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetPersonalBookingSessionCodes(f);
+ } catch (java.lang.IllegalAccessException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetPersonalBookingSessionCodes(f);
+ } catch (java.lang.InstantiationException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetPersonalBookingSessionCodes(f);
+ } catch (org.apache.axis2.AxisFault e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetPersonalBookingSessionCodes(f);
+ }
+ } else {
+ callback.receiveErrorgetPersonalBookingSessionCodes(f);
+ }
+ } else {
+ callback.receiveErrorgetPersonalBookingSessionCodes(f);
+ }
+ } else {
+ callback.receiveErrorgetPersonalBookingSessionCodes(error);
+ }
+ }
+
+ public void onFault(org.apache.axis2.context.MessageContext faultContext) {
+ org.apache.axis2.AxisFault fault = org.apache.axis2.util.Utils.getInboundFaultFromMessageContext(faultContext);
+ onError(fault);
+ }
+
+ public void onComplete() {
+ try {
+ _messageContext.getTransportOut().getSender().cleanup(_messageContext);
+ } catch (org.apache.axis2.AxisFault axisFault) {
+ callback.receiveErrorgetPersonalBookingSessionCodes(axisFault);
+ }
+ }
+ });
+
+
+ org.apache.axis2.util.CallbackReceiver _callbackReceiver = null;
+ if ( _operations[5].getMessageReceiver()==null && _operationClient.getOptions().isUseSeparateListener()) {
+ _callbackReceiver = new org.apache.axis2.util.CallbackReceiver();
+ _operations[5].setMessageReceiver(
+ _callbackReceiver);
+ }
+
+ //execute the operation client
+ _operationClient.execute(false);
+
+ }
+
+
+ /**
+ * Auto generated method signature
+ *
+ */
+ public void deleteSessionCode(
+ com.frentix.olat.vitero.manager.stubs.SessionCodeServiceStub.DeleteSessionCodeRequest deleteSessionCodeRequest11
+
+ ) throws java.rmi.RemoteException
+
+
+ {
+ org.apache.axis2.context.MessageContext _messageContext = null;
+
+
+ org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[6].getName());
+ _operationClient.getOptions().setAction("\"\"");
+ _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true);
+
+
+
+ addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&");
+
+ org.apache.axiom.soap.SOAPEnvelope env = null;
+ _messageContext = new org.apache.axis2.context.MessageContext();
+
+
+ //Style is Doc.
+
+
+ env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()),
+ deleteSessionCodeRequest11,
+ optimizeContent(new javax.xml.namespace.QName("http://www.vitero.de/schema/sessioncode",
+ "deleteSessionCode")));
+
+
+ //adding SOAP soap_headers
+ _serviceClient.addHeadersToEnvelope(env);
+ // create message context with that soap envelope
+
+ _messageContext.setEnvelope(env);
+
+ // add the message contxt to the operation client
+ _operationClient.addMessageContext(_messageContext);
+
+ _operationClient.execute(true);
+
+
+ _messageContext.getTransportOut().getSender().cleanup(_messageContext);
+
+ return;
+ }
+
+
+
+ /**
+ * A utility method that copies the namepaces from the SOAPEnvelope
+ */
+ private java.util.Map getEnvelopeNamespaces(org.apache.axiom.soap.SOAPEnvelope env){
+ java.util.Map returnMap = new java.util.HashMap();
+ java.util.Iterator namespaceIterator = env.getAllDeclaredNamespaces();
+ while (namespaceIterator.hasNext()) {
+ org.apache.axiom.om.OMNamespace ns = (org.apache.axiom.om.OMNamespace) namespaceIterator.next();
+ returnMap.put(ns.getPrefix(),ns.getNamespaceURI());
+ }
+ return returnMap;
+ }
+
+
+
+ private javax.xml.namespace.QName[] opNameArray = null;
+ private boolean optimizeContent(javax.xml.namespace.QName opName) {
+
+
+ if (opNameArray == null) {
+ return false;
+ }
+ for (int i = 0; i < opNameArray.length; i++) {
+ if (opName.equals(opNameArray[i])) {
+ return true;
+ }
+ }
+ return false;
+ }
+ //http://192.168.1.54:8080/vitero/services/
+ public static class CreatePersonalBookingSessionCodeRequest
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/sessioncode",
+ "createPersonalBookingSessionCodeRequest",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/sessioncode")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for Sessioncode
+ */
+
+
+ protected Sessioncode_type2 localSessioncode ;
+
+
+ /**
+ * Auto generated getter method
+ * @return Sessioncode_type2
+ */
+ public Sessioncode_type2 getSessioncode(){
+ return localSessioncode;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Sessioncode
+ */
+ public void setSessioncode(Sessioncode_type2 param){
+
+ this.localSessioncode=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ CreatePersonalBookingSessionCodeRequest.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/sessioncode");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":createPersonalBookingSessionCodeRequest",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "createPersonalBookingSessionCodeRequest",
+ xmlWriter);
+ }
+
+
+ }
+
+ if (localSessioncode==null){
+ throw new org.apache.axis2.databinding.ADBException("sessioncode cannot be null!!");
+ }
+ localSessioncode.serialize(new javax.xml.namespace.QName("http://www.vitero.de/schema/sessioncode","sessioncode"),
+ factory,xmlWriter);
+
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/sessioncode",
+ "sessioncode"));
+
+
+ if (localSessioncode==null){
+ throw new org.apache.axis2.databinding.ADBException("sessioncode cannot be null!!");
+ }
+ elementList.add(localSessioncode);
+
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static CreatePersonalBookingSessionCodeRequest parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ CreatePersonalBookingSessionCodeRequest object =
+ new CreatePersonalBookingSessionCodeRequest();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"createPersonalBookingSessionCodeRequest".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (CreatePersonalBookingSessionCodeRequest)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/sessioncode","sessioncode").equals(reader.getName())){
+
+ object.setSessioncode(Sessioncode_type2.Factory.parse(reader));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class GetPersonalGroupSessionCodesRequest
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/sessioncode",
+ "getPersonalGroupSessionCodesRequest",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/sessioncode")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for Userid
+ */
+
+
+ protected int localUserid ;
+
+
+ /**
+ * Auto generated getter method
+ * @return int
+ */
+ public int getUserid(){
+ return localUserid;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Userid
+ */
+ public void setUserid(int param){
+
+ this.localUserid=param;
+
+
+ }
+
+
+ /**
+ * field for Groupid
+ */
+
+
+ protected int localGroupid ;
+
+
+ /**
+ * Auto generated getter method
+ * @return int
+ */
+ public int getGroupid(){
+ return localGroupid;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Groupid
+ */
+ public void setGroupid(int param){
+
+ this.localGroupid=param;
+
+
+ }
+
+
+ /**
+ * field for Timezone
+ */
+
+
+ protected java.lang.String localTimezone ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localTimezoneTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getTimezone(){
+ return localTimezone;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Timezone
+ */
+ public void setTimezone(java.lang.String param){
+
+ if (param != null){
+ //update the setting tracker
+ localTimezoneTracker = true;
+ } else {
+ localTimezoneTracker = false;
+
+ }
+
+ this.localTimezone=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ GetPersonalGroupSessionCodesRequest.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/sessioncode");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":getPersonalGroupSessionCodesRequest",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "getPersonalGroupSessionCodesRequest",
+ xmlWriter);
+ }
+
+
+ }
+
+ namespace = "http://www.vitero.de/schema/sessioncode";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"userid", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"userid");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("userid");
+ }
+
+ if (localUserid==java.lang.Integer.MIN_VALUE) {
+
+ throw new org.apache.axis2.databinding.ADBException("userid cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localUserid));
+ }
+
+ xmlWriter.writeEndElement();
+
+ namespace = "http://www.vitero.de/schema/sessioncode";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"groupid", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"groupid");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("groupid");
+ }
+
+ if (localGroupid==java.lang.Integer.MIN_VALUE) {
+
+ throw new org.apache.axis2.databinding.ADBException("groupid cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localGroupid));
+ }
+
+ xmlWriter.writeEndElement();
+ if (localTimezoneTracker){
+ namespace = "http://www.vitero.de/schema/sessioncode";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"timezone", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"timezone");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("timezone");
+ }
+
+
+ if (localTimezone==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("timezone cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localTimezone);
+
+ }
+
+ xmlWriter.writeEndElement();
+ }
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/sessioncode",
+ "userid"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localUserid));
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/sessioncode",
+ "groupid"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localGroupid));
+ if (localTimezoneTracker){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/sessioncode",
+ "timezone"));
+
+ if (localTimezone != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localTimezone));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("timezone cannot be null!!");
+ }
+ }
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static GetPersonalGroupSessionCodesRequest parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ GetPersonalGroupSessionCodesRequest object =
+ new GetPersonalGroupSessionCodesRequest();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"getPersonalGroupSessionCodesRequest".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (GetPersonalGroupSessionCodesRequest)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/sessioncode","userid").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setUserid(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToInt(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/sessioncode","groupid").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setGroupid(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToInt(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/sessioncode","timezone").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setTimezone(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class CreatePersonalBookingSessionCodeResponse
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/sessioncode",
+ "createPersonalBookingSessionCodeResponse",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/sessioncode")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for CreatePersonalBookingSessionCodeResponse
+ */
+
+
+ protected Codetype localCreatePersonalBookingSessionCodeResponse ;
+
+
+ /**
+ * Auto generated getter method
+ * @return Codetype
+ */
+ public Codetype getCreatePersonalBookingSessionCodeResponse(){
+ return localCreatePersonalBookingSessionCodeResponse;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param CreatePersonalBookingSessionCodeResponse
+ */
+ public void setCreatePersonalBookingSessionCodeResponse(Codetype param){
+
+ this.localCreatePersonalBookingSessionCodeResponse=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ CreatePersonalBookingSessionCodeResponse.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+ //We can safely assume an element has only one type associated with it
+
+ if (localCreatePersonalBookingSessionCodeResponse==null){
+ throw new org.apache.axis2.databinding.ADBException("Property cannot be null!");
+ }
+ localCreatePersonalBookingSessionCodeResponse.serialize(MY_QNAME,factory,xmlWriter);
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+
+ //We can safely assume an element has only one type associated with it
+ return localCreatePersonalBookingSessionCodeResponse.getPullParser(MY_QNAME);
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static CreatePersonalBookingSessionCodeResponse parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ CreatePersonalBookingSessionCodeResponse object =
+ new CreatePersonalBookingSessionCodeResponse();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/sessioncode","createPersonalBookingSessionCodeResponse").equals(reader.getName())){
+
+ object.setCreatePersonalBookingSessionCodeResponse(Codetype.Factory.parse(reader));
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class Sessioncode_type2
+ implements org.apache.axis2.databinding.ADBBean{
+ /* This type was generated from the piece of schema that had
+ name = sessioncode_type2
+ Namespace URI = http://www.vitero.de/schema/sessioncode
+ Namespace Prefix = ns1
+ */
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/sessioncode")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for Userid
+ */
+
+
+ protected int localUserid ;
+
+
+ /**
+ * Auto generated getter method
+ * @return int
+ */
+ public int getUserid(){
+ return localUserid;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Userid
+ */
+ public void setUserid(int param){
+
+ this.localUserid=param;
+
+
+ }
+
+
+ /**
+ * field for Bookingid
+ */
+
+
+ protected int localBookingid ;
+
+
+ /**
+ * Auto generated getter method
+ * @return int
+ */
+ public int getBookingid(){
+ return localBookingid;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Bookingid
+ */
+ public void setBookingid(int param){
+
+ this.localBookingid=param;
+
+
+ }
+
+
+ /**
+ * field for Expirationdate
+ */
+
+
+ protected java.lang.String localExpirationdate ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localExpirationdateTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getExpirationdate(){
+ return localExpirationdate;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Expirationdate
+ */
+ public void setExpirationdate(java.lang.String param){
+
+ if (param != null){
+ //update the setting tracker
+ localExpirationdateTracker = true;
+ } else {
+ localExpirationdateTracker = false;
+
+ }
+
+ this.localExpirationdate=param;
+
+
+ }
+
+
+ /**
+ * field for Timezone
+ */
+
+
+ protected java.lang.String localTimezone ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localTimezoneTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getTimezone(){
+ return localTimezone;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Timezone
+ */
+ public void setTimezone(java.lang.String param){
+
+ if (param != null){
+ //update the setting tracker
+ localTimezoneTracker = true;
+ } else {
+ localTimezoneTracker = false;
+
+ }
+
+ this.localTimezone=param;
+
+
+ }
+
+
+ /**
+ * field for Codelength
+ */
+
+
+ protected int localCodelength ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localCodelengthTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return int
+ */
+ public int getCodelength(){
+ return localCodelength;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Codelength
+ */
+ public void setCodelength(int param){
+
+ // setting primitive attribute tracker to true
+
+ if (param==java.lang.Integer.MIN_VALUE) {
+ localCodelengthTracker = false;
+
+ } else {
+ localCodelengthTracker = true;
+ }
+
+ this.localCodelength=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,parentQName){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ Sessioncode_type2.this.serialize(parentQName,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ parentQName,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/sessioncode");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":sessioncode_type2",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "sessioncode_type2",
+ xmlWriter);
+ }
+
+
+ }
+
+ namespace = "http://www.vitero.de/schema/sessioncode";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"userid", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"userid");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("userid");
+ }
+
+ if (localUserid==java.lang.Integer.MIN_VALUE) {
+
+ throw new org.apache.axis2.databinding.ADBException("userid cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localUserid));
+ }
+
+ xmlWriter.writeEndElement();
+
+ namespace = "http://www.vitero.de/schema/sessioncode";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"bookingid", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"bookingid");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("bookingid");
+ }
+
+ if (localBookingid==java.lang.Integer.MIN_VALUE) {
+
+ throw new org.apache.axis2.databinding.ADBException("bookingid cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localBookingid));
+ }
+
+ xmlWriter.writeEndElement();
+ if (localExpirationdateTracker){
+ namespace = "http://www.vitero.de/schema/sessioncode";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"expirationdate", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"expirationdate");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("expirationdate");
+ }
+
+
+ if (localExpirationdate==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("expirationdate cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localExpirationdate);
+
+ }
+
+ xmlWriter.writeEndElement();
+ } if (localTimezoneTracker){
+ namespace = "http://www.vitero.de/schema/sessioncode";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"timezone", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"timezone");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("timezone");
+ }
+
+
+ if (localTimezone==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("timezone cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localTimezone);
+
+ }
+
+ xmlWriter.writeEndElement();
+ } if (localCodelengthTracker){
+ namespace = "http://www.vitero.de/schema/sessioncode";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"codelength", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"codelength");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("codelength");
+ }
+
+ if (localCodelength==java.lang.Integer.MIN_VALUE) {
+
+ throw new org.apache.axis2.databinding.ADBException("codelength cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localCodelength));
+ }
+
+ xmlWriter.writeEndElement();
+ }
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/sessioncode",
+ "userid"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localUserid));
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/sessioncode",
+ "bookingid"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localBookingid));
+ if (localExpirationdateTracker){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/sessioncode",
+ "expirationdate"));
+
+ if (localExpirationdate != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localExpirationdate));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("expirationdate cannot be null!!");
+ }
+ } if (localTimezoneTracker){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/sessioncode",
+ "timezone"));
+
+ if (localTimezone != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localTimezone));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("timezone cannot be null!!");
+ }
+ } if (localCodelengthTracker){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/sessioncode",
+ "codelength"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localCodelength));
+ }
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static Sessioncode_type2 parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ Sessioncode_type2 object =
+ new Sessioncode_type2();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"sessioncode_type2".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (Sessioncode_type2)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/sessioncode","userid").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setUserid(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToInt(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/sessioncode","bookingid").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setBookingid(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToInt(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/sessioncode","expirationdate").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setExpirationdate(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/sessioncode","timezone").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setTimezone(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/sessioncode","codelength").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setCodelength(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToInt(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class GetSessionCodeInformationRequest
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/sessioncode",
+ "getSessionCodeInformationRequest",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/sessioncode")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for Code
+ */
+
+
+ protected java.lang.String localCode ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getCode(){
+ return localCode;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Code
+ */
+ public void setCode(java.lang.String param){
+
+ this.localCode=param;
+
+
+ }
+
+
+ /**
+ * field for Timezone
+ */
+
+
+ protected java.lang.String localTimezone ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localTimezoneTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getTimezone(){
+ return localTimezone;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Timezone
+ */
+ public void setTimezone(java.lang.String param){
+
+ if (param != null){
+ //update the setting tracker
+ localTimezoneTracker = true;
+ } else {
+ localTimezoneTracker = false;
+
+ }
+
+ this.localTimezone=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ GetSessionCodeInformationRequest.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/sessioncode");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":getSessionCodeInformationRequest",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "getSessionCodeInformationRequest",
+ xmlWriter);
+ }
+
+
+ }
+
+ namespace = "http://www.vitero.de/schema/sessioncode";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"code", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"code");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("code");
+ }
+
+
+ if (localCode==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("code cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localCode);
+
+ }
+
+ xmlWriter.writeEndElement();
+ if (localTimezoneTracker){
+ namespace = "http://www.vitero.de/schema/sessioncode";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"timezone", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"timezone");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("timezone");
+ }
+
+
+ if (localTimezone==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("timezone cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localTimezone);
+
+ }
+
+ xmlWriter.writeEndElement();
+ }
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/sessioncode",
+ "code"));
+
+ if (localCode != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localCode));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("code cannot be null!!");
+ }
+ if (localTimezoneTracker){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/sessioncode",
+ "timezone"));
+
+ if (localTimezone != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localTimezone));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("timezone cannot be null!!");
+ }
+ }
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static GetSessionCodeInformationRequest parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ GetSessionCodeInformationRequest object =
+ new GetSessionCodeInformationRequest();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"getSessionCodeInformationRequest".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (GetSessionCodeInformationRequest)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/sessioncode","code").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setCode(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/sessioncode","timezone").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setTimezone(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class Sessioncode_type0
+ implements org.apache.axis2.databinding.ADBBean{
+ /* This type was generated from the piece of schema that had
+ name = sessioncode_type0
+ Namespace URI = http://www.vitero.de/schema/sessioncode
+ Namespace Prefix = ns1
+ */
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/sessioncode")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for Type
+ */
+
+
+ protected java.lang.String localType ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getType(){
+ return localType;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Type
+ */
+ public void setType(java.lang.String param){
+
+ this.localType=param;
+
+
+ }
+
+
+ /**
+ * field for Userid
+ */
+
+
+ protected int localUserid ;
+
+
+ /**
+ * Auto generated getter method
+ * @return int
+ */
+ public int getUserid(){
+ return localUserid;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Userid
+ */
+ public void setUserid(int param){
+
+ this.localUserid=param;
+
+
+ }
+
+
+ /**
+ * field for Bookingid
+ */
+
+
+ protected int localBookingid ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localBookingidTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return int
+ */
+ public int getBookingid(){
+ return localBookingid;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Bookingid
+ */
+ public void setBookingid(int param){
+
+ // setting primitive attribute tracker to true
+
+ if (param==java.lang.Integer.MIN_VALUE) {
+ localBookingidTracker = false;
+
+ } else {
+ localBookingidTracker = true;
+ }
+
+ this.localBookingid=param;
+
+
+ }
+
+
+ /**
+ * field for Groupid
+ */
+
+
+ protected int localGroupid ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localGroupidTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return int
+ */
+ public int getGroupid(){
+ return localGroupid;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Groupid
+ */
+ public void setGroupid(int param){
+
+ // setting primitive attribute tracker to true
+
+ if (param==java.lang.Integer.MIN_VALUE) {
+ localGroupidTracker = false;
+
+ } else {
+ localGroupidTracker = true;
+ }
+
+ this.localGroupid=param;
+
+
+ }
+
+
+ /**
+ * field for Expirationdate
+ */
+
+
+ protected java.lang.String localExpirationdate ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localExpirationdateTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getExpirationdate(){
+ return localExpirationdate;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Expirationdate
+ */
+ public void setExpirationdate(java.lang.String param){
+
+ if (param != null){
+ //update the setting tracker
+ localExpirationdateTracker = true;
+ } else {
+ localExpirationdateTracker = false;
+
+ }
+
+ this.localExpirationdate=param;
+
+
+ }
+
+
+ /**
+ * field for Allownotexistingusers
+ */
+
+
+ protected boolean localAllownotexistingusers ;
+
+
+ /**
+ * Auto generated getter method
+ * @return boolean
+ */
+ public boolean getAllownotexistingusers(){
+ return localAllownotexistingusers;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Allownotexistingusers
+ */
+ public void setAllownotexistingusers(boolean param){
+
+ this.localAllownotexistingusers=param;
+
+
+ }
+
+
+ /**
+ * field for Allownotassignedusers
+ */
+
+
+ protected boolean localAllownotassignedusers ;
+
+
+ /**
+ * Auto generated getter method
+ * @return boolean
+ */
+ public boolean getAllownotassignedusers(){
+ return localAllownotassignedusers;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Allownotassignedusers
+ */
+ public void setAllownotassignedusers(boolean param){
+
+ this.localAllownotassignedusers=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,parentQName){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ Sessioncode_type0.this.serialize(parentQName,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ parentQName,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/sessioncode");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":sessioncode_type0",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "sessioncode_type0",
+ xmlWriter);
+ }
+
+
+ }
+
+ namespace = "http://www.vitero.de/schema/sessioncode";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"type", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"type");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("type");
+ }
+
+
+ if (localType==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("type cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localType);
+
+ }
+
+ xmlWriter.writeEndElement();
+
+ namespace = "http://www.vitero.de/schema/sessioncode";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"userid", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"userid");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("userid");
+ }
+
+ if (localUserid==java.lang.Integer.MIN_VALUE) {
+
+ throw new org.apache.axis2.databinding.ADBException("userid cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localUserid));
+ }
+
+ xmlWriter.writeEndElement();
+ if (localBookingidTracker){
+ namespace = "http://www.vitero.de/schema/sessioncode";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"bookingid", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"bookingid");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("bookingid");
+ }
+
+ if (localBookingid==java.lang.Integer.MIN_VALUE) {
+
+ throw new org.apache.axis2.databinding.ADBException("bookingid cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localBookingid));
+ }
+
+ xmlWriter.writeEndElement();
+ } if (localGroupidTracker){
+ namespace = "http://www.vitero.de/schema/sessioncode";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"groupid", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"groupid");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("groupid");
+ }
+
+ if (localGroupid==java.lang.Integer.MIN_VALUE) {
+
+ throw new org.apache.axis2.databinding.ADBException("groupid cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localGroupid));
+ }
+
+ xmlWriter.writeEndElement();
+ } if (localExpirationdateTracker){
+ namespace = "http://www.vitero.de/schema/sessioncode";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"expirationdate", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"expirationdate");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("expirationdate");
+ }
+
+
+ if (localExpirationdate==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("expirationdate cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localExpirationdate);
+
+ }
+
+ xmlWriter.writeEndElement();
+ }
+ namespace = "http://www.vitero.de/schema/sessioncode";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"allownotexistingusers", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"allownotexistingusers");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("allownotexistingusers");
+ }
+
+ if (false) {
+
+ throw new org.apache.axis2.databinding.ADBException("allownotexistingusers cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localAllownotexistingusers));
+ }
+
+ xmlWriter.writeEndElement();
+
+ namespace = "http://www.vitero.de/schema/sessioncode";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"allownotassignedusers", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"allownotassignedusers");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("allownotassignedusers");
+ }
+
+ if (false) {
+
+ throw new org.apache.axis2.databinding.ADBException("allownotassignedusers cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localAllownotassignedusers));
+ }
+
+ xmlWriter.writeEndElement();
+
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/sessioncode",
+ "type"));
+
+ if (localType != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localType));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("type cannot be null!!");
+ }
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/sessioncode",
+ "userid"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localUserid));
+ if (localBookingidTracker){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/sessioncode",
+ "bookingid"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localBookingid));
+ } if (localGroupidTracker){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/sessioncode",
+ "groupid"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localGroupid));
+ } if (localExpirationdateTracker){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/sessioncode",
+ "expirationdate"));
+
+ if (localExpirationdate != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localExpirationdate));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("expirationdate cannot be null!!");
+ }
+ }
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/sessioncode",
+ "allownotexistingusers"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localAllownotexistingusers));
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/sessioncode",
+ "allownotassignedusers"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localAllownotassignedusers));
+
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static Sessioncode_type0 parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ Sessioncode_type0 object =
+ new Sessioncode_type0();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"sessioncode_type0".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (Sessioncode_type0)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/sessioncode","type").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setType(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/sessioncode","userid").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setUserid(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToInt(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/sessioncode","bookingid").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setBookingid(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToInt(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/sessioncode","groupid").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setGroupid(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToInt(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/sessioncode","expirationdate").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setExpirationdate(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/sessioncode","allownotexistingusers").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setAllownotexistingusers(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToBoolean(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/sessioncode","allownotassignedusers").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setAllownotassignedusers(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToBoolean(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class Sessioncodebyidtype
+ implements org.apache.axis2.databinding.ADBBean{
+ /* This type was generated from the piece of schema that had
+ name = sessioncodebyidtype
+ Namespace URI = http://www.vitero.de/schema/sessioncode
+ Namespace Prefix = ns1
+ */
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/sessioncode")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for Code
+ */
+
+
+ protected java.lang.String localCode ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getCode(){
+ return localCode;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Code
+ */
+ public void setCode(java.lang.String param){
+
+ this.localCode=param;
+
+
+ }
+
+
+ /**
+ * field for Expirationdate
+ */
+
+
+ protected java.lang.String localExpirationdate ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localExpirationdateTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getExpirationdate(){
+ return localExpirationdate;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Expirationdate
+ */
+ public void setExpirationdate(java.lang.String param){
+
+ if (param != null){
+ //update the setting tracker
+ localExpirationdateTracker = true;
+ } else {
+ localExpirationdateTracker = false;
+
+ }
+
+ this.localExpirationdate=param;
+
+
+ }
+
+
+ /**
+ * field for Allownotassignedusers
+ */
+
+
+ protected boolean localAllownotassignedusers ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localAllownotassignedusersTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return boolean
+ */
+ public boolean getAllownotassignedusers(){
+ return localAllownotassignedusers;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Allownotassignedusers
+ */
+ public void setAllownotassignedusers(boolean param){
+
+ // setting primitive attribute tracker to true
+
+ if (false) {
+ localAllownotassignedusersTracker = false;
+
+ } else {
+ localAllownotassignedusersTracker = true;
+ }
+
+ this.localAllownotassignedusers=param;
+
+
+ }
+
+
+ /**
+ * field for Allownotexistingusers
+ */
+
+
+ protected boolean localAllownotexistingusers ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localAllownotexistingusersTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return boolean
+ */
+ public boolean getAllownotexistingusers(){
+ return localAllownotexistingusers;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Allownotexistingusers
+ */
+ public void setAllownotexistingusers(boolean param){
+
+ // setting primitive attribute tracker to true
+
+ if (false) {
+ localAllownotexistingusersTracker = false;
+
+ } else {
+ localAllownotexistingusersTracker = true;
+ }
+
+ this.localAllownotexistingusers=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,parentQName){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ Sessioncodebyidtype.this.serialize(parentQName,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ parentQName,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/sessioncode");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":sessioncodebyidtype",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "sessioncodebyidtype",
+ xmlWriter);
+ }
+
+
+ }
+
+ namespace = "http://www.vitero.de/schema/sessioncode";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"code", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"code");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("code");
+ }
+
+
+ if (localCode==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("code cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localCode);
+
+ }
+
+ xmlWriter.writeEndElement();
+ if (localExpirationdateTracker){
+ namespace = "http://www.vitero.de/schema/sessioncode";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"expirationdate", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"expirationdate");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("expirationdate");
+ }
+
+
+ if (localExpirationdate==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("expirationdate cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localExpirationdate);
+
+ }
+
+ xmlWriter.writeEndElement();
+ } if (localAllownotassignedusersTracker){
+ namespace = "http://www.vitero.de/schema/sessioncode";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"allownotassignedusers", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"allownotassignedusers");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("allownotassignedusers");
+ }
+
+ if (false) {
+
+ throw new org.apache.axis2.databinding.ADBException("allownotassignedusers cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localAllownotassignedusers));
+ }
+
+ xmlWriter.writeEndElement();
+ } if (localAllownotexistingusersTracker){
+ namespace = "http://www.vitero.de/schema/sessioncode";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"allownotexistingusers", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"allownotexistingusers");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("allownotexistingusers");
+ }
+
+ if (false) {
+
+ throw new org.apache.axis2.databinding.ADBException("allownotexistingusers cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localAllownotexistingusers));
+ }
+
+ xmlWriter.writeEndElement();
+ }
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/sessioncode",
+ "code"));
+
+ if (localCode != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localCode));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("code cannot be null!!");
+ }
+ if (localExpirationdateTracker){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/sessioncode",
+ "expirationdate"));
+
+ if (localExpirationdate != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localExpirationdate));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("expirationdate cannot be null!!");
+ }
+ } if (localAllownotassignedusersTracker){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/sessioncode",
+ "allownotassignedusers"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localAllownotassignedusers));
+ } if (localAllownotexistingusersTracker){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/sessioncode",
+ "allownotexistingusers"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localAllownotexistingusers));
+ }
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static Sessioncodebyidtype parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ Sessioncodebyidtype object =
+ new Sessioncodebyidtype();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"sessioncodebyidtype".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (Sessioncodebyidtype)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/sessioncode","code").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setCode(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/sessioncode","expirationdate").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setExpirationdate(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/sessioncode","allownotassignedusers").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setAllownotassignedusers(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToBoolean(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/sessioncode","allownotexistingusers").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setAllownotexistingusers(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToBoolean(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class Sessioncode_type1
+ implements org.apache.axis2.databinding.ADBBean{
+ /* This type was generated from the piece of schema that had
+ name = sessioncode_type1
+ Namespace URI = http://www.vitero.de/schema/sessioncode
+ Namespace Prefix = ns1
+ */
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/sessioncode")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for Userid
+ */
+
+
+ protected int localUserid ;
+
+
+ /**
+ * Auto generated getter method
+ * @return int
+ */
+ public int getUserid(){
+ return localUserid;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Userid
+ */
+ public void setUserid(int param){
+
+ this.localUserid=param;
+
+
+ }
+
+
+ /**
+ * field for Groupid
+ */
+
+
+ protected int localGroupid ;
+
+
+ /**
+ * Auto generated getter method
+ * @return int
+ */
+ public int getGroupid(){
+ return localGroupid;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Groupid
+ */
+ public void setGroupid(int param){
+
+ this.localGroupid=param;
+
+
+ }
+
+
+ /**
+ * field for Expirationdate
+ */
+
+
+ protected java.lang.String localExpirationdate ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localExpirationdateTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getExpirationdate(){
+ return localExpirationdate;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Expirationdate
+ */
+ public void setExpirationdate(java.lang.String param){
+
+ if (param != null){
+ //update the setting tracker
+ localExpirationdateTracker = true;
+ } else {
+ localExpirationdateTracker = false;
+
+ }
+
+ this.localExpirationdate=param;
+
+
+ }
+
+
+ /**
+ * field for Timezone
+ */
+
+
+ protected java.lang.String localTimezone ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localTimezoneTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getTimezone(){
+ return localTimezone;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Timezone
+ */
+ public void setTimezone(java.lang.String param){
+
+ if (param != null){
+ //update the setting tracker
+ localTimezoneTracker = true;
+ } else {
+ localTimezoneTracker = false;
+
+ }
+
+ this.localTimezone=param;
+
+
+ }
+
+
+ /**
+ * field for Codelength
+ */
+
+
+ protected int localCodelength ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localCodelengthTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return int
+ */
+ public int getCodelength(){
+ return localCodelength;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Codelength
+ */
+ public void setCodelength(int param){
+
+ // setting primitive attribute tracker to true
+
+ if (param==java.lang.Integer.MIN_VALUE) {
+ localCodelengthTracker = false;
+
+ } else {
+ localCodelengthTracker = true;
+ }
+
+ this.localCodelength=param;
+
+
+ }
+
+
+ /**
+ * field for Allownotassignedusers
+ */
+
+
+ protected boolean localAllownotassignedusers ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localAllownotassignedusersTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return boolean
+ */
+ public boolean getAllownotassignedusers(){
+ return localAllownotassignedusers;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Allownotassignedusers
+ */
+ public void setAllownotassignedusers(boolean param){
+
+ // setting primitive attribute tracker to true
+
+ if (false) {
+ localAllownotassignedusersTracker = false;
+
+ } else {
+ localAllownotassignedusersTracker = true;
+ }
+
+ this.localAllownotassignedusers=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,parentQName){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ Sessioncode_type1.this.serialize(parentQName,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ parentQName,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/sessioncode");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":sessioncode_type1",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "sessioncode_type1",
+ xmlWriter);
+ }
+
+
+ }
+
+ namespace = "http://www.vitero.de/schema/sessioncode";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"userid", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"userid");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("userid");
+ }
+
+ if (localUserid==java.lang.Integer.MIN_VALUE) {
+
+ throw new org.apache.axis2.databinding.ADBException("userid cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localUserid));
+ }
+
+ xmlWriter.writeEndElement();
+
+ namespace = "http://www.vitero.de/schema/sessioncode";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"groupid", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"groupid");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("groupid");
+ }
+
+ if (localGroupid==java.lang.Integer.MIN_VALUE) {
+
+ throw new org.apache.axis2.databinding.ADBException("groupid cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localGroupid));
+ }
+
+ xmlWriter.writeEndElement();
+ if (localExpirationdateTracker){
+ namespace = "http://www.vitero.de/schema/sessioncode";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"expirationdate", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"expirationdate");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("expirationdate");
+ }
+
+
+ if (localExpirationdate==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("expirationdate cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localExpirationdate);
+
+ }
+
+ xmlWriter.writeEndElement();
+ } if (localTimezoneTracker){
+ namespace = "http://www.vitero.de/schema/sessioncode";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"timezone", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"timezone");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("timezone");
+ }
+
+
+ if (localTimezone==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("timezone cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localTimezone);
+
+ }
+
+ xmlWriter.writeEndElement();
+ } if (localCodelengthTracker){
+ namespace = "http://www.vitero.de/schema/sessioncode";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"codelength", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"codelength");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("codelength");
+ }
+
+ if (localCodelength==java.lang.Integer.MIN_VALUE) {
+
+ throw new org.apache.axis2.databinding.ADBException("codelength cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localCodelength));
+ }
+
+ xmlWriter.writeEndElement();
+ } if (localAllownotassignedusersTracker){
+ namespace = "http://www.vitero.de/schema/sessioncode";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"allownotassignedusers", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"allownotassignedusers");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("allownotassignedusers");
+ }
+
+ if (false) {
+
+ throw new org.apache.axis2.databinding.ADBException("allownotassignedusers cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localAllownotassignedusers));
+ }
+
+ xmlWriter.writeEndElement();
+ }
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/sessioncode",
+ "userid"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localUserid));
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/sessioncode",
+ "groupid"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localGroupid));
+ if (localExpirationdateTracker){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/sessioncode",
+ "expirationdate"));
+
+ if (localExpirationdate != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localExpirationdate));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("expirationdate cannot be null!!");
+ }
+ } if (localTimezoneTracker){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/sessioncode",
+ "timezone"));
+
+ if (localTimezone != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localTimezone));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("timezone cannot be null!!");
+ }
+ } if (localCodelengthTracker){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/sessioncode",
+ "codelength"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localCodelength));
+ } if (localAllownotassignedusersTracker){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/sessioncode",
+ "allownotassignedusers"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localAllownotassignedusers));
+ }
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static Sessioncode_type1 parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ Sessioncode_type1 object =
+ new Sessioncode_type1();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"sessioncode_type1".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (Sessioncode_type1)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/sessioncode","userid").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setUserid(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToInt(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/sessioncode","groupid").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setGroupid(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToInt(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/sessioncode","expirationdate").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setExpirationdate(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/sessioncode","timezone").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setTimezone(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/sessioncode","codelength").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setCodelength(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToInt(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/sessioncode","allownotassignedusers").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setAllownotassignedusers(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToBoolean(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class GetPersonalBookingSessionCodesRequest
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/sessioncode",
+ "getPersonalBookingSessionCodesRequest",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/sessioncode")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for Userid
+ */
+
+
+ protected int localUserid ;
+
+
+ /**
+ * Auto generated getter method
+ * @return int
+ */
+ public int getUserid(){
+ return localUserid;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Userid
+ */
+ public void setUserid(int param){
+
+ this.localUserid=param;
+
+
+ }
+
+
+ /**
+ * field for Bookingid
+ */
+
+
+ protected int localBookingid ;
+
+
+ /**
+ * Auto generated getter method
+ * @return int
+ */
+ public int getBookingid(){
+ return localBookingid;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Bookingid
+ */
+ public void setBookingid(int param){
+
+ this.localBookingid=param;
+
+
+ }
+
+
+ /**
+ * field for Timezone
+ */
+
+
+ protected java.lang.String localTimezone ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localTimezoneTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getTimezone(){
+ return localTimezone;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Timezone
+ */
+ public void setTimezone(java.lang.String param){
+
+ if (param != null){
+ //update the setting tracker
+ localTimezoneTracker = true;
+ } else {
+ localTimezoneTracker = false;
+
+ }
+
+ this.localTimezone=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ GetPersonalBookingSessionCodesRequest.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/sessioncode");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":getPersonalBookingSessionCodesRequest",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "getPersonalBookingSessionCodesRequest",
+ xmlWriter);
+ }
+
+
+ }
+
+ namespace = "http://www.vitero.de/schema/sessioncode";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"userid", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"userid");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("userid");
+ }
+
+ if (localUserid==java.lang.Integer.MIN_VALUE) {
+
+ throw new org.apache.axis2.databinding.ADBException("userid cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localUserid));
+ }
+
+ xmlWriter.writeEndElement();
+
+ namespace = "http://www.vitero.de/schema/sessioncode";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"bookingid", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"bookingid");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("bookingid");
+ }
+
+ if (localBookingid==java.lang.Integer.MIN_VALUE) {
+
+ throw new org.apache.axis2.databinding.ADBException("bookingid cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localBookingid));
+ }
+
+ xmlWriter.writeEndElement();
+ if (localTimezoneTracker){
+ namespace = "http://www.vitero.de/schema/sessioncode";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"timezone", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"timezone");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("timezone");
+ }
+
+
+ if (localTimezone==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("timezone cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localTimezone);
+
+ }
+
+ xmlWriter.writeEndElement();
+ }
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/sessioncode",
+ "userid"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localUserid));
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/sessioncode",
+ "bookingid"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localBookingid));
+ if (localTimezoneTracker){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/sessioncode",
+ "timezone"));
+
+ if (localTimezone != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localTimezone));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("timezone cannot be null!!");
+ }
+ }
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static GetPersonalBookingSessionCodesRequest parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ GetPersonalBookingSessionCodesRequest object =
+ new GetPersonalBookingSessionCodesRequest();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"getPersonalBookingSessionCodesRequest".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (GetPersonalBookingSessionCodesRequest)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/sessioncode","userid").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setUserid(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToInt(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/sessioncode","bookingid").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setBookingid(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToInt(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/sessioncode","timezone").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setTimezone(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class Codetype
+ implements org.apache.axis2.databinding.ADBBean{
+ /* This type was generated from the piece of schema that had
+ name = codetype
+ Namespace URI = http://www.vitero.de/schema/sessioncode
+ Namespace Prefix = ns1
+ */
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/sessioncode")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for Code
+ */
+
+
+ protected java.lang.String localCode ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getCode(){
+ return localCode;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Code
+ */
+ public void setCode(java.lang.String param){
+
+ this.localCode=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,parentQName){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ Codetype.this.serialize(parentQName,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ parentQName,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/sessioncode");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":codetype",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "codetype",
+ xmlWriter);
+ }
+
+
+ }
+
+ namespace = "http://www.vitero.de/schema/sessioncode";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"code", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"code");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("code");
+ }
+
+
+ if (localCode==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("code cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localCode);
+
+ }
+
+ xmlWriter.writeEndElement();
+
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/sessioncode",
+ "code"));
+
+ if (localCode != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localCode));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("code cannot be null!!");
+ }
+
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static Codetype parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ Codetype object =
+ new Codetype();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"codetype".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (Codetype)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/sessioncode","code").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setCode(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class SuccessResponse
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/sessioncode",
+ "successResponse",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/sessioncode")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for Request
+ */
+
+
+ protected java.lang.String localRequest ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getRequest(){
+ return localRequest;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Request
+ */
+ public void setRequest(java.lang.String param){
+
+ this.localRequest=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ SuccessResponse.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/sessioncode");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":successResponse",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "successResponse",
+ xmlWriter);
+ }
+
+
+ }
+
+ namespace = "http://www.vitero.de/schema/sessioncode";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"request", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"request");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("request");
+ }
+
+
+ if (localRequest==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("request cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localRequest);
+
+ }
+
+ xmlWriter.writeEndElement();
+
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/sessioncode",
+ "request"));
+
+ if (localRequest != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localRequest));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("request cannot be null!!");
+ }
+
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static SuccessResponse parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ SuccessResponse object =
+ new SuccessResponse();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"successResponse".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (SuccessResponse)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/sessioncode","request").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setRequest(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class ExtensionMapper{
+
+ public static java.lang.Object getTypeObject(java.lang.String namespaceURI,
+ java.lang.String typeName,
+ javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+
+
+ if (
+ "http://www.vitero.de/schema/sessioncode".equals(namespaceURI) &&
+ "sessioncodebyidtype".equals(typeName)){
+
+ return Sessioncodebyidtype.Factory.parse(reader);
+
+
+ }
+
+
+ if (
+ "http://www.vitero.de/schema/sessioncode".equals(namespaceURI) &&
+ "sessioncode_type2".equals(typeName)){
+
+ return Sessioncode_type2.Factory.parse(reader);
+
+
+ }
+
+
+ if (
+ "http://www.vitero.de/schema/sessioncode".equals(namespaceURI) &&
+ "codetype".equals(typeName)){
+
+ return Codetype.Factory.parse(reader);
+
+
+ }
+
+
+ if (
+ "http://www.vitero.de/schema/sessioncode".equals(namespaceURI) &&
+ "sessioncode_type0".equals(typeName)){
+
+ return Sessioncode_type0.Factory.parse(reader);
+
+
+ }
+
+
+ if (
+ "http://www.vitero.de/schema/sessioncode".equals(namespaceURI) &&
+ "sessioncode_type1".equals(typeName)){
+
+ return Sessioncode_type1.Factory.parse(reader);
+
+
+ }
+
+
+ throw new org.apache.axis2.databinding.ADBException("Unsupported type " + namespaceURI + " " + typeName);
+ }
+
+ }
+
+ public static class GetSessionCodeInformationResponse
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/sessioncode",
+ "getSessionCodeInformationResponse",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/sessioncode")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for Sessioncode
+ */
+
+
+ protected Sessioncode_type0 localSessioncode ;
+
+
+ /**
+ * Auto generated getter method
+ * @return Sessioncode_type0
+ */
+ public Sessioncode_type0 getSessioncode(){
+ return localSessioncode;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Sessioncode
+ */
+ public void setSessioncode(Sessioncode_type0 param){
+
+ this.localSessioncode=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ GetSessionCodeInformationResponse.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/sessioncode");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":getSessionCodeInformationResponse",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "getSessionCodeInformationResponse",
+ xmlWriter);
+ }
+
+
+ }
+
+ if (localSessioncode==null){
+ throw new org.apache.axis2.databinding.ADBException("sessioncode cannot be null!!");
+ }
+ localSessioncode.serialize(new javax.xml.namespace.QName("http://www.vitero.de/schema/sessioncode","sessioncode"),
+ factory,xmlWriter);
+
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/sessioncode",
+ "sessioncode"));
+
+
+ if (localSessioncode==null){
+ throw new org.apache.axis2.databinding.ADBException("sessioncode cannot be null!!");
+ }
+ elementList.add(localSessioncode);
+
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static GetSessionCodeInformationResponse parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ GetSessionCodeInformationResponse object =
+ new GetSessionCodeInformationResponse();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"getSessionCodeInformationResponse".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (GetSessionCodeInformationResponse)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/sessioncode","sessioncode").equals(reader.getName())){
+
+ object.setSessioncode(Sessioncode_type0.Factory.parse(reader));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class DeleteSessionCodeRequest
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/sessioncode",
+ "deleteSessionCodeRequest",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/sessioncode")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for DeleteSessionCodeRequest
+ */
+
+
+ protected Codetype localDeleteSessionCodeRequest ;
+
+
+ /**
+ * Auto generated getter method
+ * @return Codetype
+ */
+ public Codetype getDeleteSessionCodeRequest(){
+ return localDeleteSessionCodeRequest;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param DeleteSessionCodeRequest
+ */
+ public void setDeleteSessionCodeRequest(Codetype param){
+
+ this.localDeleteSessionCodeRequest=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ DeleteSessionCodeRequest.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+ //We can safely assume an element has only one type associated with it
+
+ if (localDeleteSessionCodeRequest==null){
+ throw new org.apache.axis2.databinding.ADBException("Property cannot be null!");
+ }
+ localDeleteSessionCodeRequest.serialize(MY_QNAME,factory,xmlWriter);
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+
+ //We can safely assume an element has only one type associated with it
+ return localDeleteSessionCodeRequest.getPullParser(MY_QNAME);
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static DeleteSessionCodeRequest parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ DeleteSessionCodeRequest object =
+ new DeleteSessionCodeRequest();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/sessioncode","deleteSessionCodeRequest").equals(reader.getName())){
+
+ object.setDeleteSessionCodeRequest(Codetype.Factory.parse(reader));
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class CreatePersonalGroupSessionCodeRequest
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/sessioncode",
+ "createPersonalGroupSessionCodeRequest",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/sessioncode")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for Sessioncode
+ */
+
+
+ protected Sessioncode_type1 localSessioncode ;
+
+
+ /**
+ * Auto generated getter method
+ * @return Sessioncode_type1
+ */
+ public Sessioncode_type1 getSessioncode(){
+ return localSessioncode;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Sessioncode
+ */
+ public void setSessioncode(Sessioncode_type1 param){
+
+ this.localSessioncode=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ CreatePersonalGroupSessionCodeRequest.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/sessioncode");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":createPersonalGroupSessionCodeRequest",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "createPersonalGroupSessionCodeRequest",
+ xmlWriter);
+ }
+
+
+ }
+
+ if (localSessioncode==null){
+ throw new org.apache.axis2.databinding.ADBException("sessioncode cannot be null!!");
+ }
+ localSessioncode.serialize(new javax.xml.namespace.QName("http://www.vitero.de/schema/sessioncode","sessioncode"),
+ factory,xmlWriter);
+
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/sessioncode",
+ "sessioncode"));
+
+
+ if (localSessioncode==null){
+ throw new org.apache.axis2.databinding.ADBException("sessioncode cannot be null!!");
+ }
+ elementList.add(localSessioncode);
+
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static CreatePersonalGroupSessionCodeRequest parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ CreatePersonalGroupSessionCodeRequest object =
+ new CreatePersonalGroupSessionCodeRequest();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"createPersonalGroupSessionCodeRequest".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (CreatePersonalGroupSessionCodeRequest)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/sessioncode","sessioncode").equals(reader.getName())){
+
+ object.setSessioncode(Sessioncode_type1.Factory.parse(reader));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class GetPersonalGroupSessionCodesResponse
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/sessioncode",
+ "getPersonalGroupSessionCodesResponse",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/sessioncode")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for Sessioncode
+ * This was an Array!
+ */
+
+
+ protected Sessioncodebyidtype[] localSessioncode ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localSessioncodeTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return Sessioncodebyidtype[]
+ */
+ public Sessioncodebyidtype[] getSessioncode(){
+ return localSessioncode;
+ }
+
+
+
+
+
+
+ /**
+ * validate the array for Sessioncode
+ */
+ protected void validateSessioncode(Sessioncodebyidtype[] param){
+
+ }
+
+
+ /**
+ * Auto generated setter method
+ * @param param Sessioncode
+ */
+ public void setSessioncode(Sessioncodebyidtype[] param){
+
+ validateSessioncode(param);
+
+
+ if (param != null){
+ //update the setting tracker
+ localSessioncodeTracker = true;
+ } else {
+ localSessioncodeTracker = false;
+
+ }
+
+ this.localSessioncode=param;
+ }
+
+
+
+ /**
+ * Auto generated add method for the array for convenience
+ * @param param Sessioncodebyidtype
+ */
+ public void addSessioncode(Sessioncodebyidtype param){
+ if (localSessioncode == null){
+ localSessioncode = new Sessioncodebyidtype[]{};
+ }
+
+
+ //update the setting tracker
+ localSessioncodeTracker = true;
+
+
+ java.util.List list =
+ org.apache.axis2.databinding.utils.ConverterUtil.toList(localSessioncode);
+ list.add(param);
+ this.localSessioncode =
+ (Sessioncodebyidtype[])list.toArray(
+ new Sessioncodebyidtype[list.size()]);
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ GetPersonalGroupSessionCodesResponse.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/sessioncode");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":getPersonalGroupSessionCodesResponse",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "getPersonalGroupSessionCodesResponse",
+ xmlWriter);
+ }
+
+
+ }
+ if (localSessioncodeTracker){
+ if (localSessioncode!=null){
+ for (int i = 0;i < localSessioncode.length;i++){
+ if (localSessioncode[i] != null){
+ localSessioncode[i].serialize(new javax.xml.namespace.QName("http://www.vitero.de/schema/sessioncode","sessioncode"),
+ factory,xmlWriter);
+ } else {
+
+ // we don't have to do any thing since minOccures is zero
+
+ }
+
+ }
+ } else {
+
+ throw new org.apache.axis2.databinding.ADBException("sessioncode cannot be null!!");
+
+ }
+ }
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+ if (localSessioncodeTracker){
+ if (localSessioncode!=null) {
+ for (int i = 0;i < localSessioncode.length;i++){
+
+ if (localSessioncode[i] != null){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/sessioncode",
+ "sessioncode"));
+ elementList.add(localSessioncode[i]);
+ } else {
+
+ // nothing to do
+
+ }
+
+ }
+ } else {
+
+ throw new org.apache.axis2.databinding.ADBException("sessioncode cannot be null!!");
+
+ }
+
+ }
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static GetPersonalGroupSessionCodesResponse parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ GetPersonalGroupSessionCodesResponse object =
+ new GetPersonalGroupSessionCodesResponse();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"getPersonalGroupSessionCodesResponse".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (GetPersonalGroupSessionCodesResponse)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+ java.util.ArrayList list1 = new java.util.ArrayList();
+
+
+ while (!reader.isStartElement() && !reader.isEndElement()) reader.next();
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/sessioncode","sessioncode").equals(reader.getName())){
+
+
+
+ // Process the array and step past its final element's end.
+ list1.add(Sessioncodebyidtype.Factory.parse(reader));
+
+ //loop until we find a start element that is not part of this array
+ boolean loopDone1 = false;
+ while(!loopDone1){
+ // We should be at the end element, but make sure
+ while (!reader.isEndElement())
+ reader.next();
+ // Step out of this element
+ reader.next();
+ // Step to next element event.
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+ if (reader.isEndElement()){
+ //two continuous end elements means we are exiting the xml structure
+ loopDone1 = true;
+ } else {
+ if (new javax.xml.namespace.QName("http://www.vitero.de/schema/sessioncode","sessioncode").equals(reader.getName())){
+ list1.add(Sessioncodebyidtype.Factory.parse(reader));
+
+ }else{
+ loopDone1 = true;
+ }
+ }
+ }
+ // call the converter utility to convert and set the array
+
+ object.setSessioncode((Sessioncodebyidtype[])
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToArray(
+ Sessioncodebyidtype.class,
+ list1));
+
+ } // End of if for expected property start element
+
+ else {
+
+ }
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+ if (reader.isStartElement())
+ // A start element we are not expecting indicates a trailing invalid property
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class GetPersonalBookingSessionCodesResponse
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/sessioncode",
+ "getPersonalBookingSessionCodesResponse",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/sessioncode")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for Sessioncode
+ * This was an Array!
+ */
+
+
+ protected Sessioncodebyidtype[] localSessioncode ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localSessioncodeTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return Sessioncodebyidtype[]
+ */
+ public Sessioncodebyidtype[] getSessioncode(){
+ return localSessioncode;
+ }
+
+
+
+
+
+
+ /**
+ * validate the array for Sessioncode
+ */
+ protected void validateSessioncode(Sessioncodebyidtype[] param){
+
+ }
+
+
+ /**
+ * Auto generated setter method
+ * @param param Sessioncode
+ */
+ public void setSessioncode(Sessioncodebyidtype[] param){
+
+ validateSessioncode(param);
+
+
+ if (param != null){
+ //update the setting tracker
+ localSessioncodeTracker = true;
+ } else {
+ localSessioncodeTracker = false;
+
+ }
+
+ this.localSessioncode=param;
+ }
+
+
+
+ /**
+ * Auto generated add method for the array for convenience
+ * @param param Sessioncodebyidtype
+ */
+ public void addSessioncode(Sessioncodebyidtype param){
+ if (localSessioncode == null){
+ localSessioncode = new Sessioncodebyidtype[]{};
+ }
+
+
+ //update the setting tracker
+ localSessioncodeTracker = true;
+
+
+ java.util.List list =
+ org.apache.axis2.databinding.utils.ConverterUtil.toList(localSessioncode);
+ list.add(param);
+ this.localSessioncode =
+ (Sessioncodebyidtype[])list.toArray(
+ new Sessioncodebyidtype[list.size()]);
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ GetPersonalBookingSessionCodesResponse.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/sessioncode");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":getPersonalBookingSessionCodesResponse",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "getPersonalBookingSessionCodesResponse",
+ xmlWriter);
+ }
+
+
+ }
+ if (localSessioncodeTracker){
+ if (localSessioncode!=null){
+ for (int i = 0;i < localSessioncode.length;i++){
+ if (localSessioncode[i] != null){
+ localSessioncode[i].serialize(new javax.xml.namespace.QName("http://www.vitero.de/schema/sessioncode","sessioncode"),
+ factory,xmlWriter);
+ } else {
+
+ // we don't have to do any thing since minOccures is zero
+
+ }
+
+ }
+ } else {
+
+ throw new org.apache.axis2.databinding.ADBException("sessioncode cannot be null!!");
+
+ }
+ }
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+ if (localSessioncodeTracker){
+ if (localSessioncode!=null) {
+ for (int i = 0;i < localSessioncode.length;i++){
+
+ if (localSessioncode[i] != null){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/sessioncode",
+ "sessioncode"));
+ elementList.add(localSessioncode[i]);
+ } else {
+
+ // nothing to do
+
+ }
+
+ }
+ } else {
+
+ throw new org.apache.axis2.databinding.ADBException("sessioncode cannot be null!!");
+
+ }
+
+ }
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static GetPersonalBookingSessionCodesResponse parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ GetPersonalBookingSessionCodesResponse object =
+ new GetPersonalBookingSessionCodesResponse();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"getPersonalBookingSessionCodesResponse".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (GetPersonalBookingSessionCodesResponse)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+ java.util.ArrayList list1 = new java.util.ArrayList();
+
+
+ while (!reader.isStartElement() && !reader.isEndElement()) reader.next();
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/sessioncode","sessioncode").equals(reader.getName())){
+
+
+
+ // Process the array and step past its final element's end.
+ list1.add(Sessioncodebyidtype.Factory.parse(reader));
+
+ //loop until we find a start element that is not part of this array
+ boolean loopDone1 = false;
+ while(!loopDone1){
+ // We should be at the end element, but make sure
+ while (!reader.isEndElement())
+ reader.next();
+ // Step out of this element
+ reader.next();
+ // Step to next element event.
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+ if (reader.isEndElement()){
+ //two continuous end elements means we are exiting the xml structure
+ loopDone1 = true;
+ } else {
+ if (new javax.xml.namespace.QName("http://www.vitero.de/schema/sessioncode","sessioncode").equals(reader.getName())){
+ list1.add(Sessioncodebyidtype.Factory.parse(reader));
+
+ }else{
+ loopDone1 = true;
+ }
+ }
+ }
+ // call the converter utility to convert and set the array
+
+ object.setSessioncode((Sessioncodebyidtype[])
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToArray(
+ Sessioncodebyidtype.class,
+ list1));
+
+ } // End of if for expected property start element
+
+ else {
+
+ }
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+ if (reader.isStartElement())
+ // A start element we are not expecting indicates a trailing invalid property
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class CreatePersonalGroupSessionCodeResponse
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/sessioncode",
+ "createPersonalGroupSessionCodeResponse",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/sessioncode")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for CreatePersonalGroupSessionCodeResponse
+ */
+
+
+ protected Codetype localCreatePersonalGroupSessionCodeResponse ;
+
+
+ /**
+ * Auto generated getter method
+ * @return Codetype
+ */
+ public Codetype getCreatePersonalGroupSessionCodeResponse(){
+ return localCreatePersonalGroupSessionCodeResponse;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param CreatePersonalGroupSessionCodeResponse
+ */
+ public void setCreatePersonalGroupSessionCodeResponse(Codetype param){
+
+ this.localCreatePersonalGroupSessionCodeResponse=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ CreatePersonalGroupSessionCodeResponse.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+ //We can safely assume an element has only one type associated with it
+
+ if (localCreatePersonalGroupSessionCodeResponse==null){
+ throw new org.apache.axis2.databinding.ADBException("Property cannot be null!");
+ }
+ localCreatePersonalGroupSessionCodeResponse.serialize(MY_QNAME,factory,xmlWriter);
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+
+ //We can safely assume an element has only one type associated with it
+ return localCreatePersonalGroupSessionCodeResponse.getPullParser(MY_QNAME);
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static CreatePersonalGroupSessionCodeResponse parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ CreatePersonalGroupSessionCodeResponse object =
+ new CreatePersonalGroupSessionCodeResponse();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/sessioncode","createPersonalGroupSessionCodeResponse").equals(reader.getName())){
+
+ object.setCreatePersonalGroupSessionCodeResponse(Codetype.Factory.parse(reader));
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.SessionCodeServiceStub.CreatePersonalGroupSessionCodeRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.SessionCodeServiceStub.CreatePersonalGroupSessionCodeRequest.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.SessionCodeServiceStub.CreatePersonalGroupSessionCodeResponse param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.SessionCodeServiceStub.CreatePersonalGroupSessionCodeResponse.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.SessionCodeServiceStub.GetSessionCodeInformationRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.SessionCodeServiceStub.GetSessionCodeInformationRequest.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.SessionCodeServiceStub.GetSessionCodeInformationResponse param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.SessionCodeServiceStub.GetSessionCodeInformationResponse.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.SessionCodeServiceStub.SuccessResponse param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.SessionCodeServiceStub.SuccessResponse.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.SessionCodeServiceStub.GetPersonalGroupSessionCodesRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.SessionCodeServiceStub.GetPersonalGroupSessionCodesRequest.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.SessionCodeServiceStub.GetPersonalGroupSessionCodesResponse param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.SessionCodeServiceStub.GetPersonalGroupSessionCodesResponse.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.SessionCodeServiceStub.CreatePersonalBookingSessionCodeRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.SessionCodeServiceStub.CreatePersonalBookingSessionCodeRequest.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.SessionCodeServiceStub.CreatePersonalBookingSessionCodeResponse param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.SessionCodeServiceStub.CreatePersonalBookingSessionCodeResponse.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.SessionCodeServiceStub.GetPersonalBookingSessionCodesRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.SessionCodeServiceStub.GetPersonalBookingSessionCodesRequest.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.SessionCodeServiceStub.GetPersonalBookingSessionCodesResponse param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.SessionCodeServiceStub.GetPersonalBookingSessionCodesResponse.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.SessionCodeServiceStub.DeleteSessionCodeRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.SessionCodeServiceStub.DeleteSessionCodeRequest.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+
+ private org.apache.axiom.soap.SOAPEnvelope toEnvelope(org.apache.axiom.soap.SOAPFactory factory, com.frentix.olat.vitero.manager.stubs.SessionCodeServiceStub.CreatePersonalGroupSessionCodeRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault{
+
+
+ try{
+
+ org.apache.axiom.soap.SOAPEnvelope emptyEnvelope = factory.getDefaultEnvelope();
+ emptyEnvelope.getBody().addChild(param.getOMElement(com.frentix.olat.vitero.manager.stubs.SessionCodeServiceStub.CreatePersonalGroupSessionCodeRequest.MY_QNAME,factory));
+ return emptyEnvelope;
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+
+ /* methods to provide back word compatibility */
+
+
+
+ private org.apache.axiom.soap.SOAPEnvelope toEnvelope(org.apache.axiom.soap.SOAPFactory factory, com.frentix.olat.vitero.manager.stubs.SessionCodeServiceStub.GetSessionCodeInformationRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault{
+
+
+ try{
+
+ org.apache.axiom.soap.SOAPEnvelope emptyEnvelope = factory.getDefaultEnvelope();
+ emptyEnvelope.getBody().addChild(param.getOMElement(com.frentix.olat.vitero.manager.stubs.SessionCodeServiceStub.GetSessionCodeInformationRequest.MY_QNAME,factory));
+ return emptyEnvelope;
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+
+ /* methods to provide back word compatibility */
+
+
+
+ private org.apache.axiom.soap.SOAPEnvelope toEnvelope(org.apache.axiom.soap.SOAPFactory factory, com.frentix.olat.vitero.manager.stubs.SessionCodeServiceStub.GetPersonalGroupSessionCodesRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault{
+
+
+ try{
+
+ org.apache.axiom.soap.SOAPEnvelope emptyEnvelope = factory.getDefaultEnvelope();
+ emptyEnvelope.getBody().addChild(param.getOMElement(com.frentix.olat.vitero.manager.stubs.SessionCodeServiceStub.GetPersonalGroupSessionCodesRequest.MY_QNAME,factory));
+ return emptyEnvelope;
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+
+ /* methods to provide back word compatibility */
+
+
+
+ private org.apache.axiom.soap.SOAPEnvelope toEnvelope(org.apache.axiom.soap.SOAPFactory factory, com.frentix.olat.vitero.manager.stubs.SessionCodeServiceStub.CreatePersonalBookingSessionCodeRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault{
+
+
+ try{
+
+ org.apache.axiom.soap.SOAPEnvelope emptyEnvelope = factory.getDefaultEnvelope();
+ emptyEnvelope.getBody().addChild(param.getOMElement(com.frentix.olat.vitero.manager.stubs.SessionCodeServiceStub.CreatePersonalBookingSessionCodeRequest.MY_QNAME,factory));
+ return emptyEnvelope;
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+
+ /* methods to provide back word compatibility */
+
+
+
+ private org.apache.axiom.soap.SOAPEnvelope toEnvelope(org.apache.axiom.soap.SOAPFactory factory, com.frentix.olat.vitero.manager.stubs.SessionCodeServiceStub.GetPersonalBookingSessionCodesRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault{
+
+
+ try{
+
+ org.apache.axiom.soap.SOAPEnvelope emptyEnvelope = factory.getDefaultEnvelope();
+ emptyEnvelope.getBody().addChild(param.getOMElement(com.frentix.olat.vitero.manager.stubs.SessionCodeServiceStub.GetPersonalBookingSessionCodesRequest.MY_QNAME,factory));
+ return emptyEnvelope;
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+
+ /* methods to provide back word compatibility */
+
+
+
+ private org.apache.axiom.soap.SOAPEnvelope toEnvelope(org.apache.axiom.soap.SOAPFactory factory, com.frentix.olat.vitero.manager.stubs.SessionCodeServiceStub.DeleteSessionCodeRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault{
+
+
+ try{
+
+ org.apache.axiom.soap.SOAPEnvelope emptyEnvelope = factory.getDefaultEnvelope();
+ emptyEnvelope.getBody().addChild(param.getOMElement(com.frentix.olat.vitero.manager.stubs.SessionCodeServiceStub.DeleteSessionCodeRequest.MY_QNAME,factory));
+ return emptyEnvelope;
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+
+ /* methods to provide back word compatibility */
+
+
+
+
+ /**
+ * get the default envelope
+ */
+ private org.apache.axiom.soap.SOAPEnvelope toEnvelope(org.apache.axiom.soap.SOAPFactory factory){
+ return factory.getDefaultEnvelope();
+ }
+
+
+ private java.lang.Object fromOM(
+ org.apache.axiom.om.OMElement param,
+ java.lang.Class type,
+ java.util.Map extraNamespaces) throws org.apache.axis2.AxisFault{
+
+ try {
+
+ if (com.frentix.olat.vitero.manager.stubs.SessionCodeServiceStub.CreatePersonalGroupSessionCodeRequest.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.SessionCodeServiceStub.CreatePersonalGroupSessionCodeRequest.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ if (com.frentix.olat.vitero.manager.stubs.SessionCodeServiceStub.CreatePersonalGroupSessionCodeResponse.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.SessionCodeServiceStub.CreatePersonalGroupSessionCodeResponse.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ if (com.frentix.olat.vitero.manager.stubs.SessionCodeServiceStub.GetSessionCodeInformationRequest.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.SessionCodeServiceStub.GetSessionCodeInformationRequest.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ if (com.frentix.olat.vitero.manager.stubs.SessionCodeServiceStub.GetSessionCodeInformationResponse.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.SessionCodeServiceStub.GetSessionCodeInformationResponse.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ if (com.frentix.olat.vitero.manager.stubs.SessionCodeServiceStub.SuccessResponse.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.SessionCodeServiceStub.SuccessResponse.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ if (com.frentix.olat.vitero.manager.stubs.SessionCodeServiceStub.GetPersonalGroupSessionCodesRequest.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.SessionCodeServiceStub.GetPersonalGroupSessionCodesRequest.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ if (com.frentix.olat.vitero.manager.stubs.SessionCodeServiceStub.GetPersonalGroupSessionCodesResponse.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.SessionCodeServiceStub.GetPersonalGroupSessionCodesResponse.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ if (com.frentix.olat.vitero.manager.stubs.SessionCodeServiceStub.CreatePersonalBookingSessionCodeRequest.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.SessionCodeServiceStub.CreatePersonalBookingSessionCodeRequest.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ if (com.frentix.olat.vitero.manager.stubs.SessionCodeServiceStub.CreatePersonalBookingSessionCodeResponse.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.SessionCodeServiceStub.CreatePersonalBookingSessionCodeResponse.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ if (com.frentix.olat.vitero.manager.stubs.SessionCodeServiceStub.GetPersonalBookingSessionCodesRequest.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.SessionCodeServiceStub.GetPersonalBookingSessionCodesRequest.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ if (com.frentix.olat.vitero.manager.stubs.SessionCodeServiceStub.GetPersonalBookingSessionCodesResponse.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.SessionCodeServiceStub.GetPersonalBookingSessionCodesResponse.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ if (com.frentix.olat.vitero.manager.stubs.SessionCodeServiceStub.DeleteSessionCodeRequest.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.SessionCodeServiceStub.DeleteSessionCodeRequest.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ } catch (java.lang.Exception e) {
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+ return null;
+ }
+
+
+
+
+ }
+
\ No newline at end of file
diff --git a/src/main/java/com/frentix/olat/vitero/manager/stubs/UserServiceCallbackHandler.java b/src/main/java/com/frentix/olat/vitero/manager/stubs/UserServiceCallbackHandler.java
new file mode 100644
index 0000000000000000000000000000000000000000..ac4c083c5cf187d86a2d19d1aa620b15f5afcf21
--- /dev/null
+++ b/src/main/java/com/frentix/olat/vitero/manager/stubs/UserServiceCallbackHandler.java
@@ -0,0 +1,170 @@
+
+/**
+ * UserServiceCallbackHandler.java
+ *
+ * This file was auto-generated from WSDL
+ * by the Apache Axis2 version: 1.4.1 Built on : Aug 13, 2008 (05:03:35 LKT)
+ */
+
+ package com.frentix.olat.vitero.manager.stubs;
+
+ /**
+ * UserServiceCallbackHandler Callback class, Users can extend this class and implement
+ * their own receiveResult and receiveError methods.
+ */
+ public abstract class UserServiceCallbackHandler{
+
+
+
+ protected Object clientData;
+
+ /**
+ * User can pass in any object that needs to be accessed once the NonBlocking
+ * Web service call is finished and appropriate method of this CallBack is called.
+ * @param clientData Object mechanism by which the user can pass in user data
+ * that will be avilable at the time this callback is called.
+ */
+ public UserServiceCallbackHandler(Object clientData){
+ this.clientData = clientData;
+ }
+
+ /**
+ * Please use this constructor if you don't want to set any clientData
+ */
+ public UserServiceCallbackHandler(){
+ this.clientData = null;
+ }
+
+ /**
+ * Get the client data
+ */
+
+ public Object getClientData() {
+ return clientData;
+ }
+
+
+ // No methods generated for meps other than in-out
+
+ /**
+ * auto generated Axis2 call back method for getUserList method
+ * override this method for handling normal response from getUserList operation
+ */
+ public void receiveResultgetUserList(
+ com.frentix.olat.vitero.manager.stubs.UserServiceStub.GetUserListResponse result
+ ) {
+ }
+
+ /**
+ * auto generated Axis2 Error handler
+ * override this method for handling error response from getUserList operation
+ */
+ public void receiveErrorgetUserList(java.lang.Exception e) {
+ }
+
+ /**
+ * auto generated Axis2 call back method for getUserListByGroup method
+ * override this method for handling normal response from getUserListByGroup operation
+ */
+ public void receiveResultgetUserListByGroup(
+ com.frentix.olat.vitero.manager.stubs.UserServiceStub.GetUserListByGroupResponse result
+ ) {
+ }
+
+ /**
+ * auto generated Axis2 Error handler
+ * override this method for handling error response from getUserListByGroup operation
+ */
+ public void receiveErrorgetUserListByGroup(java.lang.Exception e) {
+ }
+
+ /**
+ * auto generated Axis2 call back method for getUserListByPosition method
+ * override this method for handling normal response from getUserListByPosition operation
+ */
+ public void receiveResultgetUserListByPosition(
+ com.frentix.olat.vitero.manager.stubs.UserServiceStub.GetUserListByPositionResponse result
+ ) {
+ }
+
+ /**
+ * auto generated Axis2 Error handler
+ * override this method for handling error response from getUserListByPosition operation
+ */
+ public void receiveErrorgetUserListByPosition(java.lang.Exception e) {
+ }
+
+ // No methods generated for meps other than in-out
+
+ // No methods generated for meps other than in-out
+
+ /**
+ * auto generated Axis2 call back method for createUser method
+ * override this method for handling normal response from createUser operation
+ */
+ public void receiveResultcreateUser(
+ com.frentix.olat.vitero.manager.stubs.UserServiceStub.CreateUserResponse result
+ ) {
+ }
+
+ /**
+ * auto generated Axis2 Error handler
+ * override this method for handling error response from createUser operation
+ */
+ public void receiveErrorcreateUser(java.lang.Exception e) {
+ }
+
+ /**
+ * auto generated Axis2 call back method for getUser method
+ * override this method for handling normal response from getUser operation
+ */
+ public void receiveResultgetUser(
+ com.frentix.olat.vitero.manager.stubs.UserServiceStub.GetUserResponse result
+ ) {
+ }
+
+ /**
+ * auto generated Axis2 Error handler
+ * override this method for handling error response from getUser operation
+ */
+ public void receiveErrorgetUser(java.lang.Exception e) {
+ }
+
+ /**
+ * auto generated Axis2 call back method for getUserCount method
+ * override this method for handling normal response from getUserCount operation
+ */
+ public void receiveResultgetUserCount(
+ com.frentix.olat.vitero.manager.stubs.UserServiceStub.GetUserCountResponse result
+ ) {
+ }
+
+ /**
+ * auto generated Axis2 Error handler
+ * override this method for handling error response from getUserCount operation
+ */
+ public void receiveErrorgetUserCount(java.lang.Exception e) {
+ }
+
+ /**
+ * auto generated Axis2 call back method for getUserListByCustomer method
+ * override this method for handling normal response from getUserListByCustomer operation
+ */
+ public void receiveResultgetUserListByCustomer(
+ com.frentix.olat.vitero.manager.stubs.UserServiceStub.GetUserListByCustomerResponse result
+ ) {
+ }
+
+ /**
+ * auto generated Axis2 Error handler
+ * override this method for handling error response from getUserListByCustomer operation
+ */
+ public void receiveErrorgetUserListByCustomer(java.lang.Exception e) {
+ }
+
+ // No methods generated for meps other than in-out
+
+
+
+ }
+
\ No newline at end of file
diff --git a/src/main/java/com/frentix/olat/vitero/manager/stubs/UserServiceStub.java b/src/main/java/com/frentix/olat/vitero/manager/stubs/UserServiceStub.java
new file mode 100644
index 0000000000000000000000000000000000000000..2ad1f562f42f18960588b63b422f13b21c47c56c
--- /dev/null
+++ b/src/main/java/com/frentix/olat/vitero/manager/stubs/UserServiceStub.java
@@ -0,0 +1,20212 @@
+
+/**
+ * UserServiceStub.java
+ *
+ * This file was auto-generated from WSDL
+ * by the Apache Axis2 version: 1.4.1 Built on : Aug 13, 2008 (05:03:35 LKT)
+ */
+ package com.frentix.olat.vitero.manager.stubs;
+
+
+
+ /*
+ * UserServiceStub java implementation
+ */
+
+
+ public class UserServiceStub extends org.apache.axis2.client.Stub
+ {
+ protected org.apache.axis2.description.AxisOperation[] _operations;
+
+ //hashmaps to keep the fault mapping
+ private java.util.HashMap faultExceptionNameMap = new java.util.HashMap();
+ private java.util.HashMap faultExceptionClassNameMap = new java.util.HashMap();
+ private java.util.HashMap faultMessageMap = new java.util.HashMap();
+
+ private static int counter = 0;
+
+ private static synchronized String getUniqueSuffix(){
+ // reset the counter if it is greater than 99999
+ if (counter > 99999){
+ counter = 0;
+ }
+ counter = counter + 1;
+ return Long.toString(System.currentTimeMillis()) + "_" + counter;
+ }
+
+
+ private void populateAxisService() throws org.apache.axis2.AxisFault {
+
+ //creating the Service with a unique name
+ _service = new org.apache.axis2.description.AxisService("UserService" + getUniqueSuffix());
+ addAnonymousOperations();
+
+ //creating the operations
+ org.apache.axis2.description.AxisOperation __operation;
+
+ _operations = new org.apache.axis2.description.AxisOperation[11];
+
+ __operation = new org.apache.axis2.description.OutOnlyAxisOperation();
+
+
+ __operation.setName(new javax.xml.namespace.QName("http://www.vitero.de/schema/user", "deleteUser"));
+ _service.addOperation(__operation);
+
+
+
+
+ _operations[0]=__operation;
+
+
+ __operation = new org.apache.axis2.description.OutInAxisOperation();
+
+
+ __operation.setName(new javax.xml.namespace.QName("http://www.vitero.de/schema/user", "getUserList"));
+ _service.addOperation(__operation);
+
+
+
+
+ _operations[1]=__operation;
+
+
+ __operation = new org.apache.axis2.description.OutInAxisOperation();
+
+
+ __operation.setName(new javax.xml.namespace.QName("http://www.vitero.de/schema/user", "getUserListByGroup"));
+ _service.addOperation(__operation);
+
+
+
+
+ _operations[2]=__operation;
+
+
+ __operation = new org.apache.axis2.description.OutInAxisOperation();
+
+
+ __operation.setName(new javax.xml.namespace.QName("http://www.vitero.de/schema/user", "getUserListByPosition"));
+ _service.addOperation(__operation);
+
+
+
+
+ _operations[3]=__operation;
+
+
+ __operation = new org.apache.axis2.description.OutOnlyAxisOperation();
+
+
+ __operation.setName(new javax.xml.namespace.QName("http://www.vitero.de/schema/user", "updateUser"));
+ _service.addOperation(__operation);
+
+
+
+
+ _operations[4]=__operation;
+
+
+ __operation = new org.apache.axis2.description.OutInAxisOperation();
+
+
+ __operation.setName(new javax.xml.namespace.QName("http://www.vitero.de/schema/user", "success"));
+ _service.addOperation(__operation);
+
+
+
+
+ _operations[5]=__operation;
+
+
+ __operation = new org.apache.axis2.description.OutInAxisOperation();
+
+
+ __operation.setName(new javax.xml.namespace.QName("http://www.vitero.de/schema/user", "createUser"));
+ _service.addOperation(__operation);
+
+
+
+
+ _operations[6]=__operation;
+
+
+ __operation = new org.apache.axis2.description.OutInAxisOperation();
+
+
+ __operation.setName(new javax.xml.namespace.QName("http://www.vitero.de/schema/user", "getUser"));
+ _service.addOperation(__operation);
+
+
+
+
+ _operations[7]=__operation;
+
+
+ __operation = new org.apache.axis2.description.OutInAxisOperation();
+
+
+ __operation.setName(new javax.xml.namespace.QName("http://www.vitero.de/schema/user", "getUserCount"));
+ _service.addOperation(__operation);
+
+
+
+
+ _operations[8]=__operation;
+
+
+ __operation = new org.apache.axis2.description.OutInAxisOperation();
+
+
+ __operation.setName(new javax.xml.namespace.QName("http://www.vitero.de/schema/user", "getUserListByCustomer"));
+ _service.addOperation(__operation);
+
+
+
+
+ _operations[9]=__operation;
+
+
+ __operation = new org.apache.axis2.description.OutOnlyAxisOperation();
+
+
+ __operation.setName(new javax.xml.namespace.QName("http://www.vitero.de/schema/user", "changePassword"));
+ _service.addOperation(__operation);
+
+
+
+
+ _operations[10]=__operation;
+
+
+ }
+
+ //populates the faults
+ private void populateFaults(){
+
+
+
+ }
+
+ /**
+ *Constructor that takes in a configContext
+ */
+
+ public UserServiceStub(org.apache.axis2.context.ConfigurationContext configurationContext,
+ java.lang.String targetEndpoint)
+ throws org.apache.axis2.AxisFault {
+ this(configurationContext,targetEndpoint,false);
+ }
+
+
+ /**
+ * Constructor that takes in a configContext and useseperate listner
+ */
+ public UserServiceStub(org.apache.axis2.context.ConfigurationContext configurationContext,
+ java.lang.String targetEndpoint, boolean useSeparateListener)
+ throws org.apache.axis2.AxisFault {
+ //To populate AxisService
+ populateAxisService();
+ populateFaults();
+
+ _serviceClient = new org.apache.axis2.client.ServiceClient(configurationContext,_service);
+
+
+ configurationContext = _serviceClient.getServiceContext().getConfigurationContext();
+
+ _serviceClient.getOptions().setTo(new org.apache.axis2.addressing.EndpointReference(
+ targetEndpoint));
+ _serviceClient.getOptions().setUseSeparateListener(useSeparateListener);
+
+
+ }
+
+ /**
+ * Default Constructor
+ */
+ public UserServiceStub(org.apache.axis2.context.ConfigurationContext configurationContext) throws org.apache.axis2.AxisFault {
+
+ this(configurationContext,"http://192.168.1.54:8080/vitero/services/" );
+
+ }
+
+ /**
+ * Default Constructor
+ */
+ public UserServiceStub() throws org.apache.axis2.AxisFault {
+
+ this("http://192.168.1.54:8080/vitero/services/" );
+
+ }
+
+ /**
+ * Constructor taking the target endpoint
+ */
+ public UserServiceStub(java.lang.String targetEndpoint) throws org.apache.axis2.AxisFault {
+ this(null,targetEndpoint);
+ }
+
+
+
+
+
+ /**
+ * Auto generated method signature
+ *
+ */
+ public void deleteUser(
+ com.frentix.olat.vitero.manager.stubs.UserServiceStub.DeleteUserRequest deleteUserRequest0
+
+ ) throws java.rmi.RemoteException
+
+
+ {
+ org.apache.axis2.context.MessageContext _messageContext = null;
+
+
+ org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[0].getName());
+ _operationClient.getOptions().setAction("\"\"");
+ _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true);
+
+
+
+ addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&");
+
+ org.apache.axiom.soap.SOAPEnvelope env = null;
+ _messageContext = new org.apache.axis2.context.MessageContext();
+
+
+ //Style is Doc.
+
+
+ env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()),
+ deleteUserRequest0,
+ optimizeContent(new javax.xml.namespace.QName("http://www.vitero.de/schema/user",
+ "deleteUser")));
+
+
+ //adding SOAP soap_headers
+ _serviceClient.addHeadersToEnvelope(env);
+ // create message context with that soap envelope
+
+ _messageContext.setEnvelope(env);
+
+ // add the message contxt to the operation client
+ _operationClient.addMessageContext(_messageContext);
+
+ _operationClient.execute(true);
+
+
+ _messageContext.getTransportOut().getSender().cleanup(_messageContext);
+
+ return;
+ }
+
+ /**
+ * Auto generated method signature
+ *
+ * @see com.frentix.olat.vc.provider.vitero.stubs.UserService#getUserList
+ * @param getUserListRequest1
+
+ */
+
+
+
+ public com.frentix.olat.vitero.manager.stubs.UserServiceStub.GetUserListResponse getUserList(
+
+ com.frentix.olat.vitero.manager.stubs.UserServiceStub.GetUserListRequest getUserListRequest1)
+
+
+ throws java.rmi.RemoteException
+
+ {
+ org.apache.axis2.context.MessageContext _messageContext = null;
+ try{
+ org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[1].getName());
+ _operationClient.getOptions().setAction("\"\"");
+ _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true);
+
+
+
+ addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&");
+
+
+ // create a message context
+ _messageContext = new org.apache.axis2.context.MessageContext();
+
+
+
+ // create SOAP envelope with that payload
+ org.apache.axiom.soap.SOAPEnvelope env = null;
+
+
+ env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()),
+ getUserListRequest1,
+ optimizeContent(new javax.xml.namespace.QName("http://www.vitero.de/schema/user",
+ "getUserList")));
+
+ //adding SOAP soap_headers
+ _serviceClient.addHeadersToEnvelope(env);
+ // set the message context with that soap envelope
+ _messageContext.setEnvelope(env);
+
+ // add the message contxt to the operation client
+ _operationClient.addMessageContext(_messageContext);
+
+ //execute the operation client
+ _operationClient.execute(true);
+
+
+ org.apache.axis2.context.MessageContext _returnMessageContext = _operationClient.getMessageContext(
+ org.apache.axis2.wsdl.WSDLConstants.MESSAGE_LABEL_IN_VALUE);
+ org.apache.axiom.soap.SOAPEnvelope _returnEnv = _returnMessageContext.getEnvelope();
+
+
+ java.lang.Object object = fromOM(
+ _returnEnv.getBody().getFirstElement() ,
+ com.frentix.olat.vitero.manager.stubs.UserServiceStub.GetUserListResponse.class,
+ getEnvelopeNamespaces(_returnEnv));
+
+
+ return (com.frentix.olat.vitero.manager.stubs.UserServiceStub.GetUserListResponse)object;
+
+ }catch(org.apache.axis2.AxisFault f){
+
+ org.apache.axiom.om.OMElement faultElt = f.getDetail();
+ if (faultElt!=null){
+ if (faultExceptionNameMap.containsKey(faultElt.getQName())){
+ //make the fault by reflection
+ try{
+ java.lang.String exceptionClassName = (java.lang.String)faultExceptionClassNameMap.get(faultElt.getQName());
+ java.lang.Class exceptionClass = java.lang.Class.forName(exceptionClassName);
+ java.lang.Exception ex=
+ (java.lang.Exception) exceptionClass.newInstance();
+ //message class
+ java.lang.String messageClassName = (java.lang.String)faultMessageMap.get(faultElt.getQName());
+ java.lang.Class messageClass = java.lang.Class.forName(messageClassName);
+ java.lang.Object messageObject = fromOM(faultElt,messageClass,null);
+ java.lang.reflect.Method m = exceptionClass.getMethod("setFaultMessage",
+ new java.lang.Class[]{messageClass});
+ m.invoke(ex,new java.lang.Object[]{messageObject});
+
+
+ throw new java.rmi.RemoteException(ex.getMessage(), ex);
+ }catch(java.lang.ClassCastException e){
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.ClassNotFoundException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ }catch (java.lang.NoSuchMethodException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.reflect.InvocationTargetException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.IllegalAccessException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.InstantiationException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ }
+ }else{
+ throw f;
+ }
+ }else{
+ throw f;
+ }
+ } finally {
+ _messageContext.getTransportOut().getSender().cleanup(_messageContext);
+ }
+ }
+
+ /**
+ * Auto generated method signature for Asynchronous Invocations
+ *
+ * @see com.frentix.olat.vc.provider.vitero.stubs.UserService#startgetUserList
+ * @param getUserListRequest1
+
+ */
+ public void startgetUserList(
+
+ com.frentix.olat.vitero.manager.stubs.UserServiceStub.GetUserListRequest getUserListRequest1,
+
+ final com.frentix.olat.vitero.manager.stubs.UserServiceCallbackHandler callback)
+
+ throws java.rmi.RemoteException{
+
+ org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[1].getName());
+ _operationClient.getOptions().setAction("\"\"");
+ _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true);
+
+
+
+ addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&");
+
+
+
+ // create SOAP envelope with that payload
+ org.apache.axiom.soap.SOAPEnvelope env=null;
+ final org.apache.axis2.context.MessageContext _messageContext = new org.apache.axis2.context.MessageContext();
+
+
+ //Style is Doc.
+
+
+ env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()),
+ getUserListRequest1,
+ optimizeContent(new javax.xml.namespace.QName("http://www.vitero.de/schema/user",
+ "getUserList")));
+
+ // adding SOAP soap_headers
+ _serviceClient.addHeadersToEnvelope(env);
+ // create message context with that soap envelope
+ _messageContext.setEnvelope(env);
+
+ // add the message context to the operation client
+ _operationClient.addMessageContext(_messageContext);
+
+
+
+ _operationClient.setCallback(new org.apache.axis2.client.async.AxisCallback() {
+ public void onMessage(org.apache.axis2.context.MessageContext resultContext) {
+ try {
+ org.apache.axiom.soap.SOAPEnvelope resultEnv = resultContext.getEnvelope();
+
+ java.lang.Object object = fromOM(resultEnv.getBody().getFirstElement(),
+ com.frentix.olat.vitero.manager.stubs.UserServiceStub.GetUserListResponse.class,
+ getEnvelopeNamespaces(resultEnv));
+ callback.receiveResultgetUserList(
+ (com.frentix.olat.vitero.manager.stubs.UserServiceStub.GetUserListResponse)object);
+
+ } catch (org.apache.axis2.AxisFault e) {
+ callback.receiveErrorgetUserList(e);
+ }
+ }
+
+ public void onError(java.lang.Exception error) {
+ if (error instanceof org.apache.axis2.AxisFault) {
+ org.apache.axis2.AxisFault f = (org.apache.axis2.AxisFault) error;
+ org.apache.axiom.om.OMElement faultElt = f.getDetail();
+ if (faultElt!=null){
+ if (faultExceptionNameMap.containsKey(faultElt.getQName())){
+ //make the fault by reflection
+ try{
+ java.lang.String exceptionClassName = (java.lang.String)faultExceptionClassNameMap.get(faultElt.getQName());
+ java.lang.Class exceptionClass = java.lang.Class.forName(exceptionClassName);
+ java.lang.Exception ex=
+ (java.lang.Exception) exceptionClass.newInstance();
+ //message class
+ java.lang.String messageClassName = (java.lang.String)faultMessageMap.get(faultElt.getQName());
+ java.lang.Class messageClass = java.lang.Class.forName(messageClassName);
+ java.lang.Object messageObject = fromOM(faultElt,messageClass,null);
+ java.lang.reflect.Method m = exceptionClass.getMethod("setFaultMessage",
+ new java.lang.Class[]{messageClass});
+ m.invoke(ex,new java.lang.Object[]{messageObject});
+
+
+ callback.receiveErrorgetUserList(new java.rmi.RemoteException(ex.getMessage(), ex));
+ } catch(java.lang.ClassCastException e){
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetUserList(f);
+ } catch (java.lang.ClassNotFoundException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetUserList(f);
+ } catch (java.lang.NoSuchMethodException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetUserList(f);
+ } catch (java.lang.reflect.InvocationTargetException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetUserList(f);
+ } catch (java.lang.IllegalAccessException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetUserList(f);
+ } catch (java.lang.InstantiationException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetUserList(f);
+ } catch (org.apache.axis2.AxisFault e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetUserList(f);
+ }
+ } else {
+ callback.receiveErrorgetUserList(f);
+ }
+ } else {
+ callback.receiveErrorgetUserList(f);
+ }
+ } else {
+ callback.receiveErrorgetUserList(error);
+ }
+ }
+
+ public void onFault(org.apache.axis2.context.MessageContext faultContext) {
+ org.apache.axis2.AxisFault fault = org.apache.axis2.util.Utils.getInboundFaultFromMessageContext(faultContext);
+ onError(fault);
+ }
+
+ public void onComplete() {
+ try {
+ _messageContext.getTransportOut().getSender().cleanup(_messageContext);
+ } catch (org.apache.axis2.AxisFault axisFault) {
+ callback.receiveErrorgetUserList(axisFault);
+ }
+ }
+ });
+
+
+ org.apache.axis2.util.CallbackReceiver _callbackReceiver = null;
+ if ( _operations[1].getMessageReceiver()==null && _operationClient.getOptions().isUseSeparateListener()) {
+ _callbackReceiver = new org.apache.axis2.util.CallbackReceiver();
+ _operations[1].setMessageReceiver(
+ _callbackReceiver);
+ }
+
+ //execute the operation client
+ _operationClient.execute(false);
+
+ }
+
+ /**
+ * Auto generated method signature
+ *
+ * @see com.frentix.olat.vc.provider.vitero.stubs.UserService#getUserListByGroup
+ * @param getUserListByGroupRequest3
+
+ */
+
+
+
+ public com.frentix.olat.vitero.manager.stubs.UserServiceStub.GetUserListByGroupResponse getUserListByGroup(
+
+ com.frentix.olat.vitero.manager.stubs.UserServiceStub.GetUserListByGroupRequest getUserListByGroupRequest3)
+
+
+ throws java.rmi.RemoteException
+
+ {
+ org.apache.axis2.context.MessageContext _messageContext = null;
+ try{
+ org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[2].getName());
+ _operationClient.getOptions().setAction("\"\"");
+ _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true);
+
+
+
+ addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&");
+
+
+ // create a message context
+ _messageContext = new org.apache.axis2.context.MessageContext();
+
+
+
+ // create SOAP envelope with that payload
+ org.apache.axiom.soap.SOAPEnvelope env = null;
+
+
+ env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()),
+ getUserListByGroupRequest3,
+ optimizeContent(new javax.xml.namespace.QName("http://www.vitero.de/schema/user",
+ "getUserListByGroup")));
+
+ //adding SOAP soap_headers
+ _serviceClient.addHeadersToEnvelope(env);
+ // set the message context with that soap envelope
+ _messageContext.setEnvelope(env);
+
+ // add the message contxt to the operation client
+ _operationClient.addMessageContext(_messageContext);
+
+ //execute the operation client
+ _operationClient.execute(true);
+
+
+ org.apache.axis2.context.MessageContext _returnMessageContext = _operationClient.getMessageContext(
+ org.apache.axis2.wsdl.WSDLConstants.MESSAGE_LABEL_IN_VALUE);
+ org.apache.axiom.soap.SOAPEnvelope _returnEnv = _returnMessageContext.getEnvelope();
+
+
+ java.lang.Object object = fromOM(
+ _returnEnv.getBody().getFirstElement() ,
+ com.frentix.olat.vitero.manager.stubs.UserServiceStub.GetUserListByGroupResponse.class,
+ getEnvelopeNamespaces(_returnEnv));
+
+
+ return (com.frentix.olat.vitero.manager.stubs.UserServiceStub.GetUserListByGroupResponse)object;
+
+ }catch(org.apache.axis2.AxisFault f){
+
+ org.apache.axiom.om.OMElement faultElt = f.getDetail();
+ if (faultElt!=null){
+ if (faultExceptionNameMap.containsKey(faultElt.getQName())){
+ //make the fault by reflection
+ try{
+ java.lang.String exceptionClassName = (java.lang.String)faultExceptionClassNameMap.get(faultElt.getQName());
+ java.lang.Class exceptionClass = java.lang.Class.forName(exceptionClassName);
+ java.lang.Exception ex=
+ (java.lang.Exception) exceptionClass.newInstance();
+ //message class
+ java.lang.String messageClassName = (java.lang.String)faultMessageMap.get(faultElt.getQName());
+ java.lang.Class messageClass = java.lang.Class.forName(messageClassName);
+ java.lang.Object messageObject = fromOM(faultElt,messageClass,null);
+ java.lang.reflect.Method m = exceptionClass.getMethod("setFaultMessage",
+ new java.lang.Class[]{messageClass});
+ m.invoke(ex,new java.lang.Object[]{messageObject});
+
+
+ throw new java.rmi.RemoteException(ex.getMessage(), ex);
+ }catch(java.lang.ClassCastException e){
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.ClassNotFoundException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ }catch (java.lang.NoSuchMethodException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.reflect.InvocationTargetException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.IllegalAccessException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.InstantiationException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ }
+ }else{
+ throw f;
+ }
+ }else{
+ throw f;
+ }
+ } finally {
+ _messageContext.getTransportOut().getSender().cleanup(_messageContext);
+ }
+ }
+
+ /**
+ * Auto generated method signature for Asynchronous Invocations
+ *
+ * @see com.frentix.olat.vc.provider.vitero.stubs.UserService#startgetUserListByGroup
+ * @param getUserListByGroupRequest3
+
+ */
+ public void startgetUserListByGroup(
+
+ com.frentix.olat.vitero.manager.stubs.UserServiceStub.GetUserListByGroupRequest getUserListByGroupRequest3,
+
+ final com.frentix.olat.vitero.manager.stubs.UserServiceCallbackHandler callback)
+
+ throws java.rmi.RemoteException{
+
+ org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[2].getName());
+ _operationClient.getOptions().setAction("\"\"");
+ _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true);
+
+
+
+ addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&");
+
+
+
+ // create SOAP envelope with that payload
+ org.apache.axiom.soap.SOAPEnvelope env=null;
+ final org.apache.axis2.context.MessageContext _messageContext = new org.apache.axis2.context.MessageContext();
+
+
+ //Style is Doc.
+
+
+ env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()),
+ getUserListByGroupRequest3,
+ optimizeContent(new javax.xml.namespace.QName("http://www.vitero.de/schema/user",
+ "getUserListByGroup")));
+
+ // adding SOAP soap_headers
+ _serviceClient.addHeadersToEnvelope(env);
+ // create message context with that soap envelope
+ _messageContext.setEnvelope(env);
+
+ // add the message context to the operation client
+ _operationClient.addMessageContext(_messageContext);
+
+
+
+ _operationClient.setCallback(new org.apache.axis2.client.async.AxisCallback() {
+ public void onMessage(org.apache.axis2.context.MessageContext resultContext) {
+ try {
+ org.apache.axiom.soap.SOAPEnvelope resultEnv = resultContext.getEnvelope();
+
+ java.lang.Object object = fromOM(resultEnv.getBody().getFirstElement(),
+ com.frentix.olat.vitero.manager.stubs.UserServiceStub.GetUserListByGroupResponse.class,
+ getEnvelopeNamespaces(resultEnv));
+ callback.receiveResultgetUserListByGroup(
+ (com.frentix.olat.vitero.manager.stubs.UserServiceStub.GetUserListByGroupResponse)object);
+
+ } catch (org.apache.axis2.AxisFault e) {
+ callback.receiveErrorgetUserListByGroup(e);
+ }
+ }
+
+ public void onError(java.lang.Exception error) {
+ if (error instanceof org.apache.axis2.AxisFault) {
+ org.apache.axis2.AxisFault f = (org.apache.axis2.AxisFault) error;
+ org.apache.axiom.om.OMElement faultElt = f.getDetail();
+ if (faultElt!=null){
+ if (faultExceptionNameMap.containsKey(faultElt.getQName())){
+ //make the fault by reflection
+ try{
+ java.lang.String exceptionClassName = (java.lang.String)faultExceptionClassNameMap.get(faultElt.getQName());
+ java.lang.Class exceptionClass = java.lang.Class.forName(exceptionClassName);
+ java.lang.Exception ex=
+ (java.lang.Exception) exceptionClass.newInstance();
+ //message class
+ java.lang.String messageClassName = (java.lang.String)faultMessageMap.get(faultElt.getQName());
+ java.lang.Class messageClass = java.lang.Class.forName(messageClassName);
+ java.lang.Object messageObject = fromOM(faultElt,messageClass,null);
+ java.lang.reflect.Method m = exceptionClass.getMethod("setFaultMessage",
+ new java.lang.Class[]{messageClass});
+ m.invoke(ex,new java.lang.Object[]{messageObject});
+
+
+ callback.receiveErrorgetUserListByGroup(new java.rmi.RemoteException(ex.getMessage(), ex));
+ } catch(java.lang.ClassCastException e){
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetUserListByGroup(f);
+ } catch (java.lang.ClassNotFoundException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetUserListByGroup(f);
+ } catch (java.lang.NoSuchMethodException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetUserListByGroup(f);
+ } catch (java.lang.reflect.InvocationTargetException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetUserListByGroup(f);
+ } catch (java.lang.IllegalAccessException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetUserListByGroup(f);
+ } catch (java.lang.InstantiationException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetUserListByGroup(f);
+ } catch (org.apache.axis2.AxisFault e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetUserListByGroup(f);
+ }
+ } else {
+ callback.receiveErrorgetUserListByGroup(f);
+ }
+ } else {
+ callback.receiveErrorgetUserListByGroup(f);
+ }
+ } else {
+ callback.receiveErrorgetUserListByGroup(error);
+ }
+ }
+
+ public void onFault(org.apache.axis2.context.MessageContext faultContext) {
+ org.apache.axis2.AxisFault fault = org.apache.axis2.util.Utils.getInboundFaultFromMessageContext(faultContext);
+ onError(fault);
+ }
+
+ public void onComplete() {
+ try {
+ _messageContext.getTransportOut().getSender().cleanup(_messageContext);
+ } catch (org.apache.axis2.AxisFault axisFault) {
+ callback.receiveErrorgetUserListByGroup(axisFault);
+ }
+ }
+ });
+
+
+ org.apache.axis2.util.CallbackReceiver _callbackReceiver = null;
+ if ( _operations[2].getMessageReceiver()==null && _operationClient.getOptions().isUseSeparateListener()) {
+ _callbackReceiver = new org.apache.axis2.util.CallbackReceiver();
+ _operations[2].setMessageReceiver(
+ _callbackReceiver);
+ }
+
+ //execute the operation client
+ _operationClient.execute(false);
+
+ }
+
+ /**
+ * Auto generated method signature
+ *
+ * @see com.frentix.olat.vc.provider.vitero.stubs.UserService#getUserListByPosition
+ * @param getUserListByPositionRequest5
+
+ */
+
+
+
+ public com.frentix.olat.vitero.manager.stubs.UserServiceStub.GetUserListByPositionResponse getUserListByPosition(
+
+ com.frentix.olat.vitero.manager.stubs.UserServiceStub.GetUserListByPositionRequest getUserListByPositionRequest5)
+
+
+ throws java.rmi.RemoteException
+
+ {
+ org.apache.axis2.context.MessageContext _messageContext = null;
+ try{
+ org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[3].getName());
+ _operationClient.getOptions().setAction("\"\"");
+ _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true);
+
+
+
+ addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&");
+
+
+ // create a message context
+ _messageContext = new org.apache.axis2.context.MessageContext();
+
+
+
+ // create SOAP envelope with that payload
+ org.apache.axiom.soap.SOAPEnvelope env = null;
+
+
+ env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()),
+ getUserListByPositionRequest5,
+ optimizeContent(new javax.xml.namespace.QName("http://www.vitero.de/schema/user",
+ "getUserListByPosition")));
+
+ //adding SOAP soap_headers
+ _serviceClient.addHeadersToEnvelope(env);
+ // set the message context with that soap envelope
+ _messageContext.setEnvelope(env);
+
+ // add the message contxt to the operation client
+ _operationClient.addMessageContext(_messageContext);
+
+ //execute the operation client
+ _operationClient.execute(true);
+
+
+ org.apache.axis2.context.MessageContext _returnMessageContext = _operationClient.getMessageContext(
+ org.apache.axis2.wsdl.WSDLConstants.MESSAGE_LABEL_IN_VALUE);
+ org.apache.axiom.soap.SOAPEnvelope _returnEnv = _returnMessageContext.getEnvelope();
+
+
+ java.lang.Object object = fromOM(
+ _returnEnv.getBody().getFirstElement() ,
+ com.frentix.olat.vitero.manager.stubs.UserServiceStub.GetUserListByPositionResponse.class,
+ getEnvelopeNamespaces(_returnEnv));
+
+
+ return (com.frentix.olat.vitero.manager.stubs.UserServiceStub.GetUserListByPositionResponse)object;
+
+ }catch(org.apache.axis2.AxisFault f){
+
+ org.apache.axiom.om.OMElement faultElt = f.getDetail();
+ if (faultElt!=null){
+ if (faultExceptionNameMap.containsKey(faultElt.getQName())){
+ //make the fault by reflection
+ try{
+ java.lang.String exceptionClassName = (java.lang.String)faultExceptionClassNameMap.get(faultElt.getQName());
+ java.lang.Class exceptionClass = java.lang.Class.forName(exceptionClassName);
+ java.lang.Exception ex=
+ (java.lang.Exception) exceptionClass.newInstance();
+ //message class
+ java.lang.String messageClassName = (java.lang.String)faultMessageMap.get(faultElt.getQName());
+ java.lang.Class messageClass = java.lang.Class.forName(messageClassName);
+ java.lang.Object messageObject = fromOM(faultElt,messageClass,null);
+ java.lang.reflect.Method m = exceptionClass.getMethod("setFaultMessage",
+ new java.lang.Class[]{messageClass});
+ m.invoke(ex,new java.lang.Object[]{messageObject});
+
+
+ throw new java.rmi.RemoteException(ex.getMessage(), ex);
+ }catch(java.lang.ClassCastException e){
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.ClassNotFoundException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ }catch (java.lang.NoSuchMethodException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.reflect.InvocationTargetException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.IllegalAccessException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.InstantiationException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ }
+ }else{
+ throw f;
+ }
+ }else{
+ throw f;
+ }
+ } finally {
+ _messageContext.getTransportOut().getSender().cleanup(_messageContext);
+ }
+ }
+
+ /**
+ * Auto generated method signature for Asynchronous Invocations
+ *
+ * @see com.frentix.olat.vc.provider.vitero.stubs.UserService#startgetUserListByPosition
+ * @param getUserListByPositionRequest5
+
+ */
+ public void startgetUserListByPosition(
+
+ com.frentix.olat.vitero.manager.stubs.UserServiceStub.GetUserListByPositionRequest getUserListByPositionRequest5,
+
+ final com.frentix.olat.vitero.manager.stubs.UserServiceCallbackHandler callback)
+
+ throws java.rmi.RemoteException{
+
+ org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[3].getName());
+ _operationClient.getOptions().setAction("\"\"");
+ _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true);
+
+
+
+ addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&");
+
+
+
+ // create SOAP envelope with that payload
+ org.apache.axiom.soap.SOAPEnvelope env=null;
+ final org.apache.axis2.context.MessageContext _messageContext = new org.apache.axis2.context.MessageContext();
+
+
+ //Style is Doc.
+
+
+ env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()),
+ getUserListByPositionRequest5,
+ optimizeContent(new javax.xml.namespace.QName("http://www.vitero.de/schema/user",
+ "getUserListByPosition")));
+
+ // adding SOAP soap_headers
+ _serviceClient.addHeadersToEnvelope(env);
+ // create message context with that soap envelope
+ _messageContext.setEnvelope(env);
+
+ // add the message context to the operation client
+ _operationClient.addMessageContext(_messageContext);
+
+
+
+ _operationClient.setCallback(new org.apache.axis2.client.async.AxisCallback() {
+ public void onMessage(org.apache.axis2.context.MessageContext resultContext) {
+ try {
+ org.apache.axiom.soap.SOAPEnvelope resultEnv = resultContext.getEnvelope();
+
+ java.lang.Object object = fromOM(resultEnv.getBody().getFirstElement(),
+ com.frentix.olat.vitero.manager.stubs.UserServiceStub.GetUserListByPositionResponse.class,
+ getEnvelopeNamespaces(resultEnv));
+ callback.receiveResultgetUserListByPosition(
+ (com.frentix.olat.vitero.manager.stubs.UserServiceStub.GetUserListByPositionResponse)object);
+
+ } catch (org.apache.axis2.AxisFault e) {
+ callback.receiveErrorgetUserListByPosition(e);
+ }
+ }
+
+ public void onError(java.lang.Exception error) {
+ if (error instanceof org.apache.axis2.AxisFault) {
+ org.apache.axis2.AxisFault f = (org.apache.axis2.AxisFault) error;
+ org.apache.axiom.om.OMElement faultElt = f.getDetail();
+ if (faultElt!=null){
+ if (faultExceptionNameMap.containsKey(faultElt.getQName())){
+ //make the fault by reflection
+ try{
+ java.lang.String exceptionClassName = (java.lang.String)faultExceptionClassNameMap.get(faultElt.getQName());
+ java.lang.Class exceptionClass = java.lang.Class.forName(exceptionClassName);
+ java.lang.Exception ex=
+ (java.lang.Exception) exceptionClass.newInstance();
+ //message class
+ java.lang.String messageClassName = (java.lang.String)faultMessageMap.get(faultElt.getQName());
+ java.lang.Class messageClass = java.lang.Class.forName(messageClassName);
+ java.lang.Object messageObject = fromOM(faultElt,messageClass,null);
+ java.lang.reflect.Method m = exceptionClass.getMethod("setFaultMessage",
+ new java.lang.Class[]{messageClass});
+ m.invoke(ex,new java.lang.Object[]{messageObject});
+
+
+ callback.receiveErrorgetUserListByPosition(new java.rmi.RemoteException(ex.getMessage(), ex));
+ } catch(java.lang.ClassCastException e){
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetUserListByPosition(f);
+ } catch (java.lang.ClassNotFoundException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetUserListByPosition(f);
+ } catch (java.lang.NoSuchMethodException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetUserListByPosition(f);
+ } catch (java.lang.reflect.InvocationTargetException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetUserListByPosition(f);
+ } catch (java.lang.IllegalAccessException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetUserListByPosition(f);
+ } catch (java.lang.InstantiationException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetUserListByPosition(f);
+ } catch (org.apache.axis2.AxisFault e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetUserListByPosition(f);
+ }
+ } else {
+ callback.receiveErrorgetUserListByPosition(f);
+ }
+ } else {
+ callback.receiveErrorgetUserListByPosition(f);
+ }
+ } else {
+ callback.receiveErrorgetUserListByPosition(error);
+ }
+ }
+
+ public void onFault(org.apache.axis2.context.MessageContext faultContext) {
+ org.apache.axis2.AxisFault fault = org.apache.axis2.util.Utils.getInboundFaultFromMessageContext(faultContext);
+ onError(fault);
+ }
+
+ public void onComplete() {
+ try {
+ _messageContext.getTransportOut().getSender().cleanup(_messageContext);
+ } catch (org.apache.axis2.AxisFault axisFault) {
+ callback.receiveErrorgetUserListByPosition(axisFault);
+ }
+ }
+ });
+
+
+ org.apache.axis2.util.CallbackReceiver _callbackReceiver = null;
+ if ( _operations[3].getMessageReceiver()==null && _operationClient.getOptions().isUseSeparateListener()) {
+ _callbackReceiver = new org.apache.axis2.util.CallbackReceiver();
+ _operations[3].setMessageReceiver(
+ _callbackReceiver);
+ }
+
+ //execute the operation client
+ _operationClient.execute(false);
+
+ }
+
+
+ /**
+ * Auto generated method signature
+ *
+ */
+ public void updateUser(
+ com.frentix.olat.vitero.manager.stubs.UserServiceStub.UpdateUserRequest updateUserRequest7
+
+ ) throws java.rmi.RemoteException
+
+
+ {
+ org.apache.axis2.context.MessageContext _messageContext = null;
+
+
+ org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[4].getName());
+ _operationClient.getOptions().setAction("\"\"");
+ _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true);
+
+
+
+ addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&");
+
+ org.apache.axiom.soap.SOAPEnvelope env = null;
+ _messageContext = new org.apache.axis2.context.MessageContext();
+
+
+ //Style is Doc.
+
+
+ env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()),
+ updateUserRequest7,
+ optimizeContent(new javax.xml.namespace.QName("http://www.vitero.de/schema/user",
+ "updateUser")));
+
+
+ //adding SOAP soap_headers
+ _serviceClient.addHeadersToEnvelope(env);
+ // create message context with that soap envelope
+
+ _messageContext.setEnvelope(env);
+
+ // add the message contxt to the operation client
+ _operationClient.addMessageContext(_messageContext);
+
+ _operationClient.execute(true);
+
+
+ _messageContext.getTransportOut().getSender().cleanup(_messageContext);
+
+ return;
+ }
+
+ /**
+ * Auto generated method signature
+ *
+ * @see com.frentix.olat.vc.provider.vitero.stubs.UserService#createUser
+ * @param createUserRequest9
+
+ */
+
+
+
+ public com.frentix.olat.vitero.manager.stubs.UserServiceStub.CreateUserResponse createUser(
+
+ com.frentix.olat.vitero.manager.stubs.UserServiceStub.CreateUserRequest createUserRequest9)
+
+
+ throws java.rmi.RemoteException
+
+ {
+ org.apache.axis2.context.MessageContext _messageContext = null;
+ try{
+ org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[6].getName());
+ _operationClient.getOptions().setAction("\"\"");
+ _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true);
+
+
+
+ addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&");
+
+
+ // create a message context
+ _messageContext = new org.apache.axis2.context.MessageContext();
+
+
+
+ // create SOAP envelope with that payload
+ org.apache.axiom.soap.SOAPEnvelope env = null;
+
+
+ env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()),
+ createUserRequest9,
+ optimizeContent(new javax.xml.namespace.QName("http://www.vitero.de/schema/user",
+ "createUser")));
+
+ //adding SOAP soap_headers
+ _serviceClient.addHeadersToEnvelope(env);
+ // set the message context with that soap envelope
+ _messageContext.setEnvelope(env);
+
+ // add the message contxt to the operation client
+ _operationClient.addMessageContext(_messageContext);
+
+ //execute the operation client
+ _operationClient.execute(true);
+
+
+ org.apache.axis2.context.MessageContext _returnMessageContext = _operationClient.getMessageContext(
+ org.apache.axis2.wsdl.WSDLConstants.MESSAGE_LABEL_IN_VALUE);
+ org.apache.axiom.soap.SOAPEnvelope _returnEnv = _returnMessageContext.getEnvelope();
+
+
+ java.lang.Object object = fromOM(
+ _returnEnv.getBody().getFirstElement() ,
+ com.frentix.olat.vitero.manager.stubs.UserServiceStub.CreateUserResponse.class,
+ getEnvelopeNamespaces(_returnEnv));
+
+
+ return (com.frentix.olat.vitero.manager.stubs.UserServiceStub.CreateUserResponse)object;
+
+ }catch(org.apache.axis2.AxisFault f){
+
+ org.apache.axiom.om.OMElement faultElt = f.getDetail();
+ if (faultElt!=null){
+ if (faultExceptionNameMap.containsKey(faultElt.getQName())){
+ //make the fault by reflection
+ try{
+ java.lang.String exceptionClassName = (java.lang.String)faultExceptionClassNameMap.get(faultElt.getQName());
+ java.lang.Class exceptionClass = java.lang.Class.forName(exceptionClassName);
+ java.lang.Exception ex=
+ (java.lang.Exception) exceptionClass.newInstance();
+ //message class
+ java.lang.String messageClassName = (java.lang.String)faultMessageMap.get(faultElt.getQName());
+ java.lang.Class messageClass = java.lang.Class.forName(messageClassName);
+ java.lang.Object messageObject = fromOM(faultElt,messageClass,null);
+ java.lang.reflect.Method m = exceptionClass.getMethod("setFaultMessage",
+ new java.lang.Class[]{messageClass});
+ m.invoke(ex,new java.lang.Object[]{messageObject});
+
+
+ throw new java.rmi.RemoteException(ex.getMessage(), ex);
+ }catch(java.lang.ClassCastException e){
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.ClassNotFoundException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ }catch (java.lang.NoSuchMethodException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.reflect.InvocationTargetException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.IllegalAccessException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.InstantiationException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ }
+ }else{
+ throw f;
+ }
+ }else{
+ throw f;
+ }
+ } finally {
+ _messageContext.getTransportOut().getSender().cleanup(_messageContext);
+ }
+ }
+
+ /**
+ * Auto generated method signature for Asynchronous Invocations
+ *
+ * @see com.frentix.olat.vc.provider.vitero.stubs.UserService#startcreateUser
+ * @param createUserRequest9
+
+ */
+ public void startcreateUser(
+
+ com.frentix.olat.vitero.manager.stubs.UserServiceStub.CreateUserRequest createUserRequest9,
+
+ final com.frentix.olat.vitero.manager.stubs.UserServiceCallbackHandler callback)
+
+ throws java.rmi.RemoteException{
+
+ org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[6].getName());
+ _operationClient.getOptions().setAction("\"\"");
+ _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true);
+
+
+
+ addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&");
+
+
+
+ // create SOAP envelope with that payload
+ org.apache.axiom.soap.SOAPEnvelope env=null;
+ final org.apache.axis2.context.MessageContext _messageContext = new org.apache.axis2.context.MessageContext();
+
+
+ //Style is Doc.
+
+
+ env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()),
+ createUserRequest9,
+ optimizeContent(new javax.xml.namespace.QName("http://www.vitero.de/schema/user",
+ "createUser")));
+
+ // adding SOAP soap_headers
+ _serviceClient.addHeadersToEnvelope(env);
+ // create message context with that soap envelope
+ _messageContext.setEnvelope(env);
+
+ // add the message context to the operation client
+ _operationClient.addMessageContext(_messageContext);
+
+
+
+ _operationClient.setCallback(new org.apache.axis2.client.async.AxisCallback() {
+ public void onMessage(org.apache.axis2.context.MessageContext resultContext) {
+ try {
+ org.apache.axiom.soap.SOAPEnvelope resultEnv = resultContext.getEnvelope();
+
+ java.lang.Object object = fromOM(resultEnv.getBody().getFirstElement(),
+ com.frentix.olat.vitero.manager.stubs.UserServiceStub.CreateUserResponse.class,
+ getEnvelopeNamespaces(resultEnv));
+ callback.receiveResultcreateUser(
+ (com.frentix.olat.vitero.manager.stubs.UserServiceStub.CreateUserResponse)object);
+
+ } catch (org.apache.axis2.AxisFault e) {
+ callback.receiveErrorcreateUser(e);
+ }
+ }
+
+ public void onError(java.lang.Exception error) {
+ if (error instanceof org.apache.axis2.AxisFault) {
+ org.apache.axis2.AxisFault f = (org.apache.axis2.AxisFault) error;
+ org.apache.axiom.om.OMElement faultElt = f.getDetail();
+ if (faultElt!=null){
+ if (faultExceptionNameMap.containsKey(faultElt.getQName())){
+ //make the fault by reflection
+ try{
+ java.lang.String exceptionClassName = (java.lang.String)faultExceptionClassNameMap.get(faultElt.getQName());
+ java.lang.Class exceptionClass = java.lang.Class.forName(exceptionClassName);
+ java.lang.Exception ex=
+ (java.lang.Exception) exceptionClass.newInstance();
+ //message class
+ java.lang.String messageClassName = (java.lang.String)faultMessageMap.get(faultElt.getQName());
+ java.lang.Class messageClass = java.lang.Class.forName(messageClassName);
+ java.lang.Object messageObject = fromOM(faultElt,messageClass,null);
+ java.lang.reflect.Method m = exceptionClass.getMethod("setFaultMessage",
+ new java.lang.Class[]{messageClass});
+ m.invoke(ex,new java.lang.Object[]{messageObject});
+
+
+ callback.receiveErrorcreateUser(new java.rmi.RemoteException(ex.getMessage(), ex));
+ } catch(java.lang.ClassCastException e){
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorcreateUser(f);
+ } catch (java.lang.ClassNotFoundException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorcreateUser(f);
+ } catch (java.lang.NoSuchMethodException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorcreateUser(f);
+ } catch (java.lang.reflect.InvocationTargetException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorcreateUser(f);
+ } catch (java.lang.IllegalAccessException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorcreateUser(f);
+ } catch (java.lang.InstantiationException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorcreateUser(f);
+ } catch (org.apache.axis2.AxisFault e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorcreateUser(f);
+ }
+ } else {
+ callback.receiveErrorcreateUser(f);
+ }
+ } else {
+ callback.receiveErrorcreateUser(f);
+ }
+ } else {
+ callback.receiveErrorcreateUser(error);
+ }
+ }
+
+ public void onFault(org.apache.axis2.context.MessageContext faultContext) {
+ org.apache.axis2.AxisFault fault = org.apache.axis2.util.Utils.getInboundFaultFromMessageContext(faultContext);
+ onError(fault);
+ }
+
+ public void onComplete() {
+ try {
+ _messageContext.getTransportOut().getSender().cleanup(_messageContext);
+ } catch (org.apache.axis2.AxisFault axisFault) {
+ callback.receiveErrorcreateUser(axisFault);
+ }
+ }
+ });
+
+
+ org.apache.axis2.util.CallbackReceiver _callbackReceiver = null;
+ if ( _operations[6].getMessageReceiver()==null && _operationClient.getOptions().isUseSeparateListener()) {
+ _callbackReceiver = new org.apache.axis2.util.CallbackReceiver();
+ _operations[6].setMessageReceiver(
+ _callbackReceiver);
+ }
+
+ //execute the operation client
+ _operationClient.execute(false);
+
+ }
+
+ /**
+ * Auto generated method signature
+ *
+ * @see com.frentix.olat.vc.provider.vitero.stubs.UserService#getUser
+ * @param getUserRequest11
+
+ */
+
+
+
+ public com.frentix.olat.vitero.manager.stubs.UserServiceStub.GetUserResponse getUser(
+
+ com.frentix.olat.vitero.manager.stubs.UserServiceStub.GetUserRequest getUserRequest11)
+
+
+ throws java.rmi.RemoteException
+
+ {
+ org.apache.axis2.context.MessageContext _messageContext = null;
+ try{
+ org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[7].getName());
+ _operationClient.getOptions().setAction("\"\"");
+ _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true);
+
+
+
+ addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&");
+
+
+ // create a message context
+ _messageContext = new org.apache.axis2.context.MessageContext();
+
+
+
+ // create SOAP envelope with that payload
+ org.apache.axiom.soap.SOAPEnvelope env = null;
+
+
+ env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()),
+ getUserRequest11,
+ optimizeContent(new javax.xml.namespace.QName("http://www.vitero.de/schema/user",
+ "getUser")));
+
+ //adding SOAP soap_headers
+ _serviceClient.addHeadersToEnvelope(env);
+ // set the message context with that soap envelope
+ _messageContext.setEnvelope(env);
+
+ // add the message contxt to the operation client
+ _operationClient.addMessageContext(_messageContext);
+
+ //execute the operation client
+ _operationClient.execute(true);
+
+
+ org.apache.axis2.context.MessageContext _returnMessageContext = _operationClient.getMessageContext(
+ org.apache.axis2.wsdl.WSDLConstants.MESSAGE_LABEL_IN_VALUE);
+ org.apache.axiom.soap.SOAPEnvelope _returnEnv = _returnMessageContext.getEnvelope();
+
+
+ java.lang.Object object = fromOM(
+ _returnEnv.getBody().getFirstElement() ,
+ com.frentix.olat.vitero.manager.stubs.UserServiceStub.GetUserResponse.class,
+ getEnvelopeNamespaces(_returnEnv));
+
+
+ return (com.frentix.olat.vitero.manager.stubs.UserServiceStub.GetUserResponse)object;
+
+ }catch(org.apache.axis2.AxisFault f){
+
+ org.apache.axiom.om.OMElement faultElt = f.getDetail();
+ if (faultElt!=null){
+ if (faultExceptionNameMap.containsKey(faultElt.getQName())){
+ //make the fault by reflection
+ try{
+ java.lang.String exceptionClassName = (java.lang.String)faultExceptionClassNameMap.get(faultElt.getQName());
+ java.lang.Class exceptionClass = java.lang.Class.forName(exceptionClassName);
+ java.lang.Exception ex=
+ (java.lang.Exception) exceptionClass.newInstance();
+ //message class
+ java.lang.String messageClassName = (java.lang.String)faultMessageMap.get(faultElt.getQName());
+ java.lang.Class messageClass = java.lang.Class.forName(messageClassName);
+ java.lang.Object messageObject = fromOM(faultElt,messageClass,null);
+ java.lang.reflect.Method m = exceptionClass.getMethod("setFaultMessage",
+ new java.lang.Class[]{messageClass});
+ m.invoke(ex,new java.lang.Object[]{messageObject});
+
+
+ throw new java.rmi.RemoteException(ex.getMessage(), ex);
+ }catch(java.lang.ClassCastException e){
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.ClassNotFoundException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ }catch (java.lang.NoSuchMethodException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.reflect.InvocationTargetException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.IllegalAccessException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.InstantiationException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ }
+ }else{
+ throw f;
+ }
+ }else{
+ throw f;
+ }
+ } finally {
+ _messageContext.getTransportOut().getSender().cleanup(_messageContext);
+ }
+ }
+
+ /**
+ * Auto generated method signature for Asynchronous Invocations
+ *
+ * @see com.frentix.olat.vc.provider.vitero.stubs.UserService#startgetUser
+ * @param getUserRequest11
+
+ */
+ public void startgetUser(
+
+ com.frentix.olat.vitero.manager.stubs.UserServiceStub.GetUserRequest getUserRequest11,
+
+ final com.frentix.olat.vitero.manager.stubs.UserServiceCallbackHandler callback)
+
+ throws java.rmi.RemoteException{
+
+ org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[7].getName());
+ _operationClient.getOptions().setAction("\"\"");
+ _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true);
+
+
+
+ addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&");
+
+
+
+ // create SOAP envelope with that payload
+ org.apache.axiom.soap.SOAPEnvelope env=null;
+ final org.apache.axis2.context.MessageContext _messageContext = new org.apache.axis2.context.MessageContext();
+
+
+ //Style is Doc.
+
+
+ env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()),
+ getUserRequest11,
+ optimizeContent(new javax.xml.namespace.QName("http://www.vitero.de/schema/user",
+ "getUser")));
+
+ // adding SOAP soap_headers
+ _serviceClient.addHeadersToEnvelope(env);
+ // create message context with that soap envelope
+ _messageContext.setEnvelope(env);
+
+ // add the message context to the operation client
+ _operationClient.addMessageContext(_messageContext);
+
+
+
+ _operationClient.setCallback(new org.apache.axis2.client.async.AxisCallback() {
+ public void onMessage(org.apache.axis2.context.MessageContext resultContext) {
+ try {
+ org.apache.axiom.soap.SOAPEnvelope resultEnv = resultContext.getEnvelope();
+
+ java.lang.Object object = fromOM(resultEnv.getBody().getFirstElement(),
+ com.frentix.olat.vitero.manager.stubs.UserServiceStub.GetUserResponse.class,
+ getEnvelopeNamespaces(resultEnv));
+ callback.receiveResultgetUser(
+ (com.frentix.olat.vitero.manager.stubs.UserServiceStub.GetUserResponse)object);
+
+ } catch (org.apache.axis2.AxisFault e) {
+ callback.receiveErrorgetUser(e);
+ }
+ }
+
+ public void onError(java.lang.Exception error) {
+ if (error instanceof org.apache.axis2.AxisFault) {
+ org.apache.axis2.AxisFault f = (org.apache.axis2.AxisFault) error;
+ org.apache.axiom.om.OMElement faultElt = f.getDetail();
+ if (faultElt!=null){
+ if (faultExceptionNameMap.containsKey(faultElt.getQName())){
+ //make the fault by reflection
+ try{
+ java.lang.String exceptionClassName = (java.lang.String)faultExceptionClassNameMap.get(faultElt.getQName());
+ java.lang.Class exceptionClass = java.lang.Class.forName(exceptionClassName);
+ java.lang.Exception ex=
+ (java.lang.Exception) exceptionClass.newInstance();
+ //message class
+ java.lang.String messageClassName = (java.lang.String)faultMessageMap.get(faultElt.getQName());
+ java.lang.Class messageClass = java.lang.Class.forName(messageClassName);
+ java.lang.Object messageObject = fromOM(faultElt,messageClass,null);
+ java.lang.reflect.Method m = exceptionClass.getMethod("setFaultMessage",
+ new java.lang.Class[]{messageClass});
+ m.invoke(ex,new java.lang.Object[]{messageObject});
+
+
+ callback.receiveErrorgetUser(new java.rmi.RemoteException(ex.getMessage(), ex));
+ } catch(java.lang.ClassCastException e){
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetUser(f);
+ } catch (java.lang.ClassNotFoundException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetUser(f);
+ } catch (java.lang.NoSuchMethodException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetUser(f);
+ } catch (java.lang.reflect.InvocationTargetException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetUser(f);
+ } catch (java.lang.IllegalAccessException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetUser(f);
+ } catch (java.lang.InstantiationException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetUser(f);
+ } catch (org.apache.axis2.AxisFault e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetUser(f);
+ }
+ } else {
+ callback.receiveErrorgetUser(f);
+ }
+ } else {
+ callback.receiveErrorgetUser(f);
+ }
+ } else {
+ callback.receiveErrorgetUser(error);
+ }
+ }
+
+ public void onFault(org.apache.axis2.context.MessageContext faultContext) {
+ org.apache.axis2.AxisFault fault = org.apache.axis2.util.Utils.getInboundFaultFromMessageContext(faultContext);
+ onError(fault);
+ }
+
+ public void onComplete() {
+ try {
+ _messageContext.getTransportOut().getSender().cleanup(_messageContext);
+ } catch (org.apache.axis2.AxisFault axisFault) {
+ callback.receiveErrorgetUser(axisFault);
+ }
+ }
+ });
+
+
+ org.apache.axis2.util.CallbackReceiver _callbackReceiver = null;
+ if ( _operations[7].getMessageReceiver()==null && _operationClient.getOptions().isUseSeparateListener()) {
+ _callbackReceiver = new org.apache.axis2.util.CallbackReceiver();
+ _operations[7].setMessageReceiver(
+ _callbackReceiver);
+ }
+
+ //execute the operation client
+ _operationClient.execute(false);
+
+ }
+
+ /**
+ * Auto generated method signature
+ *
+ * @see com.frentix.olat.vc.provider.vitero.stubs.UserService#getUserCount
+ * @param getUserCountRequest13
+
+ */
+
+
+
+ public com.frentix.olat.vitero.manager.stubs.UserServiceStub.GetUserCountResponse getUserCount(
+
+ com.frentix.olat.vitero.manager.stubs.UserServiceStub.GetUserCountRequest getUserCountRequest13)
+
+
+ throws java.rmi.RemoteException
+
+ {
+ org.apache.axis2.context.MessageContext _messageContext = null;
+ try{
+ org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[8].getName());
+ _operationClient.getOptions().setAction("\"\"");
+ _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true);
+
+
+
+ addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&");
+
+
+ // create a message context
+ _messageContext = new org.apache.axis2.context.MessageContext();
+
+
+
+ // create SOAP envelope with that payload
+ org.apache.axiom.soap.SOAPEnvelope env = null;
+
+
+ env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()),
+ getUserCountRequest13,
+ optimizeContent(new javax.xml.namespace.QName("http://www.vitero.de/schema/user",
+ "getUserCount")));
+
+ //adding SOAP soap_headers
+ _serviceClient.addHeadersToEnvelope(env);
+ // set the message context with that soap envelope
+ _messageContext.setEnvelope(env);
+
+ // add the message contxt to the operation client
+ _operationClient.addMessageContext(_messageContext);
+
+ //execute the operation client
+ _operationClient.execute(true);
+
+
+ org.apache.axis2.context.MessageContext _returnMessageContext = _operationClient.getMessageContext(
+ org.apache.axis2.wsdl.WSDLConstants.MESSAGE_LABEL_IN_VALUE);
+ org.apache.axiom.soap.SOAPEnvelope _returnEnv = _returnMessageContext.getEnvelope();
+
+
+ java.lang.Object object = fromOM(
+ _returnEnv.getBody().getFirstElement() ,
+ com.frentix.olat.vitero.manager.stubs.UserServiceStub.GetUserCountResponse.class,
+ getEnvelopeNamespaces(_returnEnv));
+
+
+ return (com.frentix.olat.vitero.manager.stubs.UserServiceStub.GetUserCountResponse)object;
+
+ }catch(org.apache.axis2.AxisFault f){
+
+ org.apache.axiom.om.OMElement faultElt = f.getDetail();
+ if (faultElt!=null){
+ if (faultExceptionNameMap.containsKey(faultElt.getQName())){
+ //make the fault by reflection
+ try{
+ java.lang.String exceptionClassName = (java.lang.String)faultExceptionClassNameMap.get(faultElt.getQName());
+ java.lang.Class exceptionClass = java.lang.Class.forName(exceptionClassName);
+ java.lang.Exception ex=
+ (java.lang.Exception) exceptionClass.newInstance();
+ //message class
+ java.lang.String messageClassName = (java.lang.String)faultMessageMap.get(faultElt.getQName());
+ java.lang.Class messageClass = java.lang.Class.forName(messageClassName);
+ java.lang.Object messageObject = fromOM(faultElt,messageClass,null);
+ java.lang.reflect.Method m = exceptionClass.getMethod("setFaultMessage",
+ new java.lang.Class[]{messageClass});
+ m.invoke(ex,new java.lang.Object[]{messageObject});
+
+
+ throw new java.rmi.RemoteException(ex.getMessage(), ex);
+ }catch(java.lang.ClassCastException e){
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.ClassNotFoundException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ }catch (java.lang.NoSuchMethodException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.reflect.InvocationTargetException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.IllegalAccessException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.InstantiationException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ }
+ }else{
+ throw f;
+ }
+ }else{
+ throw f;
+ }
+ } finally {
+ _messageContext.getTransportOut().getSender().cleanup(_messageContext);
+ }
+ }
+
+ /**
+ * Auto generated method signature for Asynchronous Invocations
+ *
+ * @see com.frentix.olat.vc.provider.vitero.stubs.UserService#startgetUserCount
+ * @param getUserCountRequest13
+
+ */
+ public void startgetUserCount(
+
+ com.frentix.olat.vitero.manager.stubs.UserServiceStub.GetUserCountRequest getUserCountRequest13,
+
+ final com.frentix.olat.vitero.manager.stubs.UserServiceCallbackHandler callback)
+
+ throws java.rmi.RemoteException{
+
+ org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[8].getName());
+ _operationClient.getOptions().setAction("\"\"");
+ _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true);
+
+
+
+ addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&");
+
+
+
+ // create SOAP envelope with that payload
+ org.apache.axiom.soap.SOAPEnvelope env=null;
+ final org.apache.axis2.context.MessageContext _messageContext = new org.apache.axis2.context.MessageContext();
+
+
+ //Style is Doc.
+
+
+ env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()),
+ getUserCountRequest13,
+ optimizeContent(new javax.xml.namespace.QName("http://www.vitero.de/schema/user",
+ "getUserCount")));
+
+ // adding SOAP soap_headers
+ _serviceClient.addHeadersToEnvelope(env);
+ // create message context with that soap envelope
+ _messageContext.setEnvelope(env);
+
+ // add the message context to the operation client
+ _operationClient.addMessageContext(_messageContext);
+
+
+
+ _operationClient.setCallback(new org.apache.axis2.client.async.AxisCallback() {
+ public void onMessage(org.apache.axis2.context.MessageContext resultContext) {
+ try {
+ org.apache.axiom.soap.SOAPEnvelope resultEnv = resultContext.getEnvelope();
+
+ java.lang.Object object = fromOM(resultEnv.getBody().getFirstElement(),
+ com.frentix.olat.vitero.manager.stubs.UserServiceStub.GetUserCountResponse.class,
+ getEnvelopeNamespaces(resultEnv));
+ callback.receiveResultgetUserCount(
+ (com.frentix.olat.vitero.manager.stubs.UserServiceStub.GetUserCountResponse)object);
+
+ } catch (org.apache.axis2.AxisFault e) {
+ callback.receiveErrorgetUserCount(e);
+ }
+ }
+
+ public void onError(java.lang.Exception error) {
+ if (error instanceof org.apache.axis2.AxisFault) {
+ org.apache.axis2.AxisFault f = (org.apache.axis2.AxisFault) error;
+ org.apache.axiom.om.OMElement faultElt = f.getDetail();
+ if (faultElt!=null){
+ if (faultExceptionNameMap.containsKey(faultElt.getQName())){
+ //make the fault by reflection
+ try{
+ java.lang.String exceptionClassName = (java.lang.String)faultExceptionClassNameMap.get(faultElt.getQName());
+ java.lang.Class exceptionClass = java.lang.Class.forName(exceptionClassName);
+ java.lang.Exception ex=
+ (java.lang.Exception) exceptionClass.newInstance();
+ //message class
+ java.lang.String messageClassName = (java.lang.String)faultMessageMap.get(faultElt.getQName());
+ java.lang.Class messageClass = java.lang.Class.forName(messageClassName);
+ java.lang.Object messageObject = fromOM(faultElt,messageClass,null);
+ java.lang.reflect.Method m = exceptionClass.getMethod("setFaultMessage",
+ new java.lang.Class[]{messageClass});
+ m.invoke(ex,new java.lang.Object[]{messageObject});
+
+
+ callback.receiveErrorgetUserCount(new java.rmi.RemoteException(ex.getMessage(), ex));
+ } catch(java.lang.ClassCastException e){
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetUserCount(f);
+ } catch (java.lang.ClassNotFoundException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetUserCount(f);
+ } catch (java.lang.NoSuchMethodException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetUserCount(f);
+ } catch (java.lang.reflect.InvocationTargetException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetUserCount(f);
+ } catch (java.lang.IllegalAccessException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetUserCount(f);
+ } catch (java.lang.InstantiationException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetUserCount(f);
+ } catch (org.apache.axis2.AxisFault e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetUserCount(f);
+ }
+ } else {
+ callback.receiveErrorgetUserCount(f);
+ }
+ } else {
+ callback.receiveErrorgetUserCount(f);
+ }
+ } else {
+ callback.receiveErrorgetUserCount(error);
+ }
+ }
+
+ public void onFault(org.apache.axis2.context.MessageContext faultContext) {
+ org.apache.axis2.AxisFault fault = org.apache.axis2.util.Utils.getInboundFaultFromMessageContext(faultContext);
+ onError(fault);
+ }
+
+ public void onComplete() {
+ try {
+ _messageContext.getTransportOut().getSender().cleanup(_messageContext);
+ } catch (org.apache.axis2.AxisFault axisFault) {
+ callback.receiveErrorgetUserCount(axisFault);
+ }
+ }
+ });
+
+
+ org.apache.axis2.util.CallbackReceiver _callbackReceiver = null;
+ if ( _operations[8].getMessageReceiver()==null && _operationClient.getOptions().isUseSeparateListener()) {
+ _callbackReceiver = new org.apache.axis2.util.CallbackReceiver();
+ _operations[8].setMessageReceiver(
+ _callbackReceiver);
+ }
+
+ //execute the operation client
+ _operationClient.execute(false);
+
+ }
+
+ /**
+ * Auto generated method signature
+ *
+ * @see com.frentix.olat.vc.provider.vitero.stubs.UserService#getUserListByCustomer
+ * @param getUserListByCustomerRequest15
+
+ */
+
+
+
+ public com.frentix.olat.vitero.manager.stubs.UserServiceStub.GetUserListByCustomerResponse getUserListByCustomer(
+
+ com.frentix.olat.vitero.manager.stubs.UserServiceStub.GetUserListByCustomerRequest getUserListByCustomerRequest15)
+
+
+ throws java.rmi.RemoteException
+
+ {
+ org.apache.axis2.context.MessageContext _messageContext = null;
+ try{
+ org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[9].getName());
+ _operationClient.getOptions().setAction("\"\"");
+ _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true);
+
+
+
+ addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&");
+
+
+ // create a message context
+ _messageContext = new org.apache.axis2.context.MessageContext();
+
+
+
+ // create SOAP envelope with that payload
+ org.apache.axiom.soap.SOAPEnvelope env = null;
+
+
+ env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()),
+ getUserListByCustomerRequest15,
+ optimizeContent(new javax.xml.namespace.QName("http://www.vitero.de/schema/user",
+ "getUserListByCustomer")));
+
+ //adding SOAP soap_headers
+ _serviceClient.addHeadersToEnvelope(env);
+ // set the message context with that soap envelope
+ _messageContext.setEnvelope(env);
+
+ // add the message contxt to the operation client
+ _operationClient.addMessageContext(_messageContext);
+
+ //execute the operation client
+ _operationClient.execute(true);
+
+
+ org.apache.axis2.context.MessageContext _returnMessageContext = _operationClient.getMessageContext(
+ org.apache.axis2.wsdl.WSDLConstants.MESSAGE_LABEL_IN_VALUE);
+ org.apache.axiom.soap.SOAPEnvelope _returnEnv = _returnMessageContext.getEnvelope();
+
+
+ java.lang.Object object = fromOM(
+ _returnEnv.getBody().getFirstElement() ,
+ com.frentix.olat.vitero.manager.stubs.UserServiceStub.GetUserListByCustomerResponse.class,
+ getEnvelopeNamespaces(_returnEnv));
+
+
+ return (com.frentix.olat.vitero.manager.stubs.UserServiceStub.GetUserListByCustomerResponse)object;
+
+ }catch(org.apache.axis2.AxisFault f){
+
+ org.apache.axiom.om.OMElement faultElt = f.getDetail();
+ if (faultElt!=null){
+ if (faultExceptionNameMap.containsKey(faultElt.getQName())){
+ //make the fault by reflection
+ try{
+ java.lang.String exceptionClassName = (java.lang.String)faultExceptionClassNameMap.get(faultElt.getQName());
+ java.lang.Class exceptionClass = java.lang.Class.forName(exceptionClassName);
+ java.lang.Exception ex=
+ (java.lang.Exception) exceptionClass.newInstance();
+ //message class
+ java.lang.String messageClassName = (java.lang.String)faultMessageMap.get(faultElt.getQName());
+ java.lang.Class messageClass = java.lang.Class.forName(messageClassName);
+ java.lang.Object messageObject = fromOM(faultElt,messageClass,null);
+ java.lang.reflect.Method m = exceptionClass.getMethod("setFaultMessage",
+ new java.lang.Class[]{messageClass});
+ m.invoke(ex,new java.lang.Object[]{messageObject});
+
+
+ throw new java.rmi.RemoteException(ex.getMessage(), ex);
+ }catch(java.lang.ClassCastException e){
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.ClassNotFoundException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ }catch (java.lang.NoSuchMethodException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.reflect.InvocationTargetException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.IllegalAccessException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ } catch (java.lang.InstantiationException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ throw f;
+ }
+ }else{
+ throw f;
+ }
+ }else{
+ throw f;
+ }
+ } finally {
+ _messageContext.getTransportOut().getSender().cleanup(_messageContext);
+ }
+ }
+
+ /**
+ * Auto generated method signature for Asynchronous Invocations
+ *
+ * @see com.frentix.olat.vc.provider.vitero.stubs.UserService#startgetUserListByCustomer
+ * @param getUserListByCustomerRequest15
+
+ */
+ public void startgetUserListByCustomer(
+
+ com.frentix.olat.vitero.manager.stubs.UserServiceStub.GetUserListByCustomerRequest getUserListByCustomerRequest15,
+
+ final com.frentix.olat.vitero.manager.stubs.UserServiceCallbackHandler callback)
+
+ throws java.rmi.RemoteException{
+
+ org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[9].getName());
+ _operationClient.getOptions().setAction("\"\"");
+ _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true);
+
+
+
+ addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&");
+
+
+
+ // create SOAP envelope with that payload
+ org.apache.axiom.soap.SOAPEnvelope env=null;
+ final org.apache.axis2.context.MessageContext _messageContext = new org.apache.axis2.context.MessageContext();
+
+
+ //Style is Doc.
+
+
+ env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()),
+ getUserListByCustomerRequest15,
+ optimizeContent(new javax.xml.namespace.QName("http://www.vitero.de/schema/user",
+ "getUserListByCustomer")));
+
+ // adding SOAP soap_headers
+ _serviceClient.addHeadersToEnvelope(env);
+ // create message context with that soap envelope
+ _messageContext.setEnvelope(env);
+
+ // add the message context to the operation client
+ _operationClient.addMessageContext(_messageContext);
+
+
+
+ _operationClient.setCallback(new org.apache.axis2.client.async.AxisCallback() {
+ public void onMessage(org.apache.axis2.context.MessageContext resultContext) {
+ try {
+ org.apache.axiom.soap.SOAPEnvelope resultEnv = resultContext.getEnvelope();
+
+ java.lang.Object object = fromOM(resultEnv.getBody().getFirstElement(),
+ com.frentix.olat.vitero.manager.stubs.UserServiceStub.GetUserListByCustomerResponse.class,
+ getEnvelopeNamespaces(resultEnv));
+ callback.receiveResultgetUserListByCustomer(
+ (com.frentix.olat.vitero.manager.stubs.UserServiceStub.GetUserListByCustomerResponse)object);
+
+ } catch (org.apache.axis2.AxisFault e) {
+ callback.receiveErrorgetUserListByCustomer(e);
+ }
+ }
+
+ public void onError(java.lang.Exception error) {
+ if (error instanceof org.apache.axis2.AxisFault) {
+ org.apache.axis2.AxisFault f = (org.apache.axis2.AxisFault) error;
+ org.apache.axiom.om.OMElement faultElt = f.getDetail();
+ if (faultElt!=null){
+ if (faultExceptionNameMap.containsKey(faultElt.getQName())){
+ //make the fault by reflection
+ try{
+ java.lang.String exceptionClassName = (java.lang.String)faultExceptionClassNameMap.get(faultElt.getQName());
+ java.lang.Class exceptionClass = java.lang.Class.forName(exceptionClassName);
+ java.lang.Exception ex=
+ (java.lang.Exception) exceptionClass.newInstance();
+ //message class
+ java.lang.String messageClassName = (java.lang.String)faultMessageMap.get(faultElt.getQName());
+ java.lang.Class messageClass = java.lang.Class.forName(messageClassName);
+ java.lang.Object messageObject = fromOM(faultElt,messageClass,null);
+ java.lang.reflect.Method m = exceptionClass.getMethod("setFaultMessage",
+ new java.lang.Class[]{messageClass});
+ m.invoke(ex,new java.lang.Object[]{messageObject});
+
+
+ callback.receiveErrorgetUserListByCustomer(new java.rmi.RemoteException(ex.getMessage(), ex));
+ } catch(java.lang.ClassCastException e){
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetUserListByCustomer(f);
+ } catch (java.lang.ClassNotFoundException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetUserListByCustomer(f);
+ } catch (java.lang.NoSuchMethodException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetUserListByCustomer(f);
+ } catch (java.lang.reflect.InvocationTargetException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetUserListByCustomer(f);
+ } catch (java.lang.IllegalAccessException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetUserListByCustomer(f);
+ } catch (java.lang.InstantiationException e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetUserListByCustomer(f);
+ } catch (org.apache.axis2.AxisFault e) {
+ // we cannot intantiate the class - throw the original Axis fault
+ callback.receiveErrorgetUserListByCustomer(f);
+ }
+ } else {
+ callback.receiveErrorgetUserListByCustomer(f);
+ }
+ } else {
+ callback.receiveErrorgetUserListByCustomer(f);
+ }
+ } else {
+ callback.receiveErrorgetUserListByCustomer(error);
+ }
+ }
+
+ public void onFault(org.apache.axis2.context.MessageContext faultContext) {
+ org.apache.axis2.AxisFault fault = org.apache.axis2.util.Utils.getInboundFaultFromMessageContext(faultContext);
+ onError(fault);
+ }
+
+ public void onComplete() {
+ try {
+ _messageContext.getTransportOut().getSender().cleanup(_messageContext);
+ } catch (org.apache.axis2.AxisFault axisFault) {
+ callback.receiveErrorgetUserListByCustomer(axisFault);
+ }
+ }
+ });
+
+
+ org.apache.axis2.util.CallbackReceiver _callbackReceiver = null;
+ if ( _operations[9].getMessageReceiver()==null && _operationClient.getOptions().isUseSeparateListener()) {
+ _callbackReceiver = new org.apache.axis2.util.CallbackReceiver();
+ _operations[9].setMessageReceiver(
+ _callbackReceiver);
+ }
+
+ //execute the operation client
+ _operationClient.execute(false);
+
+ }
+
+
+ /**
+ * Auto generated method signature
+ *
+ */
+ public void changePassword(
+ com.frentix.olat.vitero.manager.stubs.UserServiceStub.ChangePasswordRequest changePasswordRequest17
+
+ ) throws java.rmi.RemoteException
+
+
+ {
+ org.apache.axis2.context.MessageContext _messageContext = null;
+
+
+ org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[10].getName());
+ _operationClient.getOptions().setAction("\"\"");
+ _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true);
+
+
+
+ addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&");
+
+ org.apache.axiom.soap.SOAPEnvelope env = null;
+ _messageContext = new org.apache.axis2.context.MessageContext();
+
+
+ //Style is Doc.
+
+
+ env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()),
+ changePasswordRequest17,
+ optimizeContent(new javax.xml.namespace.QName("http://www.vitero.de/schema/user",
+ "changePassword")));
+
+
+ //adding SOAP soap_headers
+ _serviceClient.addHeadersToEnvelope(env);
+ // create message context with that soap envelope
+
+ _messageContext.setEnvelope(env);
+
+ // add the message contxt to the operation client
+ _operationClient.addMessageContext(_messageContext);
+
+ _operationClient.execute(true);
+
+
+ _messageContext.getTransportOut().getSender().cleanup(_messageContext);
+
+ return;
+ }
+
+
+
+ /**
+ * A utility method that copies the namepaces from the SOAPEnvelope
+ */
+ private java.util.Map getEnvelopeNamespaces(org.apache.axiom.soap.SOAPEnvelope env){
+ java.util.Map returnMap = new java.util.HashMap();
+ java.util.Iterator namespaceIterator = env.getAllDeclaredNamespaces();
+ while (namespaceIterator.hasNext()) {
+ org.apache.axiom.om.OMNamespace ns = (org.apache.axiom.om.OMNamespace) namespaceIterator.next();
+ returnMap.put(ns.getPrefix(),ns.getNamespaceURI());
+ }
+ return returnMap;
+ }
+
+
+
+ private javax.xml.namespace.QName[] opNameArray = null;
+ private boolean optimizeContent(javax.xml.namespace.QName opName) {
+
+
+ if (opNameArray == null) {
+ return false;
+ }
+ for (int i = 0; i < opNameArray.length; i++) {
+ if (opName.equals(opNameArray[i])) {
+ return true;
+ }
+ }
+ return false;
+ }
+ //http://192.168.1.54:8080/vitero/services/
+ public static class Usertype
+ implements org.apache.axis2.databinding.ADBBean{
+ /* This type was generated from the piece of schema that had
+ name = usertype
+ Namespace URI = http://www.vitero.de/schema/user
+ Namespace Prefix = ns1
+ */
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/user")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for Id
+ */
+
+
+ protected int localId ;
+
+
+ /**
+ * Auto generated getter method
+ * @return int
+ */
+ public int getId(){
+ return localId;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Id
+ */
+ public void setId(int param){
+
+ this.localId=param;
+
+
+ }
+
+
+ /**
+ * field for Username
+ */
+
+
+ protected java.lang.String localUsername ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getUsername(){
+ return localUsername;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Username
+ */
+ public void setUsername(java.lang.String param){
+
+ this.localUsername=param;
+
+
+ }
+
+
+ /**
+ * field for Title
+ */
+
+
+ protected java.lang.String localTitle ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localTitleTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getTitle(){
+ return localTitle;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Title
+ */
+ public void setTitle(java.lang.String param){
+
+ if (param != null){
+ //update the setting tracker
+ localTitleTracker = true;
+ } else {
+ localTitleTracker = false;
+
+ }
+
+ this.localTitle=param;
+
+
+ }
+
+
+ /**
+ * field for Surname
+ */
+
+
+ protected java.lang.String localSurname ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getSurname(){
+ return localSurname;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Surname
+ */
+ public void setSurname(java.lang.String param){
+
+ this.localSurname=param;
+
+
+ }
+
+
+ /**
+ * field for Firstname
+ */
+
+
+ protected java.lang.String localFirstname ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getFirstname(){
+ return localFirstname;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Firstname
+ */
+ public void setFirstname(java.lang.String param){
+
+ this.localFirstname=param;
+
+
+ }
+
+
+ /**
+ * field for Email
+ */
+
+
+ protected java.lang.String localEmail ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getEmail(){
+ return localEmail;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Email
+ */
+ public void setEmail(java.lang.String param){
+
+ this.localEmail=param;
+
+
+ }
+
+
+ /**
+ * field for Company
+ */
+
+
+ protected java.lang.String localCompany ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localCompanyTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getCompany(){
+ return localCompany;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Company
+ */
+ public void setCompany(java.lang.String param){
+
+ if (param != null){
+ //update the setting tracker
+ localCompanyTracker = true;
+ } else {
+ localCompanyTracker = false;
+
+ }
+
+ this.localCompany=param;
+
+
+ }
+
+
+ /**
+ * field for Locale
+ */
+
+
+ protected java.lang.String localLocale ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localLocaleTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getLocale(){
+ return localLocale;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Locale
+ */
+ public void setLocale(java.lang.String param){
+
+ if (param != null){
+ //update the setting tracker
+ localLocaleTracker = true;
+ } else {
+ localLocaleTracker = false;
+
+ }
+
+ this.localLocale=param;
+
+
+ }
+
+
+ /**
+ * field for Timezone
+ */
+
+
+ protected java.lang.String localTimezone ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localTimezoneTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getTimezone(){
+ return localTimezone;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Timezone
+ */
+ public void setTimezone(java.lang.String param){
+
+ if (param != null){
+ //update the setting tracker
+ localTimezoneTracker = true;
+ } else {
+ localTimezoneTracker = false;
+
+ }
+
+ this.localTimezone=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,parentQName){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ Usertype.this.serialize(parentQName,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ parentQName,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/user");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":usertype",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "usertype",
+ xmlWriter);
+ }
+
+
+ }
+
+ namespace = "http://www.vitero.de/schema/user";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"id", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"id");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("id");
+ }
+
+ if (localId==java.lang.Integer.MIN_VALUE) {
+
+ throw new org.apache.axis2.databinding.ADBException("id cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localId));
+ }
+
+ xmlWriter.writeEndElement();
+
+ namespace = "http://www.vitero.de/schema/user";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"username", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"username");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("username");
+ }
+
+
+ if (localUsername==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("username cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localUsername);
+
+ }
+
+ xmlWriter.writeEndElement();
+ if (localTitleTracker){
+ namespace = "http://www.vitero.de/schema/user";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"title", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"title");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("title");
+ }
+
+
+ if (localTitle==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("title cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localTitle);
+
+ }
+
+ xmlWriter.writeEndElement();
+ }
+ namespace = "http://www.vitero.de/schema/user";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"surname", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"surname");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("surname");
+ }
+
+
+ if (localSurname==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("surname cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localSurname);
+
+ }
+
+ xmlWriter.writeEndElement();
+
+ namespace = "http://www.vitero.de/schema/user";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"firstname", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"firstname");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("firstname");
+ }
+
+
+ if (localFirstname==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("firstname cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localFirstname);
+
+ }
+
+ xmlWriter.writeEndElement();
+
+ namespace = "http://www.vitero.de/schema/user";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"email", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"email");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("email");
+ }
+
+
+ if (localEmail==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("email cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localEmail);
+
+ }
+
+ xmlWriter.writeEndElement();
+ if (localCompanyTracker){
+ namespace = "http://www.vitero.de/schema/user";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"company", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"company");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("company");
+ }
+
+
+ if (localCompany==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("company cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localCompany);
+
+ }
+
+ xmlWriter.writeEndElement();
+ } if (localLocaleTracker){
+ namespace = "http://www.vitero.de/schema/user";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"locale", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"locale");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("locale");
+ }
+
+
+ if (localLocale==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("locale cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localLocale);
+
+ }
+
+ xmlWriter.writeEndElement();
+ } if (localTimezoneTracker){
+ namespace = "http://www.vitero.de/schema/user";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"timezone", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"timezone");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("timezone");
+ }
+
+
+ if (localTimezone==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("timezone cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localTimezone);
+
+ }
+
+ xmlWriter.writeEndElement();
+ }
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/user",
+ "id"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localId));
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/user",
+ "username"));
+
+ if (localUsername != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localUsername));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("username cannot be null!!");
+ }
+ if (localTitleTracker){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/user",
+ "title"));
+
+ if (localTitle != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localTitle));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("title cannot be null!!");
+ }
+ }
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/user",
+ "surname"));
+
+ if (localSurname != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localSurname));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("surname cannot be null!!");
+ }
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/user",
+ "firstname"));
+
+ if (localFirstname != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localFirstname));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("firstname cannot be null!!");
+ }
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/user",
+ "email"));
+
+ if (localEmail != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localEmail));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("email cannot be null!!");
+ }
+ if (localCompanyTracker){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/user",
+ "company"));
+
+ if (localCompany != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localCompany));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("company cannot be null!!");
+ }
+ } if (localLocaleTracker){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/user",
+ "locale"));
+
+ if (localLocale != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localLocale));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("locale cannot be null!!");
+ }
+ } if (localTimezoneTracker){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/user",
+ "timezone"));
+
+ if (localTimezone != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localTimezone));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("timezone cannot be null!!");
+ }
+ }
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static Usertype parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ Usertype object =
+ new Usertype();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"usertype".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (Usertype)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/user","id").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setId(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToInt(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/user","username").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setUsername(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/user","title").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setTitle(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/user","surname").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setSurname(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/user","firstname").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setFirstname(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/user","email").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setEmail(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/user","company").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setCompany(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/user","locale").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setLocale(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/user","timezone").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setTimezone(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class Completeuserwithcustomertype
+ implements org.apache.axis2.databinding.ADBBean{
+ /* This type was generated from the piece of schema that had
+ name = completeuserwithcustomertype
+ Namespace URI = http://www.vitero.de/schema/user
+ Namespace Prefix = ns1
+ */
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/user")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for Id
+ */
+
+
+ protected int localId ;
+
+
+ /**
+ * Auto generated getter method
+ * @return int
+ */
+ public int getId(){
+ return localId;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Id
+ */
+ public void setId(int param){
+
+ this.localId=param;
+
+
+ }
+
+
+ /**
+ * field for Username
+ */
+
+
+ protected java.lang.String localUsername ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getUsername(){
+ return localUsername;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Username
+ */
+ public void setUsername(java.lang.String param){
+
+ this.localUsername=param;
+
+
+ }
+
+
+ /**
+ * field for Title
+ */
+
+
+ protected java.lang.String localTitle ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localTitleTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getTitle(){
+ return localTitle;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Title
+ */
+ public void setTitle(java.lang.String param){
+
+ if (param != null){
+ //update the setting tracker
+ localTitleTracker = true;
+ } else {
+ localTitleTracker = false;
+
+ }
+
+ this.localTitle=param;
+
+
+ }
+
+
+ /**
+ * field for Surname
+ */
+
+
+ protected java.lang.String localSurname ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getSurname(){
+ return localSurname;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Surname
+ */
+ public void setSurname(java.lang.String param){
+
+ this.localSurname=param;
+
+
+ }
+
+
+ /**
+ * field for Firstname
+ */
+
+
+ protected java.lang.String localFirstname ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getFirstname(){
+ return localFirstname;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Firstname
+ */
+ public void setFirstname(java.lang.String param){
+
+ this.localFirstname=param;
+
+
+ }
+
+
+ /**
+ * field for Email
+ */
+
+
+ protected java.lang.String localEmail ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getEmail(){
+ return localEmail;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Email
+ */
+ public void setEmail(java.lang.String param){
+
+ this.localEmail=param;
+
+
+ }
+
+
+ /**
+ * field for Company
+ */
+
+
+ protected java.lang.String localCompany ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localCompanyTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getCompany(){
+ return localCompany;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Company
+ */
+ public void setCompany(java.lang.String param){
+
+ if (param != null){
+ //update the setting tracker
+ localCompanyTracker = true;
+ } else {
+ localCompanyTracker = false;
+
+ }
+
+ this.localCompany=param;
+
+
+ }
+
+
+ /**
+ * field for Locale
+ */
+
+
+ protected java.lang.String localLocale ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localLocaleTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getLocale(){
+ return localLocale;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Locale
+ */
+ public void setLocale(java.lang.String param){
+
+ if (param != null){
+ //update the setting tracker
+ localLocaleTracker = true;
+ } else {
+ localLocaleTracker = false;
+
+ }
+
+ this.localLocale=param;
+
+
+ }
+
+
+ /**
+ * field for Timezone
+ */
+
+
+ protected java.lang.String localTimezone ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localTimezoneTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getTimezone(){
+ return localTimezone;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Timezone
+ */
+ public void setTimezone(java.lang.String param){
+
+ if (param != null){
+ //update the setting tracker
+ localTimezoneTracker = true;
+ } else {
+ localTimezoneTracker = false;
+
+ }
+
+ this.localTimezone=param;
+
+
+ }
+
+
+ /**
+ * field for Phone
+ */
+
+
+ protected java.lang.String localPhone ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localPhoneTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getPhone(){
+ return localPhone;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Phone
+ */
+ public void setPhone(java.lang.String param){
+
+ if (param != null){
+ //update the setting tracker
+ localPhoneTracker = true;
+ } else {
+ localPhoneTracker = false;
+
+ }
+
+ this.localPhone=param;
+
+
+ }
+
+
+ /**
+ * field for Fax
+ */
+
+
+ protected java.lang.String localFax ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localFaxTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getFax(){
+ return localFax;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Fax
+ */
+ public void setFax(java.lang.String param){
+
+ if (param != null){
+ //update the setting tracker
+ localFaxTracker = true;
+ } else {
+ localFaxTracker = false;
+
+ }
+
+ this.localFax=param;
+
+
+ }
+
+
+ /**
+ * field for Mobile
+ */
+
+
+ protected java.lang.String localMobile ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localMobileTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getMobile(){
+ return localMobile;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Mobile
+ */
+ public void setMobile(java.lang.String param){
+
+ if (param != null){
+ //update the setting tracker
+ localMobileTracker = true;
+ } else {
+ localMobileTracker = false;
+
+ }
+
+ this.localMobile=param;
+
+
+ }
+
+
+ /**
+ * field for Country
+ */
+
+
+ protected java.lang.String localCountry ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localCountryTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getCountry(){
+ return localCountry;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Country
+ */
+ public void setCountry(java.lang.String param){
+
+ if (param != null){
+ //update the setting tracker
+ localCountryTracker = true;
+ } else {
+ localCountryTracker = false;
+
+ }
+
+ this.localCountry=param;
+
+
+ }
+
+
+ /**
+ * field for Zip
+ */
+
+
+ protected java.lang.String localZip ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localZipTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getZip(){
+ return localZip;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Zip
+ */
+ public void setZip(java.lang.String param){
+
+ if (param != null){
+ //update the setting tracker
+ localZipTracker = true;
+ } else {
+ localZipTracker = false;
+
+ }
+
+ this.localZip=param;
+
+
+ }
+
+
+ /**
+ * field for City
+ */
+
+
+ protected java.lang.String localCity ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localCityTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getCity(){
+ return localCity;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param City
+ */
+ public void setCity(java.lang.String param){
+
+ if (param != null){
+ //update the setting tracker
+ localCityTracker = true;
+ } else {
+ localCityTracker = false;
+
+ }
+
+ this.localCity=param;
+
+
+ }
+
+
+ /**
+ * field for Street
+ */
+
+
+ protected java.lang.String localStreet ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localStreetTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getStreet(){
+ return localStreet;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Street
+ */
+ public void setStreet(java.lang.String param){
+
+ if (param != null){
+ //update the setting tracker
+ localStreetTracker = true;
+ } else {
+ localStreetTracker = false;
+
+ }
+
+ this.localStreet=param;
+
+
+ }
+
+
+ /**
+ * field for Pcstate
+ */
+
+
+ protected java.lang.String localPcstate ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localPcstateTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getPcstate(){
+ return localPcstate;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Pcstate
+ */
+ public void setPcstate(java.lang.String param){
+
+ if (param != null){
+ //update the setting tracker
+ localPcstateTracker = true;
+ } else {
+ localPcstateTracker = false;
+
+ }
+
+ this.localPcstate=param;
+
+
+ }
+
+
+ /**
+ * field for Technicalnote
+ */
+
+
+ protected java.lang.String localTechnicalnote ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localTechnicalnoteTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getTechnicalnote(){
+ return localTechnicalnote;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Technicalnote
+ */
+ public void setTechnicalnote(java.lang.String param){
+
+ if (param != null){
+ //update the setting tracker
+ localTechnicalnoteTracker = true;
+ } else {
+ localTechnicalnoteTracker = false;
+
+ }
+
+ this.localTechnicalnote=param;
+
+
+ }
+
+
+ /**
+ * field for Customer
+ * This was an Array!
+ */
+
+
+ protected Customer_type0[] localCustomer ;
+
+
+ /**
+ * Auto generated getter method
+ * @return Customer_type0[]
+ */
+ public Customer_type0[] getCustomer(){
+ return localCustomer;
+ }
+
+
+
+
+
+
+ /**
+ * validate the array for Customer
+ */
+ protected void validateCustomer(Customer_type0[] param){
+
+ if ((param != null) && (param.length < 1)){
+ throw new java.lang.RuntimeException();
+ }
+
+ }
+
+
+ /**
+ * Auto generated setter method
+ * @param param Customer
+ */
+ public void setCustomer(Customer_type0[] param){
+
+ validateCustomer(param);
+
+
+ this.localCustomer=param;
+ }
+
+
+
+ /**
+ * Auto generated add method for the array for convenience
+ * @param param Customer_type0
+ */
+ public void addCustomer(Customer_type0 param){
+ if (localCustomer == null){
+ localCustomer = new Customer_type0[]{};
+ }
+
+
+
+ java.util.List list =
+ org.apache.axis2.databinding.utils.ConverterUtil.toList(localCustomer);
+ list.add(param);
+ this.localCustomer =
+ (Customer_type0[])list.toArray(
+ new Customer_type0[list.size()]);
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,parentQName){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ Completeuserwithcustomertype.this.serialize(parentQName,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ parentQName,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/user");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":completeuserwithcustomertype",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "completeuserwithcustomertype",
+ xmlWriter);
+ }
+
+
+ }
+
+ namespace = "http://www.vitero.de/schema/user";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"id", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"id");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("id");
+ }
+
+ if (localId==java.lang.Integer.MIN_VALUE) {
+
+ throw new org.apache.axis2.databinding.ADBException("id cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localId));
+ }
+
+ xmlWriter.writeEndElement();
+
+ namespace = "http://www.vitero.de/schema/user";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"username", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"username");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("username");
+ }
+
+
+ if (localUsername==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("username cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localUsername);
+
+ }
+
+ xmlWriter.writeEndElement();
+ if (localTitleTracker){
+ namespace = "http://www.vitero.de/schema/user";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"title", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"title");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("title");
+ }
+
+
+ if (localTitle==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("title cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localTitle);
+
+ }
+
+ xmlWriter.writeEndElement();
+ }
+ namespace = "http://www.vitero.de/schema/user";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"surname", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"surname");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("surname");
+ }
+
+
+ if (localSurname==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("surname cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localSurname);
+
+ }
+
+ xmlWriter.writeEndElement();
+
+ namespace = "http://www.vitero.de/schema/user";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"firstname", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"firstname");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("firstname");
+ }
+
+
+ if (localFirstname==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("firstname cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localFirstname);
+
+ }
+
+ xmlWriter.writeEndElement();
+
+ namespace = "http://www.vitero.de/schema/user";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"email", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"email");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("email");
+ }
+
+
+ if (localEmail==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("email cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localEmail);
+
+ }
+
+ xmlWriter.writeEndElement();
+ if (localCompanyTracker){
+ namespace = "http://www.vitero.de/schema/user";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"company", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"company");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("company");
+ }
+
+
+ if (localCompany==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("company cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localCompany);
+
+ }
+
+ xmlWriter.writeEndElement();
+ } if (localLocaleTracker){
+ namespace = "http://www.vitero.de/schema/user";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"locale", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"locale");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("locale");
+ }
+
+
+ if (localLocale==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("locale cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localLocale);
+
+ }
+
+ xmlWriter.writeEndElement();
+ } if (localTimezoneTracker){
+ namespace = "http://www.vitero.de/schema/user";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"timezone", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"timezone");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("timezone");
+ }
+
+
+ if (localTimezone==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("timezone cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localTimezone);
+
+ }
+
+ xmlWriter.writeEndElement();
+ } if (localPhoneTracker){
+ namespace = "http://www.vitero.de/schema/user";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"phone", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"phone");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("phone");
+ }
+
+
+ if (localPhone==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("phone cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localPhone);
+
+ }
+
+ xmlWriter.writeEndElement();
+ } if (localFaxTracker){
+ namespace = "http://www.vitero.de/schema/user";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"fax", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"fax");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("fax");
+ }
+
+
+ if (localFax==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("fax cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localFax);
+
+ }
+
+ xmlWriter.writeEndElement();
+ } if (localMobileTracker){
+ namespace = "http://www.vitero.de/schema/user";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"mobile", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"mobile");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("mobile");
+ }
+
+
+ if (localMobile==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("mobile cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localMobile);
+
+ }
+
+ xmlWriter.writeEndElement();
+ } if (localCountryTracker){
+ namespace = "http://www.vitero.de/schema/user";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"country", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"country");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("country");
+ }
+
+
+ if (localCountry==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("country cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localCountry);
+
+ }
+
+ xmlWriter.writeEndElement();
+ } if (localZipTracker){
+ namespace = "http://www.vitero.de/schema/user";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"zip", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"zip");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("zip");
+ }
+
+
+ if (localZip==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("zip cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localZip);
+
+ }
+
+ xmlWriter.writeEndElement();
+ } if (localCityTracker){
+ namespace = "http://www.vitero.de/schema/user";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"city", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"city");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("city");
+ }
+
+
+ if (localCity==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("city cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localCity);
+
+ }
+
+ xmlWriter.writeEndElement();
+ } if (localStreetTracker){
+ namespace = "http://www.vitero.de/schema/user";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"street", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"street");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("street");
+ }
+
+
+ if (localStreet==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("street cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localStreet);
+
+ }
+
+ xmlWriter.writeEndElement();
+ } if (localPcstateTracker){
+ namespace = "http://www.vitero.de/schema/user";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"pcstate", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"pcstate");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("pcstate");
+ }
+
+
+ if (localPcstate==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("pcstate cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localPcstate);
+
+ }
+
+ xmlWriter.writeEndElement();
+ } if (localTechnicalnoteTracker){
+ namespace = "http://www.vitero.de/schema/user";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"technicalnote", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"technicalnote");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("technicalnote");
+ }
+
+
+ if (localTechnicalnote==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("technicalnote cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localTechnicalnote);
+
+ }
+
+ xmlWriter.writeEndElement();
+ }
+ if (localCustomer!=null){
+ for (int i = 0;i < localCustomer.length;i++){
+ if (localCustomer[i] != null){
+ localCustomer[i].serialize(new javax.xml.namespace.QName("http://www.vitero.de/schema/user","customer"),
+ factory,xmlWriter);
+ } else {
+
+ throw new org.apache.axis2.databinding.ADBException("customer cannot be null!!");
+
+ }
+
+ }
+ } else {
+
+ throw new org.apache.axis2.databinding.ADBException("customer cannot be null!!");
+
+ }
+
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/user",
+ "id"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localId));
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/user",
+ "username"));
+
+ if (localUsername != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localUsername));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("username cannot be null!!");
+ }
+ if (localTitleTracker){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/user",
+ "title"));
+
+ if (localTitle != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localTitle));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("title cannot be null!!");
+ }
+ }
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/user",
+ "surname"));
+
+ if (localSurname != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localSurname));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("surname cannot be null!!");
+ }
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/user",
+ "firstname"));
+
+ if (localFirstname != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localFirstname));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("firstname cannot be null!!");
+ }
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/user",
+ "email"));
+
+ if (localEmail != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localEmail));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("email cannot be null!!");
+ }
+ if (localCompanyTracker){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/user",
+ "company"));
+
+ if (localCompany != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localCompany));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("company cannot be null!!");
+ }
+ } if (localLocaleTracker){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/user",
+ "locale"));
+
+ if (localLocale != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localLocale));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("locale cannot be null!!");
+ }
+ } if (localTimezoneTracker){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/user",
+ "timezone"));
+
+ if (localTimezone != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localTimezone));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("timezone cannot be null!!");
+ }
+ } if (localPhoneTracker){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/user",
+ "phone"));
+
+ if (localPhone != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localPhone));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("phone cannot be null!!");
+ }
+ } if (localFaxTracker){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/user",
+ "fax"));
+
+ if (localFax != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localFax));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("fax cannot be null!!");
+ }
+ } if (localMobileTracker){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/user",
+ "mobile"));
+
+ if (localMobile != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localMobile));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("mobile cannot be null!!");
+ }
+ } if (localCountryTracker){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/user",
+ "country"));
+
+ if (localCountry != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localCountry));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("country cannot be null!!");
+ }
+ } if (localZipTracker){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/user",
+ "zip"));
+
+ if (localZip != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localZip));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("zip cannot be null!!");
+ }
+ } if (localCityTracker){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/user",
+ "city"));
+
+ if (localCity != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localCity));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("city cannot be null!!");
+ }
+ } if (localStreetTracker){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/user",
+ "street"));
+
+ if (localStreet != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localStreet));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("street cannot be null!!");
+ }
+ } if (localPcstateTracker){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/user",
+ "pcstate"));
+
+ if (localPcstate != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localPcstate));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("pcstate cannot be null!!");
+ }
+ } if (localTechnicalnoteTracker){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/user",
+ "technicalnote"));
+
+ if (localTechnicalnote != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localTechnicalnote));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("technicalnote cannot be null!!");
+ }
+ }
+ if (localCustomer!=null) {
+ for (int i = 0;i < localCustomer.length;i++){
+
+ if (localCustomer[i] != null){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/user",
+ "customer"));
+ elementList.add(localCustomer[i]);
+ } else {
+
+ throw new org.apache.axis2.databinding.ADBException("customer cannot be null !!");
+
+ }
+
+ }
+ } else {
+
+ throw new org.apache.axis2.databinding.ADBException("customer cannot be null!!");
+
+ }
+
+
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static Completeuserwithcustomertype parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ Completeuserwithcustomertype object =
+ new Completeuserwithcustomertype();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"completeuserwithcustomertype".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (Completeuserwithcustomertype)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+ java.util.ArrayList list19 = new java.util.ArrayList();
+
+
+ while (!reader.isStartElement() && !reader.isEndElement()) reader.next();
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/user","id").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setId(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToInt(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+
+ while (!reader.isStartElement() && !reader.isEndElement()) reader.next();
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/user","username").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setUsername(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+
+ while (!reader.isStartElement() && !reader.isEndElement()) reader.next();
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/user","title").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setTitle(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else {
+
+ }
+
+
+ while (!reader.isStartElement() && !reader.isEndElement()) reader.next();
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/user","surname").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setSurname(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+
+ while (!reader.isStartElement() && !reader.isEndElement()) reader.next();
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/user","firstname").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setFirstname(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+
+ while (!reader.isStartElement() && !reader.isEndElement()) reader.next();
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/user","email").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setEmail(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+
+ while (!reader.isStartElement() && !reader.isEndElement()) reader.next();
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/user","company").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setCompany(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else {
+
+ }
+
+
+ while (!reader.isStartElement() && !reader.isEndElement()) reader.next();
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/user","locale").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setLocale(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else {
+
+ }
+
+
+ while (!reader.isStartElement() && !reader.isEndElement()) reader.next();
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/user","timezone").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setTimezone(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else {
+
+ }
+
+
+ while (!reader.isStartElement() && !reader.isEndElement()) reader.next();
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/user","phone").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setPhone(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else {
+
+ }
+
+
+ while (!reader.isStartElement() && !reader.isEndElement()) reader.next();
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/user","fax").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setFax(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else {
+
+ }
+
+
+ while (!reader.isStartElement() && !reader.isEndElement()) reader.next();
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/user","mobile").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setMobile(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else {
+
+ }
+
+
+ while (!reader.isStartElement() && !reader.isEndElement()) reader.next();
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/user","country").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setCountry(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else {
+
+ }
+
+
+ while (!reader.isStartElement() && !reader.isEndElement()) reader.next();
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/user","zip").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setZip(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else {
+
+ }
+
+
+ while (!reader.isStartElement() && !reader.isEndElement()) reader.next();
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/user","city").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setCity(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else {
+
+ }
+
+
+ while (!reader.isStartElement() && !reader.isEndElement()) reader.next();
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/user","street").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setStreet(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else {
+
+ }
+
+
+ while (!reader.isStartElement() && !reader.isEndElement()) reader.next();
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/user","pcstate").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setPcstate(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else {
+
+ }
+
+
+ while (!reader.isStartElement() && !reader.isEndElement()) reader.next();
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/user","technicalnote").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setTechnicalnote(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else {
+
+ }
+
+
+ while (!reader.isStartElement() && !reader.isEndElement()) reader.next();
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/user","customer").equals(reader.getName())){
+
+
+
+ // Process the array and step past its final element's end.
+ list19.add(Customer_type0.Factory.parse(reader));
+
+ //loop until we find a start element that is not part of this array
+ boolean loopDone19 = false;
+ while(!loopDone19){
+ // We should be at the end element, but make sure
+ while (!reader.isEndElement())
+ reader.next();
+ // Step out of this element
+ reader.next();
+ // Step to next element event.
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+ if (reader.isEndElement()){
+ //two continuous end elements means we are exiting the xml structure
+ loopDone19 = true;
+ } else {
+ if (new javax.xml.namespace.QName("http://www.vitero.de/schema/user","customer").equals(reader.getName())){
+ list19.add(Customer_type0.Factory.parse(reader));
+
+ }else{
+ loopDone19 = true;
+ }
+ }
+ }
+ // call the converter utility to convert and set the array
+
+ object.setCustomer((Customer_type0[])
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToArray(
+ Customer_type0.class,
+ list19));
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+ if (reader.isStartElement())
+ // A start element we are not expecting indicates a trailing invalid property
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class Completeusertype
+ implements org.apache.axis2.databinding.ADBBean{
+ /* This type was generated from the piece of schema that had
+ name = completeusertype
+ Namespace URI = http://www.vitero.de/schema/user
+ Namespace Prefix = ns1
+ */
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/user")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for Id
+ */
+
+
+ protected int localId ;
+
+
+ /**
+ * Auto generated getter method
+ * @return int
+ */
+ public int getId(){
+ return localId;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Id
+ */
+ public void setId(int param){
+
+ this.localId=param;
+
+
+ }
+
+
+ /**
+ * field for Username
+ */
+
+
+ protected java.lang.String localUsername ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getUsername(){
+ return localUsername;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Username
+ */
+ public void setUsername(java.lang.String param){
+
+ this.localUsername=param;
+
+
+ }
+
+
+ /**
+ * field for Title
+ */
+
+
+ protected java.lang.String localTitle ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localTitleTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getTitle(){
+ return localTitle;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Title
+ */
+ public void setTitle(java.lang.String param){
+
+ if (param != null){
+ //update the setting tracker
+ localTitleTracker = true;
+ } else {
+ localTitleTracker = false;
+
+ }
+
+ this.localTitle=param;
+
+
+ }
+
+
+ /**
+ * field for Surname
+ */
+
+
+ protected java.lang.String localSurname ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getSurname(){
+ return localSurname;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Surname
+ */
+ public void setSurname(java.lang.String param){
+
+ this.localSurname=param;
+
+
+ }
+
+
+ /**
+ * field for Firstname
+ */
+
+
+ protected java.lang.String localFirstname ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getFirstname(){
+ return localFirstname;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Firstname
+ */
+ public void setFirstname(java.lang.String param){
+
+ this.localFirstname=param;
+
+
+ }
+
+
+ /**
+ * field for Email
+ */
+
+
+ protected java.lang.String localEmail ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getEmail(){
+ return localEmail;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Email
+ */
+ public void setEmail(java.lang.String param){
+
+ this.localEmail=param;
+
+
+ }
+
+
+ /**
+ * field for Company
+ */
+
+
+ protected java.lang.String localCompany ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localCompanyTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getCompany(){
+ return localCompany;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Company
+ */
+ public void setCompany(java.lang.String param){
+
+ if (param != null){
+ //update the setting tracker
+ localCompanyTracker = true;
+ } else {
+ localCompanyTracker = false;
+
+ }
+
+ this.localCompany=param;
+
+
+ }
+
+
+ /**
+ * field for Locale
+ */
+
+
+ protected java.lang.String localLocale ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localLocaleTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getLocale(){
+ return localLocale;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Locale
+ */
+ public void setLocale(java.lang.String param){
+
+ if (param != null){
+ //update the setting tracker
+ localLocaleTracker = true;
+ } else {
+ localLocaleTracker = false;
+
+ }
+
+ this.localLocale=param;
+
+
+ }
+
+
+ /**
+ * field for Timezone
+ */
+
+
+ protected java.lang.String localTimezone ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localTimezoneTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getTimezone(){
+ return localTimezone;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Timezone
+ */
+ public void setTimezone(java.lang.String param){
+
+ if (param != null){
+ //update the setting tracker
+ localTimezoneTracker = true;
+ } else {
+ localTimezoneTracker = false;
+
+ }
+
+ this.localTimezone=param;
+
+
+ }
+
+
+ /**
+ * field for Phone
+ */
+
+
+ protected java.lang.String localPhone ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localPhoneTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getPhone(){
+ return localPhone;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Phone
+ */
+ public void setPhone(java.lang.String param){
+
+ if (param != null){
+ //update the setting tracker
+ localPhoneTracker = true;
+ } else {
+ localPhoneTracker = false;
+
+ }
+
+ this.localPhone=param;
+
+
+ }
+
+
+ /**
+ * field for Fax
+ */
+
+
+ protected java.lang.String localFax ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localFaxTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getFax(){
+ return localFax;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Fax
+ */
+ public void setFax(java.lang.String param){
+
+ if (param != null){
+ //update the setting tracker
+ localFaxTracker = true;
+ } else {
+ localFaxTracker = false;
+
+ }
+
+ this.localFax=param;
+
+
+ }
+
+
+ /**
+ * field for Mobile
+ */
+
+
+ protected java.lang.String localMobile ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localMobileTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getMobile(){
+ return localMobile;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Mobile
+ */
+ public void setMobile(java.lang.String param){
+
+ if (param != null){
+ //update the setting tracker
+ localMobileTracker = true;
+ } else {
+ localMobileTracker = false;
+
+ }
+
+ this.localMobile=param;
+
+
+ }
+
+
+ /**
+ * field for Country
+ */
+
+
+ protected java.lang.String localCountry ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localCountryTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getCountry(){
+ return localCountry;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Country
+ */
+ public void setCountry(java.lang.String param){
+
+ if (param != null){
+ //update the setting tracker
+ localCountryTracker = true;
+ } else {
+ localCountryTracker = false;
+
+ }
+
+ this.localCountry=param;
+
+
+ }
+
+
+ /**
+ * field for Zip
+ */
+
+
+ protected java.lang.String localZip ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localZipTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getZip(){
+ return localZip;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Zip
+ */
+ public void setZip(java.lang.String param){
+
+ if (param != null){
+ //update the setting tracker
+ localZipTracker = true;
+ } else {
+ localZipTracker = false;
+
+ }
+
+ this.localZip=param;
+
+
+ }
+
+
+ /**
+ * field for City
+ */
+
+
+ protected java.lang.String localCity ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localCityTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getCity(){
+ return localCity;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param City
+ */
+ public void setCity(java.lang.String param){
+
+ if (param != null){
+ //update the setting tracker
+ localCityTracker = true;
+ } else {
+ localCityTracker = false;
+
+ }
+
+ this.localCity=param;
+
+
+ }
+
+
+ /**
+ * field for Street
+ */
+
+
+ protected java.lang.String localStreet ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localStreetTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getStreet(){
+ return localStreet;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Street
+ */
+ public void setStreet(java.lang.String param){
+
+ if (param != null){
+ //update the setting tracker
+ localStreetTracker = true;
+ } else {
+ localStreetTracker = false;
+
+ }
+
+ this.localStreet=param;
+
+
+ }
+
+
+ /**
+ * field for Pcstate
+ */
+
+
+ protected java.lang.String localPcstate ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localPcstateTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getPcstate(){
+ return localPcstate;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Pcstate
+ */
+ public void setPcstate(java.lang.String param){
+
+ if (param != null){
+ //update the setting tracker
+ localPcstateTracker = true;
+ } else {
+ localPcstateTracker = false;
+
+ }
+
+ this.localPcstate=param;
+
+
+ }
+
+
+ /**
+ * field for Technicalnote
+ */
+
+
+ protected java.lang.String localTechnicalnote ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localTechnicalnoteTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getTechnicalnote(){
+ return localTechnicalnote;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Technicalnote
+ */
+ public void setTechnicalnote(java.lang.String param){
+
+ if (param != null){
+ //update the setting tracker
+ localTechnicalnoteTracker = true;
+ } else {
+ localTechnicalnoteTracker = false;
+
+ }
+
+ this.localTechnicalnote=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,parentQName){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ Completeusertype.this.serialize(parentQName,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ parentQName,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/user");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":completeusertype",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "completeusertype",
+ xmlWriter);
+ }
+
+
+ }
+
+ namespace = "http://www.vitero.de/schema/user";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"id", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"id");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("id");
+ }
+
+ if (localId==java.lang.Integer.MIN_VALUE) {
+
+ throw new org.apache.axis2.databinding.ADBException("id cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localId));
+ }
+
+ xmlWriter.writeEndElement();
+
+ namespace = "http://www.vitero.de/schema/user";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"username", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"username");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("username");
+ }
+
+
+ if (localUsername==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("username cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localUsername);
+
+ }
+
+ xmlWriter.writeEndElement();
+ if (localTitleTracker){
+ namespace = "http://www.vitero.de/schema/user";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"title", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"title");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("title");
+ }
+
+
+ if (localTitle==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("title cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localTitle);
+
+ }
+
+ xmlWriter.writeEndElement();
+ }
+ namespace = "http://www.vitero.de/schema/user";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"surname", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"surname");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("surname");
+ }
+
+
+ if (localSurname==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("surname cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localSurname);
+
+ }
+
+ xmlWriter.writeEndElement();
+
+ namespace = "http://www.vitero.de/schema/user";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"firstname", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"firstname");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("firstname");
+ }
+
+
+ if (localFirstname==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("firstname cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localFirstname);
+
+ }
+
+ xmlWriter.writeEndElement();
+
+ namespace = "http://www.vitero.de/schema/user";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"email", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"email");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("email");
+ }
+
+
+ if (localEmail==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("email cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localEmail);
+
+ }
+
+ xmlWriter.writeEndElement();
+ if (localCompanyTracker){
+ namespace = "http://www.vitero.de/schema/user";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"company", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"company");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("company");
+ }
+
+
+ if (localCompany==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("company cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localCompany);
+
+ }
+
+ xmlWriter.writeEndElement();
+ } if (localLocaleTracker){
+ namespace = "http://www.vitero.de/schema/user";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"locale", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"locale");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("locale");
+ }
+
+
+ if (localLocale==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("locale cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localLocale);
+
+ }
+
+ xmlWriter.writeEndElement();
+ } if (localTimezoneTracker){
+ namespace = "http://www.vitero.de/schema/user";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"timezone", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"timezone");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("timezone");
+ }
+
+
+ if (localTimezone==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("timezone cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localTimezone);
+
+ }
+
+ xmlWriter.writeEndElement();
+ } if (localPhoneTracker){
+ namespace = "http://www.vitero.de/schema/user";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"phone", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"phone");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("phone");
+ }
+
+
+ if (localPhone==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("phone cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localPhone);
+
+ }
+
+ xmlWriter.writeEndElement();
+ } if (localFaxTracker){
+ namespace = "http://www.vitero.de/schema/user";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"fax", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"fax");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("fax");
+ }
+
+
+ if (localFax==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("fax cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localFax);
+
+ }
+
+ xmlWriter.writeEndElement();
+ } if (localMobileTracker){
+ namespace = "http://www.vitero.de/schema/user";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"mobile", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"mobile");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("mobile");
+ }
+
+
+ if (localMobile==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("mobile cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localMobile);
+
+ }
+
+ xmlWriter.writeEndElement();
+ } if (localCountryTracker){
+ namespace = "http://www.vitero.de/schema/user";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"country", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"country");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("country");
+ }
+
+
+ if (localCountry==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("country cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localCountry);
+
+ }
+
+ xmlWriter.writeEndElement();
+ } if (localZipTracker){
+ namespace = "http://www.vitero.de/schema/user";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"zip", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"zip");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("zip");
+ }
+
+
+ if (localZip==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("zip cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localZip);
+
+ }
+
+ xmlWriter.writeEndElement();
+ } if (localCityTracker){
+ namespace = "http://www.vitero.de/schema/user";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"city", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"city");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("city");
+ }
+
+
+ if (localCity==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("city cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localCity);
+
+ }
+
+ xmlWriter.writeEndElement();
+ } if (localStreetTracker){
+ namespace = "http://www.vitero.de/schema/user";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"street", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"street");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("street");
+ }
+
+
+ if (localStreet==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("street cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localStreet);
+
+ }
+
+ xmlWriter.writeEndElement();
+ } if (localPcstateTracker){
+ namespace = "http://www.vitero.de/schema/user";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"pcstate", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"pcstate");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("pcstate");
+ }
+
+
+ if (localPcstate==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("pcstate cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localPcstate);
+
+ }
+
+ xmlWriter.writeEndElement();
+ } if (localTechnicalnoteTracker){
+ namespace = "http://www.vitero.de/schema/user";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"technicalnote", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"technicalnote");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("technicalnote");
+ }
+
+
+ if (localTechnicalnote==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("technicalnote cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localTechnicalnote);
+
+ }
+
+ xmlWriter.writeEndElement();
+ }
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/user",
+ "id"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localId));
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/user",
+ "username"));
+
+ if (localUsername != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localUsername));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("username cannot be null!!");
+ }
+ if (localTitleTracker){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/user",
+ "title"));
+
+ if (localTitle != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localTitle));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("title cannot be null!!");
+ }
+ }
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/user",
+ "surname"));
+
+ if (localSurname != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localSurname));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("surname cannot be null!!");
+ }
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/user",
+ "firstname"));
+
+ if (localFirstname != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localFirstname));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("firstname cannot be null!!");
+ }
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/user",
+ "email"));
+
+ if (localEmail != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localEmail));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("email cannot be null!!");
+ }
+ if (localCompanyTracker){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/user",
+ "company"));
+
+ if (localCompany != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localCompany));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("company cannot be null!!");
+ }
+ } if (localLocaleTracker){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/user",
+ "locale"));
+
+ if (localLocale != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localLocale));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("locale cannot be null!!");
+ }
+ } if (localTimezoneTracker){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/user",
+ "timezone"));
+
+ if (localTimezone != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localTimezone));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("timezone cannot be null!!");
+ }
+ } if (localPhoneTracker){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/user",
+ "phone"));
+
+ if (localPhone != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localPhone));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("phone cannot be null!!");
+ }
+ } if (localFaxTracker){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/user",
+ "fax"));
+
+ if (localFax != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localFax));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("fax cannot be null!!");
+ }
+ } if (localMobileTracker){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/user",
+ "mobile"));
+
+ if (localMobile != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localMobile));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("mobile cannot be null!!");
+ }
+ } if (localCountryTracker){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/user",
+ "country"));
+
+ if (localCountry != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localCountry));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("country cannot be null!!");
+ }
+ } if (localZipTracker){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/user",
+ "zip"));
+
+ if (localZip != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localZip));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("zip cannot be null!!");
+ }
+ } if (localCityTracker){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/user",
+ "city"));
+
+ if (localCity != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localCity));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("city cannot be null!!");
+ }
+ } if (localStreetTracker){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/user",
+ "street"));
+
+ if (localStreet != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localStreet));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("street cannot be null!!");
+ }
+ } if (localPcstateTracker){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/user",
+ "pcstate"));
+
+ if (localPcstate != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localPcstate));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("pcstate cannot be null!!");
+ }
+ } if (localTechnicalnoteTracker){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/user",
+ "technicalnote"));
+
+ if (localTechnicalnote != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localTechnicalnote));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("technicalnote cannot be null!!");
+ }
+ }
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static Completeusertype parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ Completeusertype object =
+ new Completeusertype();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"completeusertype".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (Completeusertype)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/user","id").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setId(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToInt(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/user","username").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setUsername(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/user","title").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setTitle(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/user","surname").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setSurname(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/user","firstname").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setFirstname(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/user","email").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setEmail(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/user","company").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setCompany(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/user","locale").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setLocale(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/user","timezone").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setTimezone(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/user","phone").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setPhone(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/user","fax").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setFax(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/user","mobile").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setMobile(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/user","country").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setCountry(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/user","zip").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setZip(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/user","city").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setCity(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/user","street").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setStreet(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/user","pcstate").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setPcstate(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/user","technicalnote").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setTechnicalnote(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class Userlist
+ implements org.apache.axis2.databinding.ADBBean{
+ /* This type was generated from the piece of schema that had
+ name = userlist
+ Namespace URI = http://www.vitero.de/schema/user
+ Namespace Prefix = ns1
+ */
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/user")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for User
+ * This was an Array!
+ */
+
+
+ protected Usertype[] localUser ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localUserTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return Usertype[]
+ */
+ public Usertype[] getUser(){
+ return localUser;
+ }
+
+
+
+
+
+
+ /**
+ * validate the array for User
+ */
+ protected void validateUser(Usertype[] param){
+
+ }
+
+
+ /**
+ * Auto generated setter method
+ * @param param User
+ */
+ public void setUser(Usertype[] param){
+
+ validateUser(param);
+
+
+ if (param != null){
+ //update the setting tracker
+ localUserTracker = true;
+ } else {
+ localUserTracker = false;
+
+ }
+
+ this.localUser=param;
+ }
+
+
+
+ /**
+ * Auto generated add method for the array for convenience
+ * @param param Usertype
+ */
+ public void addUser(Usertype param){
+ if (localUser == null){
+ localUser = new Usertype[]{};
+ }
+
+
+ //update the setting tracker
+ localUserTracker = true;
+
+
+ java.util.List list =
+ org.apache.axis2.databinding.utils.ConverterUtil.toList(localUser);
+ list.add(param);
+ this.localUser =
+ (Usertype[])list.toArray(
+ new Usertype[list.size()]);
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,parentQName){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ Userlist.this.serialize(parentQName,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ parentQName,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/user");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":userlist",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "userlist",
+ xmlWriter);
+ }
+
+
+ }
+ if (localUserTracker){
+ if (localUser!=null){
+ for (int i = 0;i < localUser.length;i++){
+ if (localUser[i] != null){
+ localUser[i].serialize(new javax.xml.namespace.QName("http://www.vitero.de/schema/user","user"),
+ factory,xmlWriter);
+ } else {
+
+ // we don't have to do any thing since minOccures is zero
+
+ }
+
+ }
+ } else {
+
+ throw new org.apache.axis2.databinding.ADBException("user cannot be null!!");
+
+ }
+ }
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+ if (localUserTracker){
+ if (localUser!=null) {
+ for (int i = 0;i < localUser.length;i++){
+
+ if (localUser[i] != null){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/user",
+ "user"));
+ elementList.add(localUser[i]);
+ } else {
+
+ // nothing to do
+
+ }
+
+ }
+ } else {
+
+ throw new org.apache.axis2.databinding.ADBException("user cannot be null!!");
+
+ }
+
+ }
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static Userlist parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ Userlist object =
+ new Userlist();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"userlist".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (Userlist)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+ java.util.ArrayList list1 = new java.util.ArrayList();
+
+
+ while (!reader.isStartElement() && !reader.isEndElement()) reader.next();
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/user","user").equals(reader.getName())){
+
+
+
+ // Process the array and step past its final element's end.
+ list1.add(Usertype.Factory.parse(reader));
+
+ //loop until we find a start element that is not part of this array
+ boolean loopDone1 = false;
+ while(!loopDone1){
+ // We should be at the end element, but make sure
+ while (!reader.isEndElement())
+ reader.next();
+ // Step out of this element
+ reader.next();
+ // Step to next element event.
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+ if (reader.isEndElement()){
+ //two continuous end elements means we are exiting the xml structure
+ loopDone1 = true;
+ } else {
+ if (new javax.xml.namespace.QName("http://www.vitero.de/schema/user","user").equals(reader.getName())){
+ list1.add(Usertype.Factory.parse(reader));
+
+ }else{
+ loopDone1 = true;
+ }
+ }
+ }
+ // call the converter utility to convert and set the array
+
+ object.setUser((Usertype[])
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToArray(
+ Usertype.class,
+ list1));
+
+ } // End of if for expected property start element
+
+ else {
+
+ }
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+ if (reader.isStartElement())
+ // A start element we are not expecting indicates a trailing invalid property
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class GetUserResponse
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/user",
+ "getUserResponse",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/user")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for User
+ */
+
+
+ protected Completeuserwithcustomertype localUser ;
+
+
+ /**
+ * Auto generated getter method
+ * @return Completeuserwithcustomertype
+ */
+ public Completeuserwithcustomertype getUser(){
+ return localUser;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param User
+ */
+ public void setUser(Completeuserwithcustomertype param){
+
+ this.localUser=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ GetUserResponse.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/user");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":getUserResponse",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "getUserResponse",
+ xmlWriter);
+ }
+
+
+ }
+
+ if (localUser==null){
+ throw new org.apache.axis2.databinding.ADBException("user cannot be null!!");
+ }
+ localUser.serialize(new javax.xml.namespace.QName("http://www.vitero.de/schema/user","user"),
+ factory,xmlWriter);
+
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/user",
+ "user"));
+
+
+ if (localUser==null){
+ throw new org.apache.axis2.databinding.ADBException("user cannot be null!!");
+ }
+ elementList.add(localUser);
+
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static GetUserResponse parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ GetUserResponse object =
+ new GetUserResponse();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"getUserResponse".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (GetUserResponse)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/user","user").equals(reader.getName())){
+
+ object.setUser(Completeuserwithcustomertype.Factory.parse(reader));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class SuccessResponse
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/user",
+ "successResponse",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/user")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for Request
+ */
+
+
+ protected java.lang.String localRequest ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getRequest(){
+ return localRequest;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Request
+ */
+ public void setRequest(java.lang.String param){
+
+ this.localRequest=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ SuccessResponse.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/user");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":successResponse",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "successResponse",
+ xmlWriter);
+ }
+
+
+ }
+
+ namespace = "http://www.vitero.de/schema/user";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"request", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"request");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("request");
+ }
+
+
+ if (localRequest==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("request cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localRequest);
+
+ }
+
+ xmlWriter.writeEndElement();
+
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/user",
+ "request"));
+
+ if (localRequest != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localRequest));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("request cannot be null!!");
+ }
+
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static SuccessResponse parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ SuccessResponse object =
+ new SuccessResponse();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"successResponse".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (SuccessResponse)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/user","request").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setRequest(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class GetUserListByCustomerResponse
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/user",
+ "getUserListByCustomerResponse",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/user")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for GetUserListByCustomerResponse
+ */
+
+
+ protected Userlist localGetUserListByCustomerResponse ;
+
+
+ /**
+ * Auto generated getter method
+ * @return Userlist
+ */
+ public Userlist getGetUserListByCustomerResponse(){
+ return localGetUserListByCustomerResponse;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param GetUserListByCustomerResponse
+ */
+ public void setGetUserListByCustomerResponse(Userlist param){
+
+ this.localGetUserListByCustomerResponse=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ GetUserListByCustomerResponse.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+ //We can safely assume an element has only one type associated with it
+
+ if (localGetUserListByCustomerResponse==null){
+ throw new org.apache.axis2.databinding.ADBException("Property cannot be null!");
+ }
+ localGetUserListByCustomerResponse.serialize(MY_QNAME,factory,xmlWriter);
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+
+ //We can safely assume an element has only one type associated with it
+ return localGetUserListByCustomerResponse.getPullParser(MY_QNAME);
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static GetUserListByCustomerResponse parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ GetUserListByCustomerResponse object =
+ new GetUserListByCustomerResponse();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/user","getUserListByCustomerResponse").equals(reader.getName())){
+
+ object.setGetUserListByCustomerResponse(Userlist.Factory.parse(reader));
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class GetUserListByPositionResponse
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/user",
+ "getUserListByPositionResponse",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/user")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for GetUserListByPositionResponse
+ */
+
+
+ protected Userlist localGetUserListByPositionResponse ;
+
+
+ /**
+ * Auto generated getter method
+ * @return Userlist
+ */
+ public Userlist getGetUserListByPositionResponse(){
+ return localGetUserListByPositionResponse;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param GetUserListByPositionResponse
+ */
+ public void setGetUserListByPositionResponse(Userlist param){
+
+ this.localGetUserListByPositionResponse=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ GetUserListByPositionResponse.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+ //We can safely assume an element has only one type associated with it
+
+ if (localGetUserListByPositionResponse==null){
+ throw new org.apache.axis2.databinding.ADBException("Property cannot be null!");
+ }
+ localGetUserListByPositionResponse.serialize(MY_QNAME,factory,xmlWriter);
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+
+ //We can safely assume an element has only one type associated with it
+ return localGetUserListByPositionResponse.getPullParser(MY_QNAME);
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static GetUserListByPositionResponse parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ GetUserListByPositionResponse object =
+ new GetUserListByPositionResponse();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/user","getUserListByPositionResponse").equals(reader.getName())){
+
+ object.setGetUserListByPositionResponse(Userlist.Factory.parse(reader));
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class Idlist
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/user",
+ "idlist",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/user")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ protected int[] local_int;
+
+ public int[] get_int(){
+ return local_int;
+ }
+
+ public void set_int(int[] itemList){
+ this.local_int = itemList;
+ }
+
+ public java.lang.String toString() {
+ java.lang.StringBuffer outString = new java.lang.StringBuffer();
+ if (local_int != null){
+ for(int i = 0; i < local_int.length;i++){
+
+ outString.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(local_int[i])).append(" ");
+
+
+ }
+ }
+ return outString.toString().trim();
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ Idlist.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+ // first write the start element
+ java.lang.String namespace = parentQName.getNamespaceURI();
+ java.lang.String localName = parentQName.getLocalPart();
+
+ if (! namespace.equals("")) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix, localName, namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace, localName);
+ }
+
+ } else {
+ xmlWriter.writeStartElement(localName);
+ }
+
+
+ xmlWriter.writeCharacters(Idlist.this.toString());
+
+
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(MY_QNAME,
+ new java.lang.Object[]{
+ org.apache.axis2.databinding.utils.reader.ADBXMLStreamReader.ELEMENT_TEXT,
+ toString()
+ },
+ null);
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+
+ public static Idlist fromString(javax.xml.stream.XMLStreamReader xmlStreamReader,
+ java.lang.String content)
+ throws org.apache.axis2.databinding.ADBException {
+
+ Idlist object = new Idlist();
+ java.lang.String[] values = content.split(" +");
+ int[] objectValues = new int[values.length];
+
+
+
+
+ try {
+ for (int i = 0; i < values.length; i++) {
+
+ objectValues[i] =
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToInt(values[i]);
+
+
+ }
+ object.set_int(objectValues);
+ return object;
+ } catch (java.lang.Exception e) {
+ throw new org.apache.axis2.databinding.ADBException();
+ }
+
+ }
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static Idlist parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ Idlist object =
+ new Idlist();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ java.lang.String content = reader.getElementText();
+ object = Idlist.Factory.fromString(reader,content);
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class ExtensionMapper{
+
+ public static java.lang.Object getTypeObject(java.lang.String namespaceURI,
+ java.lang.String typeName,
+ javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+
+
+ if (
+ "http://www.vitero.de/schema/user".equals(namespaceURI) &&
+ "completeusertype".equals(typeName)){
+
+ return Completeusertype.Factory.parse(reader);
+
+
+ }
+
+
+ if (
+ "http://www.vitero.de/schema/user".equals(namespaceURI) &&
+ "userlist".equals(typeName)){
+
+ return Userlist.Factory.parse(reader);
+
+
+ }
+
+
+ if (
+ "http://www.vitero.de/schema/user".equals(namespaceURI) &&
+ "customer_type0".equals(typeName)){
+
+ return Customer_type0.Factory.parse(reader);
+
+
+ }
+
+
+ if (
+ "http://www.vitero.de/schema/user".equals(namespaceURI) &&
+ "userid".equals(typeName)){
+
+ return Userid.Factory.parse(reader);
+
+
+ }
+
+
+ if (
+ "http://www.vitero.de/schema/user".equals(namespaceURI) &&
+ "completeuserwithcustomertype".equals(typeName)){
+
+ return Completeuserwithcustomertype.Factory.parse(reader);
+
+
+ }
+
+
+ if (
+ "http://www.vitero.de/schema/user".equals(namespaceURI) &&
+ "usertype".equals(typeName)){
+
+ return Usertype.Factory.parse(reader);
+
+
+ }
+
+
+ if (
+ "http://www.vitero.de/schema/user".equals(namespaceURI) &&
+ "newusertype".equals(typeName)){
+
+ return Newusertype.Factory.parse(reader);
+
+
+ }
+
+
+ if (
+ "http://www.vitero.de/schema/user".equals(namespaceURI) &&
+ "idlist".equals(typeName)){
+
+ return Idlist.Factory.parse(reader);
+
+
+ }
+
+
+ throw new org.apache.axis2.databinding.ADBException("Unsupported type " + namespaceURI + " " + typeName);
+ }
+
+ }
+
+ public static class GetUserListByGroupResponse
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/user",
+ "getUserListByGroupResponse",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/user")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for GetUserListByGroupResponse
+ */
+
+
+ protected Userlist localGetUserListByGroupResponse ;
+
+
+ /**
+ * Auto generated getter method
+ * @return Userlist
+ */
+ public Userlist getGetUserListByGroupResponse(){
+ return localGetUserListByGroupResponse;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param GetUserListByGroupResponse
+ */
+ public void setGetUserListByGroupResponse(Userlist param){
+
+ this.localGetUserListByGroupResponse=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ GetUserListByGroupResponse.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+ //We can safely assume an element has only one type associated with it
+
+ if (localGetUserListByGroupResponse==null){
+ throw new org.apache.axis2.databinding.ADBException("Property cannot be null!");
+ }
+ localGetUserListByGroupResponse.serialize(MY_QNAME,factory,xmlWriter);
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+
+ //We can safely assume an element has only one type associated with it
+ return localGetUserListByGroupResponse.getPullParser(MY_QNAME);
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static GetUserListByGroupResponse parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ GetUserListByGroupResponse object =
+ new GetUserListByGroupResponse();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/user","getUserListByGroupResponse").equals(reader.getName())){
+
+ object.setGetUserListByGroupResponse(Userlist.Factory.parse(reader));
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class GetUserListByCustomerRequest
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/user",
+ "getUserListByCustomerRequest",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/user")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for Customerid
+ */
+
+
+ protected int localCustomerid ;
+
+
+ /**
+ * Auto generated getter method
+ * @return int
+ */
+ public int getCustomerid(){
+ return localCustomerid;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Customerid
+ */
+ public void setCustomerid(int param){
+
+ this.localCustomerid=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ GetUserListByCustomerRequest.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/user");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":getUserListByCustomerRequest",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "getUserListByCustomerRequest",
+ xmlWriter);
+ }
+
+
+ }
+
+ namespace = "http://www.vitero.de/schema/user";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"customerid", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"customerid");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("customerid");
+ }
+
+ if (localCustomerid==java.lang.Integer.MIN_VALUE) {
+
+ throw new org.apache.axis2.databinding.ADBException("customerid cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localCustomerid));
+ }
+
+ xmlWriter.writeEndElement();
+
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/user",
+ "customerid"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localCustomerid));
+
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static GetUserListByCustomerRequest parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ GetUserListByCustomerRequest object =
+ new GetUserListByCustomerRequest();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"getUserListByCustomerRequest".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (GetUserListByCustomerRequest)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/user","customerid").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setCustomerid(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToInt(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class Newusertype
+ implements org.apache.axis2.databinding.ADBBean{
+ /* This type was generated from the piece of schema that had
+ name = newusertype
+ Namespace URI = http://www.vitero.de/schema/user
+ Namespace Prefix = ns1
+ */
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/user")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for Username
+ */
+
+
+ protected java.lang.String localUsername ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getUsername(){
+ return localUsername;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Username
+ */
+ public void setUsername(java.lang.String param){
+
+ this.localUsername=param;
+
+
+ }
+
+
+ /**
+ * field for Title
+ */
+
+
+ protected java.lang.String localTitle ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localTitleTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getTitle(){
+ return localTitle;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Title
+ */
+ public void setTitle(java.lang.String param){
+
+ if (param != null){
+ //update the setting tracker
+ localTitleTracker = true;
+ } else {
+ localTitleTracker = false;
+
+ }
+
+ this.localTitle=param;
+
+
+ }
+
+
+ /**
+ * field for Surname
+ */
+
+
+ protected java.lang.String localSurname ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getSurname(){
+ return localSurname;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Surname
+ */
+ public void setSurname(java.lang.String param){
+
+ this.localSurname=param;
+
+
+ }
+
+
+ /**
+ * field for Firstname
+ */
+
+
+ protected java.lang.String localFirstname ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getFirstname(){
+ return localFirstname;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Firstname
+ */
+ public void setFirstname(java.lang.String param){
+
+ this.localFirstname=param;
+
+
+ }
+
+
+ /**
+ * field for Email
+ */
+
+
+ protected java.lang.String localEmail ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getEmail(){
+ return localEmail;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Email
+ */
+ public void setEmail(java.lang.String param){
+
+ this.localEmail=param;
+
+
+ }
+
+
+ /**
+ * field for Company
+ */
+
+
+ protected java.lang.String localCompany ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localCompanyTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getCompany(){
+ return localCompany;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Company
+ */
+ public void setCompany(java.lang.String param){
+
+ if (param != null){
+ //update the setting tracker
+ localCompanyTracker = true;
+ } else {
+ localCompanyTracker = false;
+
+ }
+
+ this.localCompany=param;
+
+
+ }
+
+
+ /**
+ * field for Locale
+ */
+
+
+ protected java.lang.String localLocale ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localLocaleTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getLocale(){
+ return localLocale;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Locale
+ */
+ public void setLocale(java.lang.String param){
+
+ if (param != null){
+ //update the setting tracker
+ localLocaleTracker = true;
+ } else {
+ localLocaleTracker = false;
+
+ }
+
+ this.localLocale=param;
+
+
+ }
+
+
+ /**
+ * field for Timezone
+ */
+
+
+ protected java.lang.String localTimezone ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localTimezoneTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getTimezone(){
+ return localTimezone;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Timezone
+ */
+ public void setTimezone(java.lang.String param){
+
+ if (param != null){
+ //update the setting tracker
+ localTimezoneTracker = true;
+ } else {
+ localTimezoneTracker = false;
+
+ }
+
+ this.localTimezone=param;
+
+
+ }
+
+
+ /**
+ * field for Phone
+ */
+
+
+ protected java.lang.String localPhone ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localPhoneTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getPhone(){
+ return localPhone;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Phone
+ */
+ public void setPhone(java.lang.String param){
+
+ if (param != null){
+ //update the setting tracker
+ localPhoneTracker = true;
+ } else {
+ localPhoneTracker = false;
+
+ }
+
+ this.localPhone=param;
+
+
+ }
+
+
+ /**
+ * field for Fax
+ */
+
+
+ protected java.lang.String localFax ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localFaxTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getFax(){
+ return localFax;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Fax
+ */
+ public void setFax(java.lang.String param){
+
+ if (param != null){
+ //update the setting tracker
+ localFaxTracker = true;
+ } else {
+ localFaxTracker = false;
+
+ }
+
+ this.localFax=param;
+
+
+ }
+
+
+ /**
+ * field for Mobile
+ */
+
+
+ protected java.lang.String localMobile ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localMobileTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getMobile(){
+ return localMobile;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Mobile
+ */
+ public void setMobile(java.lang.String param){
+
+ if (param != null){
+ //update the setting tracker
+ localMobileTracker = true;
+ } else {
+ localMobileTracker = false;
+
+ }
+
+ this.localMobile=param;
+
+
+ }
+
+
+ /**
+ * field for Country
+ */
+
+
+ protected java.lang.String localCountry ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localCountryTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getCountry(){
+ return localCountry;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Country
+ */
+ public void setCountry(java.lang.String param){
+
+ if (param != null){
+ //update the setting tracker
+ localCountryTracker = true;
+ } else {
+ localCountryTracker = false;
+
+ }
+
+ this.localCountry=param;
+
+
+ }
+
+
+ /**
+ * field for Zip
+ */
+
+
+ protected java.lang.String localZip ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localZipTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getZip(){
+ return localZip;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Zip
+ */
+ public void setZip(java.lang.String param){
+
+ if (param != null){
+ //update the setting tracker
+ localZipTracker = true;
+ } else {
+ localZipTracker = false;
+
+ }
+
+ this.localZip=param;
+
+
+ }
+
+
+ /**
+ * field for City
+ */
+
+
+ protected java.lang.String localCity ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localCityTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getCity(){
+ return localCity;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param City
+ */
+ public void setCity(java.lang.String param){
+
+ if (param != null){
+ //update the setting tracker
+ localCityTracker = true;
+ } else {
+ localCityTracker = false;
+
+ }
+
+ this.localCity=param;
+
+
+ }
+
+
+ /**
+ * field for Street
+ */
+
+
+ protected java.lang.String localStreet ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localStreetTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getStreet(){
+ return localStreet;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Street
+ */
+ public void setStreet(java.lang.String param){
+
+ if (param != null){
+ //update the setting tracker
+ localStreetTracker = true;
+ } else {
+ localStreetTracker = false;
+
+ }
+
+ this.localStreet=param;
+
+
+ }
+
+
+ /**
+ * field for Pcstate
+ */
+
+
+ protected java.lang.String localPcstate ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localPcstateTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getPcstate(){
+ return localPcstate;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Pcstate
+ */
+ public void setPcstate(java.lang.String param){
+
+ if (param != null){
+ //update the setting tracker
+ localPcstateTracker = true;
+ } else {
+ localPcstateTracker = false;
+
+ }
+
+ this.localPcstate=param;
+
+
+ }
+
+
+ /**
+ * field for Technicalnote
+ */
+
+
+ protected java.lang.String localTechnicalnote ;
+
+ /* This tracker boolean wil be used to detect whether the user called the set method
+ * for this attribute. It will be used to determine whether to include this field
+ * in the serialized XML
+ */
+ protected boolean localTechnicalnoteTracker = false ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getTechnicalnote(){
+ return localTechnicalnote;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Technicalnote
+ */
+ public void setTechnicalnote(java.lang.String param){
+
+ if (param != null){
+ //update the setting tracker
+ localTechnicalnoteTracker = true;
+ } else {
+ localTechnicalnoteTracker = false;
+
+ }
+
+ this.localTechnicalnote=param;
+
+
+ }
+
+
+ /**
+ * field for Password
+ */
+
+
+ protected java.lang.String localPassword ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getPassword(){
+ return localPassword;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Password
+ */
+ public void setPassword(java.lang.String param){
+
+ this.localPassword=param;
+
+
+ }
+
+
+ /**
+ * field for Customeridlist
+ */
+
+
+ protected Idlist localCustomeridlist ;
+
+
+ /**
+ * Auto generated getter method
+ * @return Idlist
+ */
+ public Idlist getCustomeridlist(){
+ return localCustomeridlist;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Customeridlist
+ */
+ public void setCustomeridlist(Idlist param){
+
+ this.localCustomeridlist=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,parentQName){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ Newusertype.this.serialize(parentQName,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ parentQName,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/user");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":newusertype",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "newusertype",
+ xmlWriter);
+ }
+
+
+ }
+
+ namespace = "http://www.vitero.de/schema/user";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"username", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"username");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("username");
+ }
+
+
+ if (localUsername==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("username cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localUsername);
+
+ }
+
+ xmlWriter.writeEndElement();
+ if (localTitleTracker){
+ namespace = "http://www.vitero.de/schema/user";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"title", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"title");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("title");
+ }
+
+
+ if (localTitle==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("title cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localTitle);
+
+ }
+
+ xmlWriter.writeEndElement();
+ }
+ namespace = "http://www.vitero.de/schema/user";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"surname", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"surname");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("surname");
+ }
+
+
+ if (localSurname==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("surname cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localSurname);
+
+ }
+
+ xmlWriter.writeEndElement();
+
+ namespace = "http://www.vitero.de/schema/user";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"firstname", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"firstname");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("firstname");
+ }
+
+
+ if (localFirstname==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("firstname cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localFirstname);
+
+ }
+
+ xmlWriter.writeEndElement();
+
+ namespace = "http://www.vitero.de/schema/user";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"email", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"email");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("email");
+ }
+
+
+ if (localEmail==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("email cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localEmail);
+
+ }
+
+ xmlWriter.writeEndElement();
+ if (localCompanyTracker){
+ namespace = "http://www.vitero.de/schema/user";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"company", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"company");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("company");
+ }
+
+
+ if (localCompany==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("company cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localCompany);
+
+ }
+
+ xmlWriter.writeEndElement();
+ } if (localLocaleTracker){
+ namespace = "http://www.vitero.de/schema/user";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"locale", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"locale");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("locale");
+ }
+
+
+ if (localLocale==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("locale cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localLocale);
+
+ }
+
+ xmlWriter.writeEndElement();
+ } if (localTimezoneTracker){
+ namespace = "http://www.vitero.de/schema/user";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"timezone", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"timezone");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("timezone");
+ }
+
+
+ if (localTimezone==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("timezone cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localTimezone);
+
+ }
+
+ xmlWriter.writeEndElement();
+ } if (localPhoneTracker){
+ namespace = "http://www.vitero.de/schema/user";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"phone", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"phone");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("phone");
+ }
+
+
+ if (localPhone==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("phone cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localPhone);
+
+ }
+
+ xmlWriter.writeEndElement();
+ } if (localFaxTracker){
+ namespace = "http://www.vitero.de/schema/user";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"fax", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"fax");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("fax");
+ }
+
+
+ if (localFax==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("fax cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localFax);
+
+ }
+
+ xmlWriter.writeEndElement();
+ } if (localMobileTracker){
+ namespace = "http://www.vitero.de/schema/user";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"mobile", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"mobile");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("mobile");
+ }
+
+
+ if (localMobile==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("mobile cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localMobile);
+
+ }
+
+ xmlWriter.writeEndElement();
+ } if (localCountryTracker){
+ namespace = "http://www.vitero.de/schema/user";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"country", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"country");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("country");
+ }
+
+
+ if (localCountry==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("country cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localCountry);
+
+ }
+
+ xmlWriter.writeEndElement();
+ } if (localZipTracker){
+ namespace = "http://www.vitero.de/schema/user";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"zip", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"zip");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("zip");
+ }
+
+
+ if (localZip==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("zip cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localZip);
+
+ }
+
+ xmlWriter.writeEndElement();
+ } if (localCityTracker){
+ namespace = "http://www.vitero.de/schema/user";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"city", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"city");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("city");
+ }
+
+
+ if (localCity==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("city cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localCity);
+
+ }
+
+ xmlWriter.writeEndElement();
+ } if (localStreetTracker){
+ namespace = "http://www.vitero.de/schema/user";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"street", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"street");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("street");
+ }
+
+
+ if (localStreet==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("street cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localStreet);
+
+ }
+
+ xmlWriter.writeEndElement();
+ } if (localPcstateTracker){
+ namespace = "http://www.vitero.de/schema/user";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"pcstate", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"pcstate");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("pcstate");
+ }
+
+
+ if (localPcstate==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("pcstate cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localPcstate);
+
+ }
+
+ xmlWriter.writeEndElement();
+ } if (localTechnicalnoteTracker){
+ namespace = "http://www.vitero.de/schema/user";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"technicalnote", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"technicalnote");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("technicalnote");
+ }
+
+
+ if (localTechnicalnote==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("technicalnote cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localTechnicalnote);
+
+ }
+
+ xmlWriter.writeEndElement();
+ }
+ namespace = "http://www.vitero.de/schema/user";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"password", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"password");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("password");
+ }
+
+
+ if (localPassword==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("password cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localPassword);
+
+ }
+
+ xmlWriter.writeEndElement();
+
+ if (localCustomeridlist==null){
+ throw new org.apache.axis2.databinding.ADBException("customeridlist cannot be null!!");
+ }
+ localCustomeridlist.serialize(new javax.xml.namespace.QName("http://www.vitero.de/schema/user","customeridlist"),
+ factory,xmlWriter);
+
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/user",
+ "username"));
+
+ if (localUsername != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localUsername));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("username cannot be null!!");
+ }
+ if (localTitleTracker){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/user",
+ "title"));
+
+ if (localTitle != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localTitle));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("title cannot be null!!");
+ }
+ }
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/user",
+ "surname"));
+
+ if (localSurname != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localSurname));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("surname cannot be null!!");
+ }
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/user",
+ "firstname"));
+
+ if (localFirstname != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localFirstname));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("firstname cannot be null!!");
+ }
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/user",
+ "email"));
+
+ if (localEmail != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localEmail));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("email cannot be null!!");
+ }
+ if (localCompanyTracker){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/user",
+ "company"));
+
+ if (localCompany != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localCompany));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("company cannot be null!!");
+ }
+ } if (localLocaleTracker){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/user",
+ "locale"));
+
+ if (localLocale != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localLocale));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("locale cannot be null!!");
+ }
+ } if (localTimezoneTracker){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/user",
+ "timezone"));
+
+ if (localTimezone != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localTimezone));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("timezone cannot be null!!");
+ }
+ } if (localPhoneTracker){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/user",
+ "phone"));
+
+ if (localPhone != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localPhone));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("phone cannot be null!!");
+ }
+ } if (localFaxTracker){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/user",
+ "fax"));
+
+ if (localFax != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localFax));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("fax cannot be null!!");
+ }
+ } if (localMobileTracker){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/user",
+ "mobile"));
+
+ if (localMobile != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localMobile));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("mobile cannot be null!!");
+ }
+ } if (localCountryTracker){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/user",
+ "country"));
+
+ if (localCountry != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localCountry));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("country cannot be null!!");
+ }
+ } if (localZipTracker){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/user",
+ "zip"));
+
+ if (localZip != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localZip));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("zip cannot be null!!");
+ }
+ } if (localCityTracker){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/user",
+ "city"));
+
+ if (localCity != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localCity));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("city cannot be null!!");
+ }
+ } if (localStreetTracker){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/user",
+ "street"));
+
+ if (localStreet != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localStreet));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("street cannot be null!!");
+ }
+ } if (localPcstateTracker){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/user",
+ "pcstate"));
+
+ if (localPcstate != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localPcstate));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("pcstate cannot be null!!");
+ }
+ } if (localTechnicalnoteTracker){
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/user",
+ "technicalnote"));
+
+ if (localTechnicalnote != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localTechnicalnote));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("technicalnote cannot be null!!");
+ }
+ }
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/user",
+ "password"));
+
+ if (localPassword != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localPassword));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("password cannot be null!!");
+ }
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/user",
+ "customeridlist"));
+
+
+ if (localCustomeridlist==null){
+ throw new org.apache.axis2.databinding.ADBException("customeridlist cannot be null!!");
+ }
+ elementList.add(localCustomeridlist);
+
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static Newusertype parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ Newusertype object =
+ new Newusertype();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"newusertype".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (Newusertype)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/user","username").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setUsername(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/user","title").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setTitle(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/user","surname").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setSurname(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/user","firstname").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setFirstname(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/user","email").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setEmail(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/user","company").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setCompany(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/user","locale").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setLocale(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/user","timezone").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setTimezone(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/user","phone").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setPhone(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/user","fax").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setFax(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/user","mobile").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setMobile(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/user","country").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setCountry(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/user","zip").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setZip(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/user","city").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setCity(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/user","street").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setStreet(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/user","pcstate").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setPcstate(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/user","technicalnote").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setTechnicalnote(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/user","password").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setPassword(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/user","customeridlist").equals(reader.getName())){
+
+ object.setCustomeridlist(Idlist.Factory.parse(reader));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class UpdateUserRequest
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/user",
+ "updateUserRequest",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/user")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for User
+ */
+
+
+ protected Completeusertype localUser ;
+
+
+ /**
+ * Auto generated getter method
+ * @return Completeusertype
+ */
+ public Completeusertype getUser(){
+ return localUser;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param User
+ */
+ public void setUser(Completeusertype param){
+
+ this.localUser=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ UpdateUserRequest.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/user");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":updateUserRequest",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "updateUserRequest",
+ xmlWriter);
+ }
+
+
+ }
+
+ if (localUser==null){
+ throw new org.apache.axis2.databinding.ADBException("user cannot be null!!");
+ }
+ localUser.serialize(new javax.xml.namespace.QName("http://www.vitero.de/schema/user","user"),
+ factory,xmlWriter);
+
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/user",
+ "user"));
+
+
+ if (localUser==null){
+ throw new org.apache.axis2.databinding.ADBException("user cannot be null!!");
+ }
+ elementList.add(localUser);
+
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static UpdateUserRequest parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ UpdateUserRequest object =
+ new UpdateUserRequest();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"updateUserRequest".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (UpdateUserRequest)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/user","user").equals(reader.getName())){
+
+ object.setUser(Completeusertype.Factory.parse(reader));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class GetUserListByPositionRequest
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/user",
+ "getUserListByPositionRequest",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/user")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for Firstposition
+ */
+
+
+ protected int localFirstposition ;
+
+
+ /**
+ * Auto generated getter method
+ * @return int
+ */
+ public int getFirstposition(){
+ return localFirstposition;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Firstposition
+ */
+ public void setFirstposition(int param){
+
+ this.localFirstposition=param;
+
+
+ }
+
+
+ /**
+ * field for Lastposition
+ */
+
+
+ protected int localLastposition ;
+
+
+ /**
+ * Auto generated getter method
+ * @return int
+ */
+ public int getLastposition(){
+ return localLastposition;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Lastposition
+ */
+ public void setLastposition(int param){
+
+ this.localLastposition=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ GetUserListByPositionRequest.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/user");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":getUserListByPositionRequest",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "getUserListByPositionRequest",
+ xmlWriter);
+ }
+
+
+ }
+
+ namespace = "http://www.vitero.de/schema/user";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"firstposition", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"firstposition");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("firstposition");
+ }
+
+ if (localFirstposition==java.lang.Integer.MIN_VALUE) {
+
+ throw new org.apache.axis2.databinding.ADBException("firstposition cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localFirstposition));
+ }
+
+ xmlWriter.writeEndElement();
+
+ namespace = "http://www.vitero.de/schema/user";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"lastposition", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"lastposition");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("lastposition");
+ }
+
+ if (localLastposition==java.lang.Integer.MIN_VALUE) {
+
+ throw new org.apache.axis2.databinding.ADBException("lastposition cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localLastposition));
+ }
+
+ xmlWriter.writeEndElement();
+
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/user",
+ "firstposition"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localFirstposition));
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/user",
+ "lastposition"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localLastposition));
+
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static GetUserListByPositionRequest parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ GetUserListByPositionRequest object =
+ new GetUserListByPositionRequest();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"getUserListByPositionRequest".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (GetUserListByPositionRequest)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/user","firstposition").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setFirstposition(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToInt(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/user","lastposition").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setLastposition(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToInt(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class Userid
+ implements org.apache.axis2.databinding.ADBBean{
+ /* This type was generated from the piece of schema that had
+ name = userid
+ Namespace URI = http://www.vitero.de/schema/user
+ Namespace Prefix = ns1
+ */
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/user")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for Userid
+ */
+
+
+ protected int localUserid ;
+
+
+ /**
+ * Auto generated getter method
+ * @return int
+ */
+ public int getUserid(){
+ return localUserid;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Userid
+ */
+ public void setUserid(int param){
+
+ this.localUserid=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,parentQName){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ Userid.this.serialize(parentQName,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ parentQName,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/user");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":userid",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "userid",
+ xmlWriter);
+ }
+
+
+ }
+
+ namespace = "http://www.vitero.de/schema/user";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"userid", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"userid");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("userid");
+ }
+
+ if (localUserid==java.lang.Integer.MIN_VALUE) {
+
+ throw new org.apache.axis2.databinding.ADBException("userid cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localUserid));
+ }
+
+ xmlWriter.writeEndElement();
+
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/user",
+ "userid"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localUserid));
+
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static Userid parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ Userid object =
+ new Userid();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"userid".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (Userid)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/user","userid").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setUserid(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToInt(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class GetUserListByGroupRequest
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/user",
+ "getUserListByGroupRequest",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/user")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for Groupid
+ */
+
+
+ protected int localGroupid ;
+
+
+ /**
+ * Auto generated getter method
+ * @return int
+ */
+ public int getGroupid(){
+ return localGroupid;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Groupid
+ */
+ public void setGroupid(int param){
+
+ this.localGroupid=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ GetUserListByGroupRequest.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/user");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":getUserListByGroupRequest",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "getUserListByGroupRequest",
+ xmlWriter);
+ }
+
+
+ }
+
+ namespace = "http://www.vitero.de/schema/user";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"groupid", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"groupid");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("groupid");
+ }
+
+ if (localGroupid==java.lang.Integer.MIN_VALUE) {
+
+ throw new org.apache.axis2.databinding.ADBException("groupid cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localGroupid));
+ }
+
+ xmlWriter.writeEndElement();
+
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/user",
+ "groupid"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localGroupid));
+
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static GetUserListByGroupRequest parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ GetUserListByGroupRequest object =
+ new GetUserListByGroupRequest();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"getUserListByGroupRequest".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (GetUserListByGroupRequest)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/user","groupid").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setGroupid(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToInt(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class GetUserListRequest
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/user",
+ "getUserListRequest",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/user")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for GetUserListRequest
+ */
+
+
+ protected org.apache.axiom.om.OMElement localGetUserListRequest ;
+
+
+ /**
+ * Auto generated getter method
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getGetUserListRequest(){
+ return localGetUserListRequest;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param GetUserListRequest
+ */
+ public void setGetUserListRequest(org.apache.axiom.om.OMElement param){
+
+ this.localGetUserListRequest=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ GetUserListRequest.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+ //We can safely assume an element has only one type associated with it
+
+ java.lang.String namespace = "http://www.vitero.de/schema/user";
+ java.lang.String localName = "getUserListRequest";
+
+ if (! namespace.equals("")) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix, localName, namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace, localName);
+ }
+
+ } else {
+ xmlWriter.writeStartElement(localName);
+ }
+
+ // add the type details if this is used in a simple type
+ if (serializeType){
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/user");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":getUserListRequest",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "getUserListRequest",
+ xmlWriter);
+ }
+ }
+
+ if (localGetUserListRequest==null){
+
+ throw new org.apache.axis2.databinding.ADBException("Value cannot be null !!");
+
+ }else{
+ localGetUserListRequest.serialize(xmlWriter);
+
+ }
+
+ xmlWriter.writeEndElement();
+
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+
+ //We can safely assume an element has only one type associated with it
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(MY_QNAME,
+ new java.lang.Object[]{
+ org.apache.axis2.databinding.utils.reader.ADBXMLStreamReader.ELEMENT_TEXT,
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localGetUserListRequest)
+ },
+ null);
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static GetUserListRequest parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ GetUserListRequest object =
+ new GetUserListRequest();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement()){
+
+
+
+ //use the QName from the parser as the name for the builder
+ javax.xml.namespace.QName startQname1 = reader.getName();
+
+ // We need to wrap the reader so that it produces a fake START_DOCUMENT event
+ // this is needed by the builder classes
+ org.apache.axis2.databinding.utils.NamedStaxOMBuilder builder1 =
+ new org.apache.axis2.databinding.utils.NamedStaxOMBuilder(
+ new org.apache.axis2.util.StreamWrapper(reader),startQname1);
+ object.setGetUserListRequest(builder1.getOMElement());
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class CreateUserResponse
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/user",
+ "createUserResponse",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/user")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for CreateUserResponse
+ */
+
+
+ protected Userid localCreateUserResponse ;
+
+
+ /**
+ * Auto generated getter method
+ * @return Userid
+ */
+ public Userid getCreateUserResponse(){
+ return localCreateUserResponse;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param CreateUserResponse
+ */
+ public void setCreateUserResponse(Userid param){
+
+ this.localCreateUserResponse=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ CreateUserResponse.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+ //We can safely assume an element has only one type associated with it
+
+ if (localCreateUserResponse==null){
+ throw new org.apache.axis2.databinding.ADBException("Property cannot be null!");
+ }
+ localCreateUserResponse.serialize(MY_QNAME,factory,xmlWriter);
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+
+ //We can safely assume an element has only one type associated with it
+ return localCreateUserResponse.getPullParser(MY_QNAME);
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static CreateUserResponse parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ CreateUserResponse object =
+ new CreateUserResponse();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/user","createUserResponse").equals(reader.getName())){
+
+ object.setCreateUserResponse(Userid.Factory.parse(reader));
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class GetUserCountRequest
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/user",
+ "getUserCountRequest",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/user")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for GetUserCountRequest
+ */
+
+
+ protected org.apache.axiom.om.OMElement localGetUserCountRequest ;
+
+
+ /**
+ * Auto generated getter method
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getGetUserCountRequest(){
+ return localGetUserCountRequest;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param GetUserCountRequest
+ */
+ public void setGetUserCountRequest(org.apache.axiom.om.OMElement param){
+
+ this.localGetUserCountRequest=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ GetUserCountRequest.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+ //We can safely assume an element has only one type associated with it
+
+ java.lang.String namespace = "http://www.vitero.de/schema/user";
+ java.lang.String localName = "getUserCountRequest";
+
+ if (! namespace.equals("")) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix, localName, namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace, localName);
+ }
+
+ } else {
+ xmlWriter.writeStartElement(localName);
+ }
+
+ // add the type details if this is used in a simple type
+ if (serializeType){
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/user");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":getUserCountRequest",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "getUserCountRequest",
+ xmlWriter);
+ }
+ }
+
+ if (localGetUserCountRequest==null){
+
+ throw new org.apache.axis2.databinding.ADBException("Value cannot be null !!");
+
+ }else{
+ localGetUserCountRequest.serialize(xmlWriter);
+
+ }
+
+ xmlWriter.writeEndElement();
+
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+
+ //We can safely assume an element has only one type associated with it
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(MY_QNAME,
+ new java.lang.Object[]{
+ org.apache.axis2.databinding.utils.reader.ADBXMLStreamReader.ELEMENT_TEXT,
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localGetUserCountRequest)
+ },
+ null);
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static GetUserCountRequest parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ GetUserCountRequest object =
+ new GetUserCountRequest();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement()){
+
+
+
+ //use the QName from the parser as the name for the builder
+ javax.xml.namespace.QName startQname1 = reader.getName();
+
+ // We need to wrap the reader so that it produces a fake START_DOCUMENT event
+ // this is needed by the builder classes
+ org.apache.axis2.databinding.utils.NamedStaxOMBuilder builder1 =
+ new org.apache.axis2.databinding.utils.NamedStaxOMBuilder(
+ new org.apache.axis2.util.StreamWrapper(reader),startQname1);
+ object.setGetUserCountRequest(builder1.getOMElement());
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class CreateUserRequest
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/user",
+ "createUserRequest",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/user")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for User
+ */
+
+
+ protected Newusertype localUser ;
+
+
+ /**
+ * Auto generated getter method
+ * @return Newusertype
+ */
+ public Newusertype getUser(){
+ return localUser;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param User
+ */
+ public void setUser(Newusertype param){
+
+ this.localUser=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ CreateUserRequest.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/user");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":createUserRequest",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "createUserRequest",
+ xmlWriter);
+ }
+
+
+ }
+
+ if (localUser==null){
+ throw new org.apache.axis2.databinding.ADBException("user cannot be null!!");
+ }
+ localUser.serialize(new javax.xml.namespace.QName("http://www.vitero.de/schema/user","user"),
+ factory,xmlWriter);
+
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/user",
+ "user"));
+
+
+ if (localUser==null){
+ throw new org.apache.axis2.databinding.ADBException("user cannot be null!!");
+ }
+ elementList.add(localUser);
+
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static CreateUserRequest parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ CreateUserRequest object =
+ new CreateUserRequest();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"createUserRequest".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (CreateUserRequest)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/user","user").equals(reader.getName())){
+
+ object.setUser(Newusertype.Factory.parse(reader));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class DeleteUserRequest
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/user",
+ "deleteUserRequest",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/user")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for DeleteUserRequest
+ */
+
+
+ protected Userid localDeleteUserRequest ;
+
+
+ /**
+ * Auto generated getter method
+ * @return Userid
+ */
+ public Userid getDeleteUserRequest(){
+ return localDeleteUserRequest;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param DeleteUserRequest
+ */
+ public void setDeleteUserRequest(Userid param){
+
+ this.localDeleteUserRequest=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ DeleteUserRequest.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+ //We can safely assume an element has only one type associated with it
+
+ if (localDeleteUserRequest==null){
+ throw new org.apache.axis2.databinding.ADBException("Property cannot be null!");
+ }
+ localDeleteUserRequest.serialize(MY_QNAME,factory,xmlWriter);
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+
+ //We can safely assume an element has only one type associated with it
+ return localDeleteUserRequest.getPullParser(MY_QNAME);
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static DeleteUserRequest parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ DeleteUserRequest object =
+ new DeleteUserRequest();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/user","deleteUserRequest").equals(reader.getName())){
+
+ object.setDeleteUserRequest(Userid.Factory.parse(reader));
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class GetUserRequest
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/user",
+ "getUserRequest",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/user")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for GetUserRequest
+ */
+
+
+ protected Userid localGetUserRequest ;
+
+
+ /**
+ * Auto generated getter method
+ * @return Userid
+ */
+ public Userid getGetUserRequest(){
+ return localGetUserRequest;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param GetUserRequest
+ */
+ public void setGetUserRequest(Userid param){
+
+ this.localGetUserRequest=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ GetUserRequest.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+ //We can safely assume an element has only one type associated with it
+
+ if (localGetUserRequest==null){
+ throw new org.apache.axis2.databinding.ADBException("Property cannot be null!");
+ }
+ localGetUserRequest.serialize(MY_QNAME,factory,xmlWriter);
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+
+ //We can safely assume an element has only one type associated with it
+ return localGetUserRequest.getPullParser(MY_QNAME);
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static GetUserRequest parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ GetUserRequest object =
+ new GetUserRequest();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/user","getUserRequest").equals(reader.getName())){
+
+ object.setGetUserRequest(Userid.Factory.parse(reader));
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class ChangePasswordRequest
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/user",
+ "changePasswordRequest",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/user")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for Userid
+ */
+
+
+ protected int localUserid ;
+
+
+ /**
+ * Auto generated getter method
+ * @return int
+ */
+ public int getUserid(){
+ return localUserid;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Userid
+ */
+ public void setUserid(int param){
+
+ this.localUserid=param;
+
+
+ }
+
+
+ /**
+ * field for Password
+ */
+
+
+ protected java.lang.String localPassword ;
+
+
+ /**
+ * Auto generated getter method
+ * @return java.lang.String
+ */
+ public java.lang.String getPassword(){
+ return localPassword;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Password
+ */
+ public void setPassword(java.lang.String param){
+
+ this.localPassword=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ ChangePasswordRequest.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/user");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":changePasswordRequest",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "changePasswordRequest",
+ xmlWriter);
+ }
+
+
+ }
+
+ namespace = "http://www.vitero.de/schema/user";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"userid", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"userid");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("userid");
+ }
+
+ if (localUserid==java.lang.Integer.MIN_VALUE) {
+
+ throw new org.apache.axis2.databinding.ADBException("userid cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localUserid));
+ }
+
+ xmlWriter.writeEndElement();
+
+ namespace = "http://www.vitero.de/schema/user";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"password", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"password");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("password");
+ }
+
+
+ if (localPassword==null){
+ // write the nil attribute
+
+ throw new org.apache.axis2.databinding.ADBException("password cannot be null!!");
+
+ }else{
+
+
+ xmlWriter.writeCharacters(localPassword);
+
+ }
+
+ xmlWriter.writeEndElement();
+
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/user",
+ "userid"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localUserid));
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/user",
+ "password"));
+
+ if (localPassword != null){
+ elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localPassword));
+ } else {
+ throw new org.apache.axis2.databinding.ADBException("password cannot be null!!");
+ }
+
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static ChangePasswordRequest parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ ChangePasswordRequest object =
+ new ChangePasswordRequest();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"changePasswordRequest".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (ChangePasswordRequest)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/user","userid").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setUserid(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToInt(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/user","password").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setPassword(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class Customer_type0
+ implements org.apache.axis2.databinding.ADBBean{
+ /* This type was generated from the piece of schema that had
+ name = customer_type0
+ Namespace URI = http://www.vitero.de/schema/user
+ Namespace Prefix = ns1
+ */
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/user")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for Customerid
+ */
+
+
+ protected int localCustomerid ;
+
+
+ /**
+ * Auto generated getter method
+ * @return int
+ */
+ public int getCustomerid(){
+ return localCustomerid;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Customerid
+ */
+ public void setCustomerid(int param){
+
+ this.localCustomerid=param;
+
+
+ }
+
+
+ /**
+ * field for Admin
+ */
+
+
+ protected boolean localAdmin ;
+
+
+ /**
+ * Auto generated getter method
+ * @return boolean
+ */
+ public boolean getAdmin(){
+ return localAdmin;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Admin
+ */
+ public void setAdmin(boolean param){
+
+ this.localAdmin=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,parentQName){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ Customer_type0.this.serialize(parentQName,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ parentQName,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/user");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":customer_type0",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "customer_type0",
+ xmlWriter);
+ }
+
+
+ }
+
+ namespace = "http://www.vitero.de/schema/user";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"customerid", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"customerid");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("customerid");
+ }
+
+ if (localCustomerid==java.lang.Integer.MIN_VALUE) {
+
+ throw new org.apache.axis2.databinding.ADBException("customerid cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localCustomerid));
+ }
+
+ xmlWriter.writeEndElement();
+
+ namespace = "http://www.vitero.de/schema/user";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"admin", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"admin");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("admin");
+ }
+
+ if (false) {
+
+ throw new org.apache.axis2.databinding.ADBException("admin cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localAdmin));
+ }
+
+ xmlWriter.writeEndElement();
+
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/user",
+ "customerid"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localCustomerid));
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/user",
+ "admin"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localAdmin));
+
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static Customer_type0 parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ Customer_type0 object =
+ new Customer_type0();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"customer_type0".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (Customer_type0)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/user","customerid").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setCustomerid(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToInt(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/user","admin").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setAdmin(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToBoolean(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class GetUserListResponse
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/user",
+ "getUserListResponse",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/user")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for GetUserListResponse
+ */
+
+
+ protected Userlist localGetUserListResponse ;
+
+
+ /**
+ * Auto generated getter method
+ * @return Userlist
+ */
+ public Userlist getGetUserListResponse(){
+ return localGetUserListResponse;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param GetUserListResponse
+ */
+ public void setGetUserListResponse(Userlist param){
+
+ this.localGetUserListResponse=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ GetUserListResponse.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+ //We can safely assume an element has only one type associated with it
+
+ if (localGetUserListResponse==null){
+ throw new org.apache.axis2.databinding.ADBException("Property cannot be null!");
+ }
+ localGetUserListResponse.serialize(MY_QNAME,factory,xmlWriter);
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+
+ //We can safely assume an element has only one type associated with it
+ return localGetUserListResponse.getPullParser(MY_QNAME);
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static GetUserListResponse parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ GetUserListResponse object =
+ new GetUserListResponse();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/user","getUserListResponse").equals(reader.getName())){
+
+ object.setGetUserListResponse(Userlist.Factory.parse(reader));
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ public static class GetUserCountResponse
+ implements org.apache.axis2.databinding.ADBBean{
+
+ public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName(
+ "http://www.vitero.de/schema/user",
+ "getUserCountResponse",
+ "ns1");
+
+
+
+ private static java.lang.String generatePrefix(java.lang.String namespace) {
+ if(namespace.equals("http://www.vitero.de/schema/user")){
+ return "ns1";
+ }
+ return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+
+
+ /**
+ * field for Count
+ */
+
+
+ protected int localCount ;
+
+
+ /**
+ * Auto generated getter method
+ * @return int
+ */
+ public int getCount(){
+ return localCount;
+ }
+
+
+
+ /**
+ * Auto generated setter method
+ * @param param Count
+ */
+ public void setCount(int param){
+
+ this.localCount=param;
+
+
+ }
+
+
+ /**
+ * isReaderMTOMAware
+ * @return true if the reader supports MTOM
+ */
+ public static boolean isReaderMTOMAware(javax.xml.stream.XMLStreamReader reader) {
+ boolean isReaderMTOMAware = false;
+
+ try{
+ isReaderMTOMAware = java.lang.Boolean.TRUE.equals(reader.getProperty(org.apache.axiom.om.OMConstants.IS_DATA_HANDLERS_AWARE));
+ }catch(java.lang.IllegalArgumentException e){
+ isReaderMTOMAware = false;
+ }
+ return isReaderMTOMAware;
+ }
+
+
+ /**
+ *
+ * @param parentQName
+ * @param factory
+ * @return org.apache.axiom.om.OMElement
+ */
+ public org.apache.axiom.om.OMElement getOMElement (
+ final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{
+
+
+
+ org.apache.axiom.om.OMDataSource dataSource =
+ new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME){
+
+ public void serialize(org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ GetUserCountResponse.this.serialize(MY_QNAME,factory,xmlWriter);
+ }
+ };
+ return new org.apache.axiom.om.impl.llom.OMSourcedElementImpl(
+ MY_QNAME,factory,dataSource);
+
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+ serialize(parentQName,factory,xmlWriter,false);
+ }
+
+ public void serialize(final javax.xml.namespace.QName parentQName,
+ final org.apache.axiom.om.OMFactory factory,
+ org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter xmlWriter,
+ boolean serializeType)
+ throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{
+
+
+
+
+ java.lang.String prefix = null;
+ java.lang.String namespace = null;
+
+
+ prefix = parentQName.getPrefix();
+ namespace = parentQName.getNamespaceURI();
+
+ if ((namespace != null) && (namespace.trim().length() > 0)) {
+ java.lang.String writerPrefix = xmlWriter.getPrefix(namespace);
+ if (writerPrefix != null) {
+ xmlWriter.writeStartElement(namespace, parentQName.getLocalPart());
+ } else {
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+ }
+
+ xmlWriter.writeStartElement(prefix, parentQName.getLocalPart(), namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+ } else {
+ xmlWriter.writeStartElement(parentQName.getLocalPart());
+ }
+
+ if (serializeType){
+
+
+ java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.vitero.de/schema/user");
+ if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ namespacePrefix+":getUserCountResponse",
+ xmlWriter);
+ } else {
+ writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type",
+ "getUserCountResponse",
+ xmlWriter);
+ }
+
+
+ }
+
+ namespace = "http://www.vitero.de/schema/user";
+ if (! namespace.equals("")) {
+ prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ xmlWriter.writeStartElement(prefix,"count", namespace);
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ } else {
+ xmlWriter.writeStartElement(namespace,"count");
+ }
+
+ } else {
+ xmlWriter.writeStartElement("count");
+ }
+
+ if (localCount==java.lang.Integer.MIN_VALUE) {
+
+ throw new org.apache.axis2.databinding.ADBException("count cannot be null!!");
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localCount));
+ }
+
+ xmlWriter.writeEndElement();
+
+ xmlWriter.writeEndElement();
+
+
+ }
+
+ /**
+ * Util method to write an attribute with the ns prefix
+ */
+ private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (xmlWriter.getPrefix(namespace) == null) {
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+
+ }
+
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+
+ }
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeAttribute(java.lang.String namespace,java.lang.String attName,
+ java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{
+ if (namespace.equals(""))
+ {
+ xmlWriter.writeAttribute(attName,attValue);
+ }
+ else
+ {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace,attName,attValue);
+ }
+ }
+
+
+ /**
+ * Util method to write an attribute without the ns prefix
+ */
+ private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName,
+ javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ java.lang.String attributeNamespace = qname.getNamespaceURI();
+ java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace);
+ if (attributePrefix == null) {
+ attributePrefix = registerPrefix(xmlWriter, attributeNamespace);
+ }
+ java.lang.String attributeValue;
+ if (attributePrefix.trim().length() > 0) {
+ attributeValue = attributePrefix + ":" + qname.getLocalPart();
+ } else {
+ attributeValue = qname.getLocalPart();
+ }
+
+ if (namespace.equals("")) {
+ xmlWriter.writeAttribute(attName, attributeValue);
+ } else {
+ registerPrefix(xmlWriter, namespace);
+ xmlWriter.writeAttribute(namespace, attName, attributeValue);
+ }
+ }
+ /**
+ * method to handle Qnames
+ */
+
+ private void writeQName(javax.xml.namespace.QName qname,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+ java.lang.String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null) {
+ java.lang.String prefix = xmlWriter.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ } else {
+ // i.e this is the default namespace
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+
+ } else {
+ xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname));
+ }
+ }
+
+ private void writeQNames(javax.xml.namespace.QName[] qnames,
+ javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException {
+
+ if (qnames != null) {
+ // we have to store this data until last moment since it is not possible to write any
+ // namespace data after writing the charactor data
+ java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer();
+ java.lang.String namespaceURI = null;
+ java.lang.String prefix = null;
+
+ for (int i = 0; i < qnames.length; i++) {
+ if (i > 0) {
+ stringToWrite.append(" ");
+ }
+ namespaceURI = qnames[i].getNamespaceURI();
+ if (namespaceURI != null) {
+ prefix = xmlWriter.getPrefix(namespaceURI);
+ if ((prefix == null) || (prefix.length() == 0)) {
+ prefix = generatePrefix(namespaceURI);
+ xmlWriter.writeNamespace(prefix, namespaceURI);
+ xmlWriter.setPrefix(prefix,namespaceURI);
+ }
+
+ if (prefix.trim().length() > 0){
+ stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ } else {
+ stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i]));
+ }
+ }
+ xmlWriter.writeCharacters(stringToWrite.toString());
+ }
+
+ }
+
+
+ /**
+ * Register a namespace prefix
+ */
+ private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException {
+ java.lang.String prefix = xmlWriter.getPrefix(namespace);
+
+ if (prefix == null) {
+ prefix = generatePrefix(namespace);
+
+ while (xmlWriter.getNamespaceContext().getNamespaceURI(prefix) != null) {
+ prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix();
+ }
+
+ xmlWriter.writeNamespace(prefix, namespace);
+ xmlWriter.setPrefix(prefix, namespace);
+ }
+
+ return prefix;
+ }
+
+
+
+ /**
+ * databinding method to get an XML representation of this object
+ *
+ */
+ public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName)
+ throws org.apache.axis2.databinding.ADBException{
+
+
+
+ java.util.ArrayList elementList = new java.util.ArrayList();
+ java.util.ArrayList attribList = new java.util.ArrayList();
+
+
+ elementList.add(new javax.xml.namespace.QName("http://www.vitero.de/schema/user",
+ "count"));
+
+ elementList.add(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localCount));
+
+
+ return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray());
+
+
+
+ }
+
+
+
+ /**
+ * Factory class that keeps the parse method
+ */
+ public static class Factory{
+
+
+
+
+ /**
+ * static method to create the object
+ * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable
+ * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element
+ * Postcondition: If this object is an element, the reader is positioned at its end element
+ * If this object is a complex type, the reader is positioned at the end element of its outer element
+ */
+ public static GetUserCountResponse parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{
+ GetUserCountResponse object =
+ new GetUserCountResponse();
+
+ int event;
+ java.lang.String nillableValue = null;
+ java.lang.String prefix ="";
+ java.lang.String namespaceuri ="";
+ try {
+
+ while (!reader.isStartElement() && !reader.isEndElement())
+ reader.next();
+
+
+ if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){
+ java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance",
+ "type");
+ if (fullTypeName!=null){
+ java.lang.String nsPrefix = null;
+ if (fullTypeName.indexOf(":") > -1){
+ nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":"));
+ }
+ nsPrefix = nsPrefix==null?"":nsPrefix;
+
+ java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1);
+
+ if (!"getUserCountResponse".equals(type)){
+ //find namespace for the prefix
+ java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix);
+ return (GetUserCountResponse)ExtensionMapper.getTypeObject(
+ nsUri,type,reader);
+ }
+
+
+ }
+
+
+ }
+
+
+
+
+ // Note all attributes that were handled. Used to differ normal attributes
+ // from anyAttributes.
+ java.util.Vector handledAttributes = new java.util.Vector();
+
+
+
+
+ reader.next();
+
+ while(!reader.isEndElement()) {
+ if (reader.isStartElement() ){
+
+ if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.vitero.de/schema/user","count").equals(reader.getName())){
+
+ java.lang.String content = reader.getElementText();
+
+ object.setCount(
+ org.apache.axis2.databinding.utils.ConverterUtil.convertToInt(content));
+
+ reader.next();
+
+ } // End of if for expected property start element
+
+ else{
+ // A start element we are not expecting indicates an invalid parameter was passed
+ throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getLocalName());
+ }
+
+ } else {
+ reader.next();
+ }
+ } // end of while loop
+
+
+
+
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new java.lang.Exception(e);
+ }
+
+ return object;
+ }
+
+ }//end of factory class
+
+
+
+ }
+
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.UserServiceStub.DeleteUserRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.UserServiceStub.DeleteUserRequest.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.UserServiceStub.GetUserListRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.UserServiceStub.GetUserListRequest.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.UserServiceStub.GetUserListResponse param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.UserServiceStub.GetUserListResponse.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.UserServiceStub.GetUserListByGroupRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.UserServiceStub.GetUserListByGroupRequest.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.UserServiceStub.GetUserListByGroupResponse param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.UserServiceStub.GetUserListByGroupResponse.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.UserServiceStub.GetUserListByPositionRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.UserServiceStub.GetUserListByPositionRequest.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.UserServiceStub.GetUserListByPositionResponse param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.UserServiceStub.GetUserListByPositionResponse.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.UserServiceStub.UpdateUserRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.UserServiceStub.UpdateUserRequest.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.UserServiceStub.SuccessResponse param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.UserServiceStub.SuccessResponse.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.UserServiceStub.CreateUserRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.UserServiceStub.CreateUserRequest.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.UserServiceStub.CreateUserResponse param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.UserServiceStub.CreateUserResponse.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.UserServiceStub.GetUserRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.UserServiceStub.GetUserRequest.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.UserServiceStub.GetUserResponse param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.UserServiceStub.GetUserResponse.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.UserServiceStub.GetUserCountRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.UserServiceStub.GetUserCountRequest.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.UserServiceStub.GetUserCountResponse param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.UserServiceStub.GetUserCountResponse.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.UserServiceStub.GetUserListByCustomerRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.UserServiceStub.GetUserListByCustomerRequest.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.UserServiceStub.GetUserListByCustomerResponse param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.UserServiceStub.GetUserListByCustomerResponse.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+ private org.apache.axiom.om.OMElement toOM(com.frentix.olat.vitero.manager.stubs.UserServiceStub.ChangePasswordRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault {
+
+
+ try{
+ return param.getOMElement(com.frentix.olat.vitero.manager.stubs.UserServiceStub.ChangePasswordRequest.MY_QNAME,
+ org.apache.axiom.om.OMAbstractFactory.getOMFactory());
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+
+ private org.apache.axiom.soap.SOAPEnvelope toEnvelope(org.apache.axiom.soap.SOAPFactory factory, com.frentix.olat.vitero.manager.stubs.UserServiceStub.DeleteUserRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault{
+
+
+ try{
+
+ org.apache.axiom.soap.SOAPEnvelope emptyEnvelope = factory.getDefaultEnvelope();
+ emptyEnvelope.getBody().addChild(param.getOMElement(com.frentix.olat.vitero.manager.stubs.UserServiceStub.DeleteUserRequest.MY_QNAME,factory));
+ return emptyEnvelope;
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+
+ /* methods to provide back word compatibility */
+
+
+
+ private org.apache.axiom.soap.SOAPEnvelope toEnvelope(org.apache.axiom.soap.SOAPFactory factory, com.frentix.olat.vitero.manager.stubs.UserServiceStub.GetUserListRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault{
+
+
+ try{
+
+ org.apache.axiom.soap.SOAPEnvelope emptyEnvelope = factory.getDefaultEnvelope();
+ emptyEnvelope.getBody().addChild(param.getOMElement(com.frentix.olat.vitero.manager.stubs.UserServiceStub.GetUserListRequest.MY_QNAME,factory));
+ return emptyEnvelope;
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+
+ /* methods to provide back word compatibility */
+
+
+
+ private org.apache.axiom.soap.SOAPEnvelope toEnvelope(org.apache.axiom.soap.SOAPFactory factory, com.frentix.olat.vitero.manager.stubs.UserServiceStub.GetUserListByGroupRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault{
+
+
+ try{
+
+ org.apache.axiom.soap.SOAPEnvelope emptyEnvelope = factory.getDefaultEnvelope();
+ emptyEnvelope.getBody().addChild(param.getOMElement(com.frentix.olat.vitero.manager.stubs.UserServiceStub.GetUserListByGroupRequest.MY_QNAME,factory));
+ return emptyEnvelope;
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+
+ /* methods to provide back word compatibility */
+
+
+
+ private org.apache.axiom.soap.SOAPEnvelope toEnvelope(org.apache.axiom.soap.SOAPFactory factory, com.frentix.olat.vitero.manager.stubs.UserServiceStub.GetUserListByPositionRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault{
+
+
+ try{
+
+ org.apache.axiom.soap.SOAPEnvelope emptyEnvelope = factory.getDefaultEnvelope();
+ emptyEnvelope.getBody().addChild(param.getOMElement(com.frentix.olat.vitero.manager.stubs.UserServiceStub.GetUserListByPositionRequest.MY_QNAME,factory));
+ return emptyEnvelope;
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+
+ /* methods to provide back word compatibility */
+
+
+
+ private org.apache.axiom.soap.SOAPEnvelope toEnvelope(org.apache.axiom.soap.SOAPFactory factory, com.frentix.olat.vitero.manager.stubs.UserServiceStub.UpdateUserRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault{
+
+
+ try{
+
+ org.apache.axiom.soap.SOAPEnvelope emptyEnvelope = factory.getDefaultEnvelope();
+ emptyEnvelope.getBody().addChild(param.getOMElement(com.frentix.olat.vitero.manager.stubs.UserServiceStub.UpdateUserRequest.MY_QNAME,factory));
+ return emptyEnvelope;
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+
+ /* methods to provide back word compatibility */
+
+
+
+ private org.apache.axiom.soap.SOAPEnvelope toEnvelope(org.apache.axiom.soap.SOAPFactory factory, com.frentix.olat.vitero.manager.stubs.UserServiceStub.CreateUserRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault{
+
+
+ try{
+
+ org.apache.axiom.soap.SOAPEnvelope emptyEnvelope = factory.getDefaultEnvelope();
+ emptyEnvelope.getBody().addChild(param.getOMElement(com.frentix.olat.vitero.manager.stubs.UserServiceStub.CreateUserRequest.MY_QNAME,factory));
+ return emptyEnvelope;
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+
+ /* methods to provide back word compatibility */
+
+
+
+ private org.apache.axiom.soap.SOAPEnvelope toEnvelope(org.apache.axiom.soap.SOAPFactory factory, com.frentix.olat.vitero.manager.stubs.UserServiceStub.GetUserRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault{
+
+
+ try{
+
+ org.apache.axiom.soap.SOAPEnvelope emptyEnvelope = factory.getDefaultEnvelope();
+ emptyEnvelope.getBody().addChild(param.getOMElement(com.frentix.olat.vitero.manager.stubs.UserServiceStub.GetUserRequest.MY_QNAME,factory));
+ return emptyEnvelope;
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+
+ /* methods to provide back word compatibility */
+
+
+
+ private org.apache.axiom.soap.SOAPEnvelope toEnvelope(org.apache.axiom.soap.SOAPFactory factory, com.frentix.olat.vitero.manager.stubs.UserServiceStub.GetUserCountRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault{
+
+
+ try{
+
+ org.apache.axiom.soap.SOAPEnvelope emptyEnvelope = factory.getDefaultEnvelope();
+ emptyEnvelope.getBody().addChild(param.getOMElement(com.frentix.olat.vitero.manager.stubs.UserServiceStub.GetUserCountRequest.MY_QNAME,factory));
+ return emptyEnvelope;
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+
+ /* methods to provide back word compatibility */
+
+
+
+ private org.apache.axiom.soap.SOAPEnvelope toEnvelope(org.apache.axiom.soap.SOAPFactory factory, com.frentix.olat.vitero.manager.stubs.UserServiceStub.GetUserListByCustomerRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault{
+
+
+ try{
+
+ org.apache.axiom.soap.SOAPEnvelope emptyEnvelope = factory.getDefaultEnvelope();
+ emptyEnvelope.getBody().addChild(param.getOMElement(com.frentix.olat.vitero.manager.stubs.UserServiceStub.GetUserListByCustomerRequest.MY_QNAME,factory));
+ return emptyEnvelope;
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+
+ /* methods to provide back word compatibility */
+
+
+
+ private org.apache.axiom.soap.SOAPEnvelope toEnvelope(org.apache.axiom.soap.SOAPFactory factory, com.frentix.olat.vitero.manager.stubs.UserServiceStub.ChangePasswordRequest param, boolean optimizeContent)
+ throws org.apache.axis2.AxisFault{
+
+
+ try{
+
+ org.apache.axiom.soap.SOAPEnvelope emptyEnvelope = factory.getDefaultEnvelope();
+ emptyEnvelope.getBody().addChild(param.getOMElement(com.frentix.olat.vitero.manager.stubs.UserServiceStub.ChangePasswordRequest.MY_QNAME,factory));
+ return emptyEnvelope;
+ } catch(org.apache.axis2.databinding.ADBException e){
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+
+
+ }
+
+
+ /* methods to provide back word compatibility */
+
+
+
+
+ /**
+ * get the default envelope
+ */
+ private org.apache.axiom.soap.SOAPEnvelope toEnvelope(org.apache.axiom.soap.SOAPFactory factory){
+ return factory.getDefaultEnvelope();
+ }
+
+
+ private java.lang.Object fromOM(
+ org.apache.axiom.om.OMElement param,
+ java.lang.Class type,
+ java.util.Map extraNamespaces) throws org.apache.axis2.AxisFault{
+
+ try {
+
+ if (com.frentix.olat.vitero.manager.stubs.UserServiceStub.DeleteUserRequest.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.UserServiceStub.DeleteUserRequest.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ if (com.frentix.olat.vitero.manager.stubs.UserServiceStub.GetUserListRequest.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.UserServiceStub.GetUserListRequest.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ if (com.frentix.olat.vitero.manager.stubs.UserServiceStub.GetUserListResponse.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.UserServiceStub.GetUserListResponse.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ if (com.frentix.olat.vitero.manager.stubs.UserServiceStub.GetUserListByGroupRequest.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.UserServiceStub.GetUserListByGroupRequest.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ if (com.frentix.olat.vitero.manager.stubs.UserServiceStub.GetUserListByGroupResponse.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.UserServiceStub.GetUserListByGroupResponse.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ if (com.frentix.olat.vitero.manager.stubs.UserServiceStub.GetUserListByPositionRequest.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.UserServiceStub.GetUserListByPositionRequest.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ if (com.frentix.olat.vitero.manager.stubs.UserServiceStub.GetUserListByPositionResponse.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.UserServiceStub.GetUserListByPositionResponse.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ if (com.frentix.olat.vitero.manager.stubs.UserServiceStub.UpdateUserRequest.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.UserServiceStub.UpdateUserRequest.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ if (com.frentix.olat.vitero.manager.stubs.UserServiceStub.SuccessResponse.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.UserServiceStub.SuccessResponse.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ if (com.frentix.olat.vitero.manager.stubs.UserServiceStub.CreateUserRequest.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.UserServiceStub.CreateUserRequest.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ if (com.frentix.olat.vitero.manager.stubs.UserServiceStub.CreateUserResponse.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.UserServiceStub.CreateUserResponse.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ if (com.frentix.olat.vitero.manager.stubs.UserServiceStub.GetUserRequest.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.UserServiceStub.GetUserRequest.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ if (com.frentix.olat.vitero.manager.stubs.UserServiceStub.GetUserResponse.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.UserServiceStub.GetUserResponse.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ if (com.frentix.olat.vitero.manager.stubs.UserServiceStub.GetUserCountRequest.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.UserServiceStub.GetUserCountRequest.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ if (com.frentix.olat.vitero.manager.stubs.UserServiceStub.GetUserCountResponse.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.UserServiceStub.GetUserCountResponse.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ if (com.frentix.olat.vitero.manager.stubs.UserServiceStub.GetUserListByCustomerRequest.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.UserServiceStub.GetUserListByCustomerRequest.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ if (com.frentix.olat.vitero.manager.stubs.UserServiceStub.GetUserListByCustomerResponse.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.UserServiceStub.GetUserListByCustomerResponse.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ if (com.frentix.olat.vitero.manager.stubs.UserServiceStub.ChangePasswordRequest.class.equals(type)){
+
+ return com.frentix.olat.vitero.manager.stubs.UserServiceStub.ChangePasswordRequest.Factory.parse(param.getXMLStreamReaderWithoutCaching());
+
+
+ }
+
+ } catch (java.lang.Exception e) {
+ throw org.apache.axis2.AxisFault.makeFault(e);
+ }
+ return null;
+ }
+
+
+
+
+ }
+
\ No newline at end of file
diff --git a/src/main/java/com/frentix/olat/vitero/model/GroupRole.java b/src/main/java/com/frentix/olat/vitero/model/GroupRole.java
new file mode 100644
index 0000000000000000000000000000000000000000..87f6e1f51f27f226f74dbc4a7fc028b82713f312
--- /dev/null
+++ b/src/main/java/com/frentix/olat/vitero/model/GroupRole.java
@@ -0,0 +1,28 @@
+package com.frentix.olat.vitero.model;
+
+/**
+ *
+ * Description:<br>
+ *
+ * <P>
+ * Initial Date: 11 oct. 2011 <br>
+ *
+ * @author srosse, stephane.rosse@frentix.com, http://www.frentix.com
+ */
+public enum GroupRole {
+ //position is important!
+ participant(0),
+ assistant(1),
+ teamleader(2),
+ audience(3);
+
+ private final int vmsValue;
+
+ private GroupRole(int val) {
+ this.vmsValue = val;
+ }
+
+ public int getVmsValue() {
+ return vmsValue;
+ }
+}
diff --git a/src/main/java/com/frentix/olat/vitero/model/Repetitionpattern.java b/src/main/java/com/frentix/olat/vitero/model/Repetitionpattern.java
new file mode 100644
index 0000000000000000000000000000000000000000..742e347ce6c1b5c14ecddf7db064e8bcd333dd7e
--- /dev/null
+++ b/src/main/java/com/frentix/olat/vitero/model/Repetitionpattern.java
@@ -0,0 +1,39 @@
+/**
+ * OLAT - Online Learning and Training<br>
+ * http://www.olat.org
+ * <p>
+ * Licensed under the Apache License, Version 2.0 (the "License"); <br>
+ * you may not use this file except in compliance with the License.<br>
+ * You may obtain a copy of the License at
+ * <p>
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * <p>
+ * Unless required by applicable law or agreed to in writing,<br>
+ * software distributed under the License is distributed on an "AS IS" BASIS, <br>
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. <br>
+ * See the License for the specific language governing permissions and <br>
+ * limitations under the License.
+ * <p>
+ * Copyright (c) frentix GmbH<br>
+ * http://www.frentix.com<br>
+ * <p>
+ */
+package com.frentix.olat.vitero.model;
+
+
+/**
+ *
+ * Description:<br>
+ *
+ * <P>
+ * Initial Date: 6 oct. 2011 <br>
+ *
+ * @author srosse, stephane.rosse@frentix.com, http://www.frentix.com
+ */
+public enum Repetitionpattern {
+ once, //no repetition (default)
+ daily, //every day
+ weekly, //every week
+ workdays, //only from monday to friday
+ weekends //only on saturday and sunday
+}
diff --git a/src/main/java/com/frentix/olat/vitero/model/StartBookingComparator.java b/src/main/java/com/frentix/olat/vitero/model/StartBookingComparator.java
new file mode 100644
index 0000000000000000000000000000000000000000..6e20b7bbd51154528fc8d0da3846b3c2fcfa9e3f
--- /dev/null
+++ b/src/main/java/com/frentix/olat/vitero/model/StartBookingComparator.java
@@ -0,0 +1,47 @@
+/**
+ * OLAT - Online Learning and Training<br>
+ * http://www.olat.org
+ * <p>
+ * Licensed under the Apache License, Version 2.0 (the "License"); <br>
+ * you may not use this file except in compliance with the License.<br>
+ * You may obtain a copy of the License at
+ * <p>
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * <p>
+ * Unless required by applicable law or agreed to in writing,<br>
+ * software distributed under the License is distributed on an "AS IS" BASIS, <br>
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. <br>
+ * See the License for the specific language governing permissions and <br>
+ * limitations under the License.
+ * <p>
+ * Copyright (c) frentix GmbH<br>
+ * http://www.frentix.com<br>
+ * <p>
+ */
+package com.frentix.olat.vitero.model;
+
+import java.util.Comparator;
+import java.util.Date;
+
+
+/**
+ *
+ * Description:<br>
+ *
+ * <P>
+ * Initial Date: 11 oct. 2011 <br>
+ *
+ * @author srosse, stephane.rosse@frentix.com, http://www.frentix.com
+ */
+public class StartBookingComparator implements Comparator<ViteroBooking> {
+
+ @Override
+ public int compare(ViteroBooking b1, ViteroBooking b2) {
+ Date d1 = b1.getStart();
+ Date d2 = b2.getStart();
+
+ if(d1 == null) return -1;
+ if(d2 == null) return 1;
+ return d1.compareTo(d2);
+ }
+}
diff --git a/src/main/java/com/frentix/olat/vitero/model/ViteroBooking.java b/src/main/java/com/frentix/olat/vitero/model/ViteroBooking.java
new file mode 100644
index 0000000000000000000000000000000000000000..d20189fba015a95ab814c0db80f38515867642ec
--- /dev/null
+++ b/src/main/java/com/frentix/olat/vitero/model/ViteroBooking.java
@@ -0,0 +1,144 @@
+/**
+ * OLAT - Online Learning and Training<br>
+ * http://www.olat.org
+ * <p>
+ * Licensed under the Apache License, Version 2.0 (the "License"); <br>
+ * you may not use this file except in compliance with the License.<br>
+ * You may obtain a copy of the License at
+ * <p>
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * <p>
+ * Unless required by applicable law or agreed to in writing,<br>
+ * software distributed under the License is distributed on an "AS IS" BASIS, <br>
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. <br>
+ * See the License for the specific language governing permissions and <br>
+ * limitations under the License.
+ * <p>
+ * Copyright (c) frentix GmbH<br>
+ * http://www.frentix.com<br>
+ * <p>
+ */
+package com.frentix.olat.vitero.model;
+
+import java.util.Date;
+
+import org.olat.properties.Property;
+
+/**
+ *
+ * Description:<br>
+ *
+ * <P>
+ * Initial Date: 6 oct. 2011 <br>
+ *
+ * @author srosse, stephane.rosse@frentix.com, http://www.frentix.com
+ */
+public class ViteroBooking {
+
+ private int bookingId;
+ private int groupId;
+ private Date start;
+ private int startBuffer;
+ private Date end;
+ private int endBuffer;
+ private int roomSize;
+ private boolean autoSignIn;
+ private String timeZoneId;
+
+ private String resourceName;
+
+ private Property property;
+
+
+ public ViteroBooking() {
+ // nothing to do
+ }
+
+ public String getResourceName() {
+ return resourceName;
+ }
+
+ public void setResourceName(String resourceName) {
+ this.resourceName = resourceName;
+ }
+
+ public Property getProperty() {
+ return property;
+ }
+
+ public void setProperty(Property property) {
+ this.property = property;
+ }
+
+ public int getBookingId() {
+ return bookingId;
+ }
+
+ public void setBookingId(int bookingId) {
+ this.bookingId = bookingId;
+ }
+
+ public int getGroupId() {
+ return groupId;
+ }
+
+ public void setGroupId(int groupId) {
+ this.groupId = groupId;
+ }
+
+ public int getRoomSize() {
+ return roomSize;
+ }
+
+ public void setRoomSize(int roomSize) {
+ this.roomSize = roomSize;
+ }
+
+ public int getStartBuffer() {
+ return startBuffer;
+ }
+
+ public void setStartBuffer(int startBuffer) {
+ this.startBuffer = startBuffer;
+ }
+
+ public Date getStart() {
+ return start;
+ }
+
+ public void setStart(Date start) {
+ this.start = start;
+ }
+
+ public int getEndBuffer() {
+ return endBuffer;
+ }
+
+ public void setEndBuffer(int endBuffer) {
+ this.endBuffer = endBuffer;
+ }
+
+ public Date getEnd() {
+ return end;
+ }
+
+ public void setEnd(Date end) {
+ this.end = end;
+ }
+
+ public String getTimeZoneId() {
+ return timeZoneId;
+ }
+
+ public void setTimeZoneId(String timeZoneId) {
+ this.timeZoneId = timeZoneId;
+ }
+
+ public boolean isAutoSignIn() {
+ return autoSignIn;
+ }
+
+ public void setAutoSignIn(boolean autoSignIn) {
+ this.autoSignIn = autoSignIn;
+ }
+}
\ No newline at end of file
diff --git a/src/main/java/com/frentix/olat/vitero/model/ViteroCustomer.java b/src/main/java/com/frentix/olat/vitero/model/ViteroCustomer.java
new file mode 100644
index 0000000000000000000000000000000000000000..e3db9070e817f35f174b59d8aac2d02626dea820
--- /dev/null
+++ b/src/main/java/com/frentix/olat/vitero/model/ViteroCustomer.java
@@ -0,0 +1,52 @@
+/**
+ * OLAT - Online Learning and Training<br>
+ * http://www.olat.org
+ * <p>
+ * Licensed under the Apache License, Version 2.0 (the "License"); <br>
+ * you may not use this file except in compliance with the License.<br>
+ * You may obtain a copy of the License at
+ * <p>
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * <p>
+ * Unless required by applicable law or agreed to in writing,<br>
+ * software distributed under the License is distributed on an "AS IS" BASIS, <br>
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. <br>
+ * See the License for the specific language governing permissions and <br>
+ * limitations under the License.
+ * <p>
+ * Copyright (c) frentix GmbH<br>
+ * http://www.frentix.com<br>
+ * <p>
+ */
+package com.frentix.olat.vitero.model;
+
+/**
+ *
+ * Description:<br>
+ *
+ * <P>
+ * Initial Date: 13 oct. 2011 <br>
+ *
+ * @author srosse, stephane.rosse@frentix.com, http://www.frentix.com
+ */
+public class ViteroCustomer {
+
+ private int customerId;
+ private String name;
+
+ public int getCustomerId() {
+ return customerId;
+ }
+
+ public void setCustomerId(int customerId) {
+ this.customerId = customerId;
+ }
+
+ public String getName() {
+ return name;
+ }
+
+ public void setName(String name) {
+ this.name = name;
+ }
+}
diff --git a/src/main/java/com/frentix/olat/vitero/model/ViteroGroup.java b/src/main/java/com/frentix/olat/vitero/model/ViteroGroup.java
new file mode 100644
index 0000000000000000000000000000000000000000..b1f34c1b78af567e0a374e97c3a0c95c9557378c
--- /dev/null
+++ b/src/main/java/com/frentix/olat/vitero/model/ViteroGroup.java
@@ -0,0 +1,62 @@
+/**
+ * OLAT - Online Learning and Training<br>
+ * http://www.olat.org
+ * <p>
+ * Licensed under the Apache License, Version 2.0 (the "License"); <br>
+ * you may not use this file except in compliance with the License.<br>
+ * You may obtain a copy of the License at
+ * <p>
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * <p>
+ * Unless required by applicable law or agreed to in writing,<br>
+ * software distributed under the License is distributed on an "AS IS" BASIS, <br>
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. <br>
+ * See the License for the specific language governing permissions and <br>
+ * limitations under the License.
+ * <p>
+ * Copyright (c) frentix GmbH<br>
+ * http://www.frentix.com<br>
+ * <p>
+ */
+package com.frentix.olat.vitero.model;
+
+/**
+ *
+ * Description:<br>
+ *
+ * <P>
+ * Initial Date: 13 oct. 2011 <br>
+ *
+ * @author srosse, stephane.rosse@frentix.com, http://www.frentix.com
+ */
+public class ViteroGroup {
+
+ private int groupId;
+ private String name;
+ private int numOfParticipants;
+
+
+ public int getGroupId() {
+ return groupId;
+ }
+
+ public void setGroupId(int groupId) {
+ this.groupId = groupId;
+ }
+
+ public String getName() {
+ return name;
+ }
+
+ public void setName(String name) {
+ this.name = name;
+ }
+
+ public int getNumOfParticipants() {
+ return numOfParticipants;
+ }
+
+ public void setNumOfParticipants(int numOfParticipants) {
+ this.numOfParticipants = numOfParticipants;
+ }
+}
diff --git a/src/main/java/com/frentix/olat/vitero/model/ViteroUser.java b/src/main/java/com/frentix/olat/vitero/model/ViteroUser.java
new file mode 100644
index 0000000000000000000000000000000000000000..1559fc11fb4f51602cb8066a19a9c02ffec5bddd
--- /dev/null
+++ b/src/main/java/com/frentix/olat/vitero/model/ViteroUser.java
@@ -0,0 +1,50 @@
+package com.frentix.olat.vitero.model;
+
+/**
+ *
+ * Description:<br>
+ *
+ * <P>
+ * Initial Date: 13 oct. 2011 <br>
+ *
+ * @author srosse, stephane.rosse@frentix.com, http://www.frentix.com
+ */
+public class ViteroUser {
+
+ private int userId;
+ private String firstName;
+ private String lastName;
+ private String email;
+
+ public int getUserId() {
+ return userId;
+ }
+
+ public void setUserId(int userId) {
+ this.userId = userId;
+ }
+
+ public String getFirstName() {
+ return firstName;
+ }
+
+ public void setFirstName(String firstName) {
+ this.firstName = firstName;
+ }
+
+ public String getLastName() {
+ return lastName;
+ }
+
+ public void setLastName(String lastName) {
+ this.lastName = lastName;
+ }
+
+ public String getEmail() {
+ return email;
+ }
+
+ public void setEmail(String email) {
+ this.email = email;
+ }
+}
diff --git a/src/main/java/com/frentix/olat/vitero/ui/FilterBookings.java b/src/main/java/com/frentix/olat/vitero/ui/FilterBookings.java
new file mode 100644
index 0000000000000000000000000000000000000000..c00bddd5d1a4199d58ea9e493fdd53404635944d
--- /dev/null
+++ b/src/main/java/com/frentix/olat/vitero/ui/FilterBookings.java
@@ -0,0 +1,42 @@
+package com.frentix.olat.vitero.ui;
+
+import java.util.Date;
+import java.util.Iterator;
+import java.util.List;
+
+import com.frentix.olat.vitero.model.ViteroBooking;
+
+/**
+ *
+ * Description:<br>
+ *
+ * <P>
+ * Initial Date: 11 oct. 2011 <br>
+ *
+ * @author srosse, stephane.rosse@frentix.com, http://www.frentix.com
+ */
+public class FilterBookings {
+
+ public static void filterMyFutureBookings(final List<ViteroBooking> bookings, final List<ViteroBooking> signedInBookings) {
+ //only the bookings in the future
+ Date now = new Date();
+ for(Iterator<ViteroBooking> it=bookings.iterator(); it.hasNext(); ) {
+ ViteroBooking booking = it.next();
+ Date end = booking.getEnd();
+ if(end.before(now)) {
+ it.remove();
+ } else if(!booking.isAutoSignIn()) {
+ boolean in = false;
+ for(ViteroBooking signedInBooking:signedInBookings) {
+ if(signedInBooking.getBookingId() == booking.getBookingId()) {
+ in = true;//already in
+ }
+ }
+ if(!in) {
+ it.remove();
+ }
+ }
+ }
+ }
+
+}
diff --git a/src/main/java/com/frentix/olat/vitero/ui/RoleCellRenderer.java b/src/main/java/com/frentix/olat/vitero/ui/RoleCellRenderer.java
new file mode 100644
index 0000000000000000000000000000000000000000..4e674cd57104af6c0fde1d6f164b82598b6cd4c4
--- /dev/null
+++ b/src/main/java/com/frentix/olat/vitero/ui/RoleCellRenderer.java
@@ -0,0 +1,53 @@
+/**
+ * OLAT - Online Learning and Training<br>
+ * http://www.olat.org
+ * <p>
+ * Licensed under the Apache License, Version 2.0 (the "License"); <br>
+ * you may not use this file except in compliance with the License.<br>
+ * You may obtain a copy of the License at
+ * <p>
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * <p>
+ * Unless required by applicable law or agreed to in writing,<br>
+ * software distributed under the License is distributed on an "AS IS" BASIS, <br>
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. <br>
+ * See the License for the specific language governing permissions and <br>
+ * limitations under the License.
+ * <p>
+ * Copyright (c) frentix GmbH<br>
+ * http://www.frentix.com<br>
+ * <p>
+ */
+package com.frentix.olat.vitero.ui;
+
+import java.util.Locale;
+
+import org.olat.core.gui.components.table.CustomCellRenderer;
+import org.olat.core.gui.render.Renderer;
+import org.olat.core.gui.render.StringOutput;
+import org.olat.core.gui.translator.Translator;
+
+/**
+ *
+ * Description:<br>
+ *
+ * <P>
+ * Initial Date: 12 oct. 2011 <br>
+ *
+ * @author srosse, stephane.rosse@frentix.com, http://www.frentix.com
+ */
+public class RoleCellRenderer implements CustomCellRenderer {
+
+ private Translator translator;
+
+ protected RoleCellRenderer(Translator translator) {
+ this.translator = translator;
+ }
+
+ @Override
+ public void render(StringOutput sb, Renderer renderer, Object val, Locale locale, int alignment, String action) {
+ if("owner".equals(val) || "coach".equals(val)) {
+ sb.append(translator.translate("role.teamLeader"));
+ }
+ }
+}
diff --git a/src/main/java/com/frentix/olat/vitero/ui/Sign.java b/src/main/java/com/frentix/olat/vitero/ui/Sign.java
new file mode 100644
index 0000000000000000000000000000000000000000..df694a32cdbe79d5898c93f43ffcb449aa66e657
--- /dev/null
+++ b/src/main/java/com/frentix/olat/vitero/ui/Sign.java
@@ -0,0 +1,16 @@
+package com.frentix.olat.vitero.ui;
+
+/**
+ *
+ * Description:<br>
+ *
+ * <P>
+ * Initial Date: 11 oct. 2011 <br>
+ *
+ * @author srosse, stephane.rosse@frentix.com, http://www.frentix.com
+ */
+public enum Sign {
+ signin,
+ signout,
+ no,
+}
diff --git a/src/main/java/com/frentix/olat/vitero/ui/SignColumnDescriptor.java b/src/main/java/com/frentix/olat/vitero/ui/SignColumnDescriptor.java
new file mode 100644
index 0000000000000000000000000000000000000000..9ac403a6ca43db3bd90455a005156050ea3b0428
--- /dev/null
+++ b/src/main/java/com/frentix/olat/vitero/ui/SignColumnDescriptor.java
@@ -0,0 +1,75 @@
+/**
+ * OLAT - Online Learning and Training<br>
+ * http://www.olat.org
+ * <p>
+ * Licensed under the Apache License, Version 2.0 (the "License"); <br>
+ * you may not use this file except in compliance with the License.<br>
+ * You may obtain a copy of the License at
+ * <p>
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * <p>
+ * Unless required by applicable law or agreed to in writing,<br>
+ * software distributed under the License is distributed on an "AS IS" BASIS, <br>
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. <br>
+ * See the License for the specific language governing permissions and <br>
+ * limitations under the License.
+ * <p>
+ * Copyright (c) frentix GmbH<br>
+ * http://www.frentix.com<br>
+ * <p>
+ */
+package com.frentix.olat.vitero.ui;
+
+import java.util.Locale;
+
+import org.olat.core.gui.components.table.DefaultColumnDescriptor;
+import org.olat.core.gui.render.Renderer;
+import org.olat.core.gui.render.StringOutput;
+import org.olat.core.gui.translator.Translator;
+
+/**
+ *
+ * Description:<br>
+ *
+ * <P>
+ * Initial Date: 11 oct. 2011 <br>
+ *
+ * @author srosse, stephane.rosse@frentix.com, http://www.frentix.com
+ */
+public class SignColumnDescriptor extends DefaultColumnDescriptor {
+
+ private final Translator translator;
+
+ public SignColumnDescriptor(final String headerKey, final int dataColumn, final Locale locale, final Translator translator) {
+ super(headerKey, dataColumn, null, locale);
+ this.translator = translator;
+ }
+
+ @Override
+ public String getAction(int row) {
+ int sortedRow = table.getSortedRow(row);
+ Object state = getTable().getTableDataModel().getValueAt(sortedRow, getDataColumn());
+ if(state instanceof Sign) {
+ Sign sign = (Sign)state;
+ switch(sign) {
+ case signin: return sign.name();
+ case signout: return sign.name();
+ default: return null;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public void renderValue(StringOutput sb, int row, Renderer renderer) {
+ int sortedRow = table.getSortedRow(row);
+ Object state = getTable().getTableDataModel().getValueAt(sortedRow, getDataColumn());
+ if(state instanceof Sign) {
+ Sign sign = (Sign)state;
+ switch(sign) {
+ case signin: sb.append(translator.translate("signin")); break;
+ case signout: sb.append(translator.translate("signout")); break;
+ }
+ }
+ }
+}
diff --git a/src/main/java/com/frentix/olat/vitero/ui/StartColumnDescriptor.java b/src/main/java/com/frentix/olat/vitero/ui/StartColumnDescriptor.java
new file mode 100644
index 0000000000000000000000000000000000000000..026405cba1bd4316e96142d601b6420c06300f72
--- /dev/null
+++ b/src/main/java/com/frentix/olat/vitero/ui/StartColumnDescriptor.java
@@ -0,0 +1,78 @@
+/**
+ * OLAT - Online Learning and Training<br>
+ * http://www.olat.org
+ * <p>
+ * Licensed under the Apache License, Version 2.0 (the "License"); <br>
+ * you may not use this file except in compliance with the License.<br>
+ * You may obtain a copy of the License at
+ * <p>
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * <p>
+ * Unless required by applicable law or agreed to in writing,<br>
+ * software distributed under the License is distributed on an "AS IS" BASIS, <br>
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. <br>
+ * See the License for the specific language governing permissions and <br>
+ * limitations under the License.
+ * <p>
+ * Copyright (c) frentix GmbH<br>
+ * http://www.frentix.com<br>
+ * <p>
+ */
+package com.frentix.olat.vitero.ui;
+
+import java.util.Locale;
+
+import org.olat.core.gui.components.table.DefaultColumnDescriptor;
+import org.olat.core.gui.render.Renderer;
+import org.olat.core.gui.render.StringOutput;
+import org.olat.core.gui.translator.Translator;
+
+import com.frentix.olat.vitero.manager.ViteroManager;
+import com.frentix.olat.vitero.model.ViteroBooking;
+
+/**
+ *
+ * Description:<br>
+ *
+ * <P>
+ * Initial Date: 11 oct. 2011 <br>
+ *
+ * @author srosse, stephane.rosse@frentix.com, http://www.frentix.com
+ */
+public class StartColumnDescriptor extends DefaultColumnDescriptor {
+
+ private final ViteroManager viteroManager;
+
+ private final Translator translator;
+
+ public StartColumnDescriptor(final String headerKey, String action, final Locale locale, ViteroManager viteroManager, Translator translator) {
+ super(headerKey, 1, action, locale);
+ this.viteroManager = viteroManager;
+ this.translator = translator;
+ }
+
+ @Override
+ public String getAction(int row) {
+ int sortedRow = table.getSortedRow(row);
+ ViteroBooking booking = (ViteroBooking)getTable().getTableDataModel().getObject(sortedRow);
+ if(viteroManager.canGoBooking(booking)) {
+ Object state = getTable().getTableDataModel().getValueAt(sortedRow, ViteroBookingDataModel.Column.sign.ordinal());
+ if(Sign.signout.equals(state)) {
+ return super.getAction(row);
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public void renderValue(StringOutput sb, int row, Renderer renderer) {
+ int sortedRow = table.getSortedRow(row);
+ ViteroBooking booking = (ViteroBooking)getTable().getTableDataModel().getObject(sortedRow);
+ if(viteroManager.canGoBooking(booking)) {
+ Object state = getTable().getTableDataModel().getValueAt(sortedRow, ViteroBookingDataModel.Column.sign.ordinal());
+ if(Sign.signout.equals(state)) {
+ sb.append(translator.translate(getHeaderKey()));
+ }
+ }
+ }
+}
diff --git a/src/main/java/com/frentix/olat/vitero/ui/ViteroAdminBookingInfosController.java b/src/main/java/com/frentix/olat/vitero/ui/ViteroAdminBookingInfosController.java
new file mode 100644
index 0000000000000000000000000000000000000000..8f88759506792ea7d20b251cc62dbd048da64e00
--- /dev/null
+++ b/src/main/java/com/frentix/olat/vitero/ui/ViteroAdminBookingInfosController.java
@@ -0,0 +1,117 @@
+/**
+ * OLAT - Online Learning and Training<br>
+ * http://www.olat.org
+ * <p>
+ * Licensed under the Apache License, Version 2.0 (the "License"); <br>
+ * you may not use this file except in compliance with the License.<br>
+ * You may obtain a copy of the License at
+ * <p>
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * <p>
+ * Unless required by applicable law or agreed to in writing,<br>
+ * software distributed under the License is distributed on an "AS IS" BASIS, <br>
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. <br>
+ * See the License for the specific language governing permissions and <br>
+ * limitations under the License.
+ * <p>
+ * Copyright (c) frentix GmbH<br>
+ * http://www.frentix.com<br>
+ * <p>
+ */
+package com.frentix.olat.vitero.ui;
+
+import org.olat.core.gui.UserRequest;
+import org.olat.core.gui.components.Component;
+import org.olat.core.gui.components.link.Link;
+import org.olat.core.gui.components.link.LinkFactory;
+import org.olat.core.gui.components.segmentedview.SegmentViewComponent;
+import org.olat.core.gui.components.segmentedview.SegmentViewEvent;
+import org.olat.core.gui.components.segmentedview.SegmentViewFactory;
+import org.olat.core.gui.components.velocity.VelocityContainer;
+import org.olat.core.gui.control.Event;
+import org.olat.core.gui.control.WindowControl;
+import org.olat.core.gui.control.controller.BasicController;
+
+import com.frentix.olat.vitero.model.ViteroBooking;
+import com.frentix.olat.vitero.model.ViteroGroup;
+
+/**
+ *
+ * Description:<br>
+ *
+ * <P>
+ * Initial Date: 13 oct. 2011 <br>
+ *
+ * @author srosse, stephane.rosse@frentix.com, http://www.frentix.com
+ */
+public class ViteroAdminBookingInfosController extends BasicController {
+
+ private final Link infosLink;
+ private final Link membersLink;
+ private final SegmentViewComponent segmentView;
+ private final VelocityContainer mainVC;
+
+ private ViteroAdminBookingRawInfosController infosController;
+ private ViteroAdminBookingMembersController membersController;
+
+ private final ViteroBooking booking;
+ private final ViteroGroup group;
+
+ public ViteroAdminBookingInfosController(UserRequest ureq, WindowControl wControl, ViteroBooking booking, ViteroGroup group) {
+ super(ureq, wControl);
+
+ this.booking = booking;
+ this.group = group;
+
+ mainVC = createVelocityContainer("vitero_admin");
+
+ segmentView = SegmentViewFactory.createSegmentView("segments", mainVC, this);
+ infosLink = LinkFactory.createLink("vitero.account", mainVC, this);
+ segmentView.addSegment(infosLink, true);
+
+ membersLink = LinkFactory.createLink("users", mainVC, this);
+ segmentView.addSegment(membersLink, false);
+
+ doOpenInfos(ureq);
+
+ putInitialPanel(mainVC);
+
+ }
+
+ @Override
+ protected void doDispose() {
+ //
+ }
+
+ @Override
+ protected void event(UserRequest ureq, Component source, Event event) {
+ if(source == segmentView) {
+ if(event instanceof SegmentViewEvent) {
+ SegmentViewEvent sve = (SegmentViewEvent)event;
+ String segmentCName = sve.getComponentName();
+ Component clickedLink = mainVC.getComponent(segmentCName);
+ if (clickedLink == infosLink) {
+ doOpenInfos(ureq);
+ } else if (clickedLink == membersLink){
+ doOpenMembers(ureq);
+ }
+ }
+ }
+ }
+
+ private void doOpenInfos(UserRequest ureq) {
+ if(infosController == null) {
+ infosController = new ViteroAdminBookingRawInfosController(ureq, getWindowControl(), booking, group);
+ listenTo(infosController);
+ }
+ mainVC.put("segmentCmp", infosController.getInitialComponent());
+ }
+
+ private void doOpenMembers(UserRequest ureq) {
+ if(membersController == null) {
+ membersController = new ViteroAdminBookingMembersController(ureq, getWindowControl(), booking);
+ listenTo(membersController);
+ }
+ mainVC.put("segmentCmp", membersController.getInitialComponent());
+ }
+}
\ No newline at end of file
diff --git a/src/main/java/com/frentix/olat/vitero/ui/ViteroAdminBookingMembersController.java b/src/main/java/com/frentix/olat/vitero/ui/ViteroAdminBookingMembersController.java
new file mode 100644
index 0000000000000000000000000000000000000000..fe205b6722f891c65f1a2a0e8490626f47cc7b8c
--- /dev/null
+++ b/src/main/java/com/frentix/olat/vitero/ui/ViteroAdminBookingMembersController.java
@@ -0,0 +1,228 @@
+/**
+ * OLAT - Online Learning and Training<br>
+ * http://www.olat.org
+ * <p>
+ * Licensed under the Apache License, Version 2.0 (the "License"); <br>
+ * you may not use this file except in compliance with the License.<br>
+ * You may obtain a copy of the License at
+ * <p>
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * <p>
+ * Unless required by applicable law or agreed to in writing,<br>
+ * software distributed under the License is distributed on an "AS IS" BASIS, <br>
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. <br>
+ * See the License for the specific language governing permissions and <br>
+ * limitations under the License.
+ * <p>
+ * Copyright (c) frentix GmbH<br>
+ * http://www.frentix.com<br>
+ * <p>
+ */
+package com.frentix.olat.vitero.ui;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Locale;
+
+import org.olat.core.CoreSpringFactory;
+import org.olat.core.gui.UserRequest;
+import org.olat.core.gui.components.Component;
+import org.olat.core.gui.components.table.ColumnDescriptor;
+import org.olat.core.gui.components.table.StaticColumnDescriptor;
+import org.olat.core.gui.components.table.TableController;
+import org.olat.core.gui.components.table.TableDataModel;
+import org.olat.core.gui.components.table.TableEvent;
+import org.olat.core.gui.components.table.TableGuiConfiguration;
+import org.olat.core.gui.components.table.TableMultiSelectEvent;
+import org.olat.core.gui.components.velocity.VelocityContainer;
+import org.olat.core.gui.control.Controller;
+import org.olat.core.gui.control.Event;
+import org.olat.core.gui.control.WindowControl;
+import org.olat.core.gui.control.controller.BasicController;
+import org.olat.core.gui.translator.Translator;
+import org.olat.core.id.UserConstants;
+import org.olat.user.UserManager;
+import org.olat.user.propertyhandlers.UserPropertyHandler;
+
+import com.frentix.olat.vitero.manager.ViteroManager;
+import com.frentix.olat.vitero.manager.VmsNotAvailableException;
+import com.frentix.olat.vitero.model.ViteroBooking;
+import com.frentix.olat.vitero.model.ViteroUser;
+
+/**
+ *
+ * Description:<br>
+ *
+ * <P>
+ * Initial Date: 13 oct. 2011 <br>
+ *
+ * @author srosse, stephane.rosse@frentix.com, http://www.frentix.com
+ */
+public class ViteroAdminBookingMembersController extends BasicController {
+
+ private final ViteroBooking booking;
+ private final ViteroManager viteroManager;
+
+ private final TableController tableCtr;
+ private final VelocityContainer mainVC;
+
+ public ViteroAdminBookingMembersController(UserRequest ureq, WindowControl wControl, ViteroBooking booking) {
+ super(ureq, wControl);
+
+ this.booking = booking;
+ viteroManager = (ViteroManager)CoreSpringFactory.getBean("viteroManager");
+
+ mainVC = createVelocityContainer("vms_user_admin");
+
+ TableGuiConfiguration tableConfig = new TableGuiConfiguration();
+ tableConfig.setTableEmptyMessage(translate("users.empty"));
+
+ Translator trans = UserManager.getInstance().getPropertyHandlerTranslator(getTranslator());
+ tableCtr = new TableController(tableConfig, ureq, getWindowControl(), trans);
+ listenTo(tableCtr);
+
+ tableCtr.addColumnDescriptor(getColumnDescriptor(Col.firstName.ordinal(), UserConstants.FIRSTNAME, ureq.getLocale()));
+ tableCtr.addColumnDescriptor(getColumnDescriptor(Col.lastName.ordinal(), UserConstants.LASTNAME, ureq.getLocale()));
+ tableCtr.addColumnDescriptor(getColumnDescriptor(Col.email.ordinal(), UserConstants.EMAIL, ureq.getLocale()));
+ tableCtr.addColumnDescriptor(new StaticColumnDescriptor("signout", "table.action", translate("signout")));
+
+ tableCtr.addMultiSelectAction("signout", "signout");
+ tableCtr.setMultiSelect(true);
+
+ loadModel();
+ mainVC.put("userTable", tableCtr.getInitialComponent());
+
+ putInitialPanel(mainVC);
+ }
+
+ private ColumnDescriptor getColumnDescriptor(int pos, String attrName, Locale locale) {
+ List<UserPropertyHandler> userPropertyHandlers = UserManager.getInstance().getAllUserPropertyHandlers();
+ for(UserPropertyHandler handler:userPropertyHandlers) {
+ if(handler.getName().equals(attrName)) {
+ return handler.getColumnDescriptor(pos, null, locale);
+ }
+ }
+ return null;
+ }
+
+ @Override
+ protected void doDispose() {
+ //
+ }
+
+ @Override
+ protected void event(UserRequest ureq, Component source, Event event) {
+ //
+ }
+
+ @Override
+ protected void event(UserRequest ureq, Controller source, Event event) {
+ if(source == tableCtr) {
+ if(event instanceof TableEvent) {
+ TableEvent e = (TableEvent)event;
+ int row = e.getRowId();
+ ViteroUser identity = (ViteroUser)tableCtr.getTableDataModel().getObject(row);
+ if("signout".equals(e.getActionId())) {
+ signOut(ureq, Collections.singletonList(identity));
+ }
+ } else if(event instanceof TableMultiSelectEvent) {
+ TableMultiSelectEvent e = (TableMultiSelectEvent)event;
+ List<ViteroUser> identities = new ArrayList<ViteroUser>();
+ for (int i = e.getSelection().nextSetBit(0); i >= 0; i = e.getSelection().nextSetBit(i + 1)) {
+ ViteroUser identity = (ViteroUser)tableCtr.getTableDataModel().getObject(i);
+ identities.add(identity);
+ }
+ if("signout".equals(e.getAction())) {
+ signOut(ureq, identities);
+ }
+ }
+
+ }
+ super.event(ureq, source, event);
+ }
+
+ private void signOut(UserRequest ureq, List<ViteroUser> members) {
+ try {
+ for(ViteroUser member:members) {
+ if(viteroManager.removeFromRoom(booking, member.getUserId())) {
+ showInfo("signout.ok");
+ } else {
+ showInfo("signout.nok");
+ break;
+ }
+ }
+ loadModel();
+ } catch (VmsNotAvailableException e) {
+ showError(VmsNotAvailableException.I18N_KEY);
+ }
+ }
+
+ private void loadModel() {
+ try {
+ List<ViteroUser> users = viteroManager.getUsersOf(booking);
+ tableCtr.setTableDataModel(new UserToGroupDataModel(users));
+
+ int numOfFreePlaces = booking.getRoomSize() - users.size();
+ mainVC.contextPut("freePlaces", new String[]{Integer.toString(numOfFreePlaces)});
+ } catch (VmsNotAvailableException e) {
+ showError(VmsNotAvailableException.I18N_KEY);
+ }
+ }
+
+ public class UserToGroupDataModel implements TableDataModel {
+
+ private List<ViteroUser> members;
+
+ public UserToGroupDataModel() {
+ //
+ }
+
+ public UserToGroupDataModel( List<ViteroUser> members) {
+ this.members = members;
+ }
+
+ @Override
+ public int getColumnCount() {
+ return 4;
+ }
+
+ @Override
+ public int getRowCount() {
+ return members == null ? 0 : members.size();
+ }
+
+ @Override
+ public Object getValueAt(int row, int col) {
+ ViteroUser identity = getObject(row);
+ switch(Col.values()[col]) {
+ case firstName: return identity.getFirstName();
+ case lastName: return identity.getLastName();
+ case email: return identity.getEmail();
+ }
+ return null;
+ }
+
+ @Override
+ public ViteroUser getObject(int row) {
+ return members.get(row);
+ }
+
+ @Override
+ public void setObjects(List objects) {
+ this.members = objects;
+ }
+
+ @Override
+ public Object createCopyWithEmptyList() {
+ return new UserToGroupDataModel();
+ }
+ }
+
+ public enum Col {
+ firstName,
+ lastName,
+ email,
+ sign,
+ }
+}
\ No newline at end of file
diff --git a/src/main/java/com/frentix/olat/vitero/ui/ViteroAdminBookingRawInfosController.java b/src/main/java/com/frentix/olat/vitero/ui/ViteroAdminBookingRawInfosController.java
new file mode 100644
index 0000000000000000000000000000000000000000..912d25459334148a709d1f551820f9915d4517a2
--- /dev/null
+++ b/src/main/java/com/frentix/olat/vitero/ui/ViteroAdminBookingRawInfosController.java
@@ -0,0 +1,91 @@
+/**
+ * OLAT - Online Learning and Training<br>
+ * http://www.olat.org
+ * <p>
+ * Licensed under the Apache License, Version 2.0 (the "License"); <br>
+ * you may not use this file except in compliance with the License.<br>
+ * You may obtain a copy of the License at
+ * <p>
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * <p>
+ * Unless required by applicable law or agreed to in writing,<br>
+ * software distributed under the License is distributed on an "AS IS" BASIS, <br>
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. <br>
+ * See the License for the specific language governing permissions and <br>
+ * limitations under the License.
+ * <p>
+ * Copyright (c) frentix GmbH<br>
+ * http://www.frentix.com<br>
+ * <p>
+ */
+package com.frentix.olat.vitero.ui;
+
+import org.olat.core.gui.UserRequest;
+import org.olat.core.gui.components.form.flexible.FormItemContainer;
+import org.olat.core.gui.components.form.flexible.elements.MultipleSelectionElement;
+import org.olat.core.gui.components.form.flexible.impl.FormBasicController;
+import org.olat.core.gui.control.Controller;
+import org.olat.core.gui.control.WindowControl;
+import org.olat.core.util.Formatter;
+
+import com.frentix.olat.vitero.model.ViteroBooking;
+import com.frentix.olat.vitero.model.ViteroGroup;
+
+/**
+ *
+ * Description:<br>
+ *
+ * <P>
+ * Initial Date: 13 oct. 2011 <br>
+ *
+ * @author srosse, stephane.rosse@frentix.com, http://www.frentix.com
+ */
+public class ViteroAdminBookingRawInfosController extends FormBasicController {
+
+ private final ViteroGroup group;
+ private final ViteroBooking booking;
+ private final Formatter formatter;
+ private static final String[] autoSignInKeys = new String[]{"on"};
+ private final String[] autoSignInValues;
+
+ public ViteroAdminBookingRawInfosController(UserRequest ureq, WindowControl wControl, ViteroBooking booking,
+ ViteroGroup group) {
+ super(ureq, wControl);
+
+ this.group = group;
+ this.booking = booking;
+ this.formatter = Formatter.getInstance(getLocale());
+ autoSignInValues = new String[]{ translate("enabled") };
+
+ initForm(ureq);
+ }
+
+ @Override
+ protected void initForm(FormItemContainer formLayout, Controller listener, UserRequest ureq) {
+ uifactory.addStaticTextElement("booking.id", Integer.toString(booking.getBookingId()), formLayout);
+ uifactory.addStaticTextElement("booking.begin", formatter.formatDateAndTime(booking.getStart()), formLayout);
+ uifactory.addStaticTextElement("booking.end", formatter.formatDateAndTime(booking.getEnd()), formLayout);
+ uifactory.addStaticTextElement("booking.beginBuffer", Integer.toString(booking.getStartBuffer()), formLayout);
+ uifactory.addStaticTextElement("booking.endBuffer", Integer.toString(booking.getEndBuffer()), formLayout);
+ uifactory.addStaticTextElement("booking.roomSize", Integer.toString(booking.getRoomSize()), formLayout);
+ uifactory.addStaticTextElement("group.numOfParticipants", Integer.toString(group.getNumOfParticipants()), formLayout);
+ uifactory.addStaticTextElement("group.id", Integer.toString(group.getGroupId()), formLayout);
+ uifactory.addStaticTextElement("group.name", group.getName(), formLayout);
+
+ MultipleSelectionElement autoSignIn = uifactory.addCheckboxesHorizontal("booking.autoSignIn", formLayout, autoSignInKeys, autoSignInValues, null);
+ if(booking.isAutoSignIn()) {
+ autoSignIn.select(autoSignInKeys[0], true);
+ }
+ autoSignIn.setEnabled(false);
+ }
+
+ @Override
+ protected void doDispose() {
+ //
+ }
+
+ @Override
+ protected void formOK(UserRequest ureq) {
+ //
+ }
+}
diff --git a/src/main/java/com/frentix/olat/vitero/ui/ViteroAdminController.java b/src/main/java/com/frentix/olat/vitero/ui/ViteroAdminController.java
new file mode 100644
index 0000000000000000000000000000000000000000..bfc9488b54d21a70d12def99ee54709915792dad
--- /dev/null
+++ b/src/main/java/com/frentix/olat/vitero/ui/ViteroAdminController.java
@@ -0,0 +1,113 @@
+/**
+ * OLAT - Online Learning and Training<br>
+ * http://www.olat.org
+ * <p>
+ * Licensed under the Apache License, Version 2.0 (the "License"); <br>
+ * you may not use this file except in compliance with the License.<br>
+ * You may obtain a copy of the License at
+ * <p>
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * <p>
+ * Unless required by applicable law or agreed to in writing,<br>
+ * software distributed under the License is distributed on an "AS IS" BASIS, <br>
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. <br>
+ * See the License for the specific language governing permissions and <br>
+ * limitations under the License.
+ * <p>
+ * Copyright (c) frentix GmbH<br>
+ * http://www.frentix.com<br>
+ * <p>
+ */
+package com.frentix.olat.vitero.ui;
+
+import org.olat.core.CoreSpringFactory;
+import org.olat.core.gui.UserRequest;
+import org.olat.core.gui.components.Component;
+import org.olat.core.gui.components.link.Link;
+import org.olat.core.gui.components.link.LinkFactory;
+import org.olat.core.gui.components.segmentedview.SegmentViewComponent;
+import org.olat.core.gui.components.segmentedview.SegmentViewEvent;
+import org.olat.core.gui.components.segmentedview.SegmentViewFactory;
+import org.olat.core.gui.components.velocity.VelocityContainer;
+import org.olat.core.gui.control.Event;
+import org.olat.core.gui.control.WindowControl;
+import org.olat.core.gui.control.controller.BasicController;
+
+import com.frentix.olat.vitero.ViteroModule;
+
+/**
+ *
+ * Description:<br>
+ *
+ * <P>
+ * Initial Date: 6 oct. 2011 <br>
+ *
+ * @author srosse, stephane.rosse@frentix.com, http://www.frentix.com
+ */
+public class ViteroAdminController extends BasicController {
+
+ private final ViteroModule viteroModule;
+
+ private final Link accountLink;
+ private Link bookingsLink;
+ private SegmentViewComponent segmentView;
+ private final VelocityContainer mainVC;
+
+ private ViteroConfigurationController configController;
+ private ViteroBookingsAdminController bookingController;
+
+ public ViteroAdminController(UserRequest ureq, WindowControl wControl) {
+ super(ureq, wControl);
+
+ viteroModule = (ViteroModule)CoreSpringFactory.getBean("viteroModule");
+ mainVC = createVelocityContainer("vitero_admin");
+
+ segmentView = SegmentViewFactory.createSegmentView("segments", mainVC, this);
+ accountLink = LinkFactory.createLink("vitero.account", mainVC, this);
+ segmentView.addSegment(accountLink, true);
+
+ bookingsLink = LinkFactory.createLink("booking.title", mainVC, this);
+ segmentView.addSegment(bookingsLink, false);
+
+ doOpenAccountSettings(ureq);
+
+ putInitialPanel(mainVC);
+ }
+
+ @Override
+ protected void doDispose() {
+ //auto-disposed
+ }
+
+ @Override
+ protected void event(UserRequest ureq, Component source, Event event) {
+ if(source == segmentView) {
+ if(event instanceof SegmentViewEvent) {
+ SegmentViewEvent sve = (SegmentViewEvent)event;
+ String segmentCName = sve.getComponentName();
+ Component clickedLink = mainVC.getComponent(segmentCName);
+ if (clickedLink == accountLink) {
+ doOpenAccountSettings(ureq);
+ } else if (clickedLink == bookingsLink){
+ doOpenBookings(ureq);
+ }
+ }
+ }
+ }
+
+ private void doOpenAccountSettings(UserRequest ureq) {
+ if(configController == null) {
+ configController = new ViteroConfigurationController(ureq, getWindowControl(), viteroModule);
+ listenTo(configController);
+ }
+ mainVC.put("segmentCmp", configController.getInitialComponent());
+ }
+
+ private void doOpenBookings(UserRequest ureq) {
+ if(bookingController == null) {
+ bookingController = new ViteroBookingsAdminController(ureq, getWindowControl());
+ listenTo(bookingController);
+ }
+ mainVC.put("segmentCmp", bookingController.getInitialComponent());
+ }
+}
\ No newline at end of file
diff --git a/src/main/java/com/frentix/olat/vitero/ui/ViteroBookingDataModel.java b/src/main/java/com/frentix/olat/vitero/ui/ViteroBookingDataModel.java
new file mode 100644
index 0000000000000000000000000000000000000000..40ec51d4a94f52539ada0671306ef9aec64ed941
--- /dev/null
+++ b/src/main/java/com/frentix/olat/vitero/ui/ViteroBookingDataModel.java
@@ -0,0 +1,134 @@
+/**
+ * OLAT - Online Learning and Training<br>
+ * http://www.olat.org
+ * <p>
+ * Licensed under the Apache License, Version 2.0 (the "License"); <br>
+ * you may not use this file except in compliance with the License.<br>
+ * You may obtain a copy of the License at
+ * <p>
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * <p>
+ * Unless required by applicable law or agreed to in writing,<br>
+ * software distributed under the License is distributed on an "AS IS" BASIS, <br>
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. <br>
+ * See the License for the specific language governing permissions and <br>
+ * limitations under the License.
+ * <p>
+ * Copyright (c) frentix GmbH<br>
+ * http://www.frentix.com<br>
+ * <p>
+ */
+package com.frentix.olat.vitero.ui;
+
+import java.util.List;
+
+import org.olat.core.gui.components.table.TableDataModel;
+import org.olat.core.util.StringHelper;
+import org.olat.properties.Property;
+
+import com.frentix.olat.vitero.model.ViteroBooking;
+
+/**
+ *
+ * Description:<br>
+ *
+ * <P>
+ * Initial Date: 10 oct. 2011 <br>
+ *
+ * @author srosse, stephane.rosse@frentix.com, http://www.frentix.com
+ */
+public class ViteroBookingDataModel implements TableDataModel {
+
+ private List<ViteroBooking> bookings;
+ private List<ViteroBooking> signedInBookings;
+
+
+ public ViteroBookingDataModel() {
+ //
+ }
+
+ public ViteroBookingDataModel(List<ViteroBooking> bookings) {
+ this.bookings = bookings;
+ }
+
+ public ViteroBookingDataModel(List<ViteroBooking> bookings, List<ViteroBooking> signedInBookings) {
+ this.bookings = bookings;
+ this.signedInBookings = signedInBookings;
+ }
+
+ @Override
+ public int getColumnCount() {
+ return 2;
+ }
+
+ @Override
+ public int getRowCount() {
+ return bookings == null ? 0 : bookings.size();
+ }
+
+ @Override
+ public ViteroBooking getObject(int row) {
+ return bookings.get(row);
+ }
+
+ @Override
+ public Object getValueAt(int row, int col) {
+ ViteroBooking booking = getObject(row);
+ switch(Column.values()[col]) {
+ case begin: return booking.getStart();
+ case end: return booking.getEnd();
+ case roomSize: {
+ int roomSize = booking.getRoomSize();
+ if(roomSize > 0) {
+ return Integer.toString(roomSize);
+ }
+ return "-";
+ }
+ case resource: {
+ Property property = booking.getProperty();
+ if(property.getGrp() != null) {
+ return property.getGrp().getName();
+ } else if(StringHelper.containsNonWhitespace(booking.getResourceName())) {
+ return booking.getResourceName();
+ } else if(StringHelper.containsNonWhitespace(property.getResourceTypeName())) {
+ return property.getResourceTypeName() + "(" + property.getResourceTypeId() + ")";
+ }
+ return "";
+ }
+ case sign: {
+ boolean auto = booking.isAutoSignIn();
+ if(auto) {
+ if(signedInBookings != null) {
+ for(ViteroBooking signedInBooking: signedInBookings) {
+ if(booking.getBookingId() == signedInBooking.getBookingId()) {
+ return Sign.signout;
+ }
+ }
+ }
+ return Sign.signin;
+ }
+ return Sign.no;
+ }
+ default: return "";
+ }
+ }
+
+ @Override
+ public void setObjects(List objects) {
+ this.bookings = objects;
+ }
+
+ @Override
+ public Object createCopyWithEmptyList() {
+ return new ViteroBookingDataModel();
+ }
+
+ public enum Column {
+ begin,
+ end,
+ roomSize,
+ resource,
+ open,
+ sign,
+ }
+}
\ No newline at end of file
diff --git a/src/main/java/com/frentix/olat/vitero/ui/ViteroBookingEditController.java b/src/main/java/com/frentix/olat/vitero/ui/ViteroBookingEditController.java
new file mode 100644
index 0000000000000000000000000000000000000000..1f7039821dae28566b5626928872cb96c4a0ed7a
--- /dev/null
+++ b/src/main/java/com/frentix/olat/vitero/ui/ViteroBookingEditController.java
@@ -0,0 +1,254 @@
+/**
+ * OLAT - Online Learning and Training<br>
+ * http://www.olat.org
+ * <p>
+ * Licensed under the Apache License, Version 2.0 (the "License"); <br>
+ * you may not use this file except in compliance with the License.<br>
+ * You may obtain a copy of the License at
+ * <p>
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * <p>
+ * Unless required by applicable law or agreed to in writing,<br>
+ * software distributed under the License is distributed on an "AS IS" BASIS, <br>
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. <br>
+ * See the License for the specific language governing permissions and <br>
+ * limitations under the License.
+ * <p>
+ * Copyright (c) frentix GmbH<br>
+ * http://www.frentix.com<br>
+ * <p>
+ */
+package com.frentix.olat.vitero.ui;
+
+import java.util.Collections;
+import java.util.Date;
+import java.util.List;
+
+import org.olat.core.CoreSpringFactory;
+import org.olat.core.gui.UserRequest;
+import org.olat.core.gui.components.form.flexible.FormItemContainer;
+import org.olat.core.gui.components.form.flexible.elements.DateChooser;
+import org.olat.core.gui.components.form.flexible.elements.MultipleSelectionElement;
+import org.olat.core.gui.components.form.flexible.elements.SingleSelection;
+import org.olat.core.gui.components.form.flexible.impl.FormBasicController;
+import org.olat.core.gui.components.form.flexible.impl.FormLayoutContainer;
+import org.olat.core.gui.control.Controller;
+import org.olat.core.gui.control.Event;
+import org.olat.core.gui.control.WindowControl;
+import org.olat.core.id.OLATResourceable;
+import org.olat.group.BusinessGroup;
+
+import com.frentix.olat.vitero.manager.ViteroManager;
+import com.frentix.olat.vitero.manager.VmsNotAvailableException;
+import com.frentix.olat.vitero.model.ViteroBooking;
+
+/**
+ *
+ * Description:<br>
+ *
+ * <P>
+ * Initial Date: 7 oct. 2011 <br>
+ *
+ * @author srosse, stephane.rosse@frentix.com, http://www.frentix.com
+ */
+public class ViteroBookingEditController extends FormBasicController {
+
+ private DateChooser beginChooser;
+ private DateChooser endChooser;
+ private SingleSelection beginBufferEl;
+ private SingleSelection endBufferEl;
+ private SingleSelection roomSizeEl;
+
+ private MultipleSelectionElement autoSignIn;
+
+ private static final String[] bufferKeys = new String[]{"0", "15", "30", "45", "60"};
+ private static final String[] bufferValues = bufferKeys;
+ private final String[] roomSizes;
+ private static final String[] autoSignInKeys = new String[]{"on"};
+ private final String[] autoSignInValues;
+
+ private final BusinessGroup group;
+ private final OLATResourceable ores;
+ private final ViteroBooking booking;
+ private final ViteroManager viteroManager;
+
+ public ViteroBookingEditController(UserRequest ureq, WindowControl wControl, BusinessGroup group, OLATResourceable ores, ViteroBooking booking) {
+ super(ureq, wControl);
+
+ this.group = group;
+ this.ores = ores;
+ this.booking = booking;
+ viteroManager = (ViteroManager)CoreSpringFactory.getBean("viteroManager");
+
+ List<Integer> sizes;
+ try {
+ sizes = viteroManager.getLicencedRoomSizes();
+
+ } catch (VmsNotAvailableException e) {
+ showError(VmsNotAvailableException.I18N_KEY);
+ sizes = Collections.emptyList();
+ }
+ roomSizes = new String[sizes.size()];
+
+ int i=0;
+ for(Integer size:sizes) {
+ roomSizes[i++] = size.toString();
+ }
+ autoSignInValues = new String[]{ translate("enabled") };
+
+ initForm(ureq);
+ }
+
+ @Override
+ protected void initForm(FormItemContainer formLayout, Controller listener, UserRequest ureq) {
+ setFormTitle("booking.admin.title");
+ boolean editable = booking.getBookingId() <= 0;
+ if(editable) {
+ setFormWarning("new.booking.warning");
+ }
+
+ //begin
+ beginChooser = uifactory.addDateChooser("booking.begin", "", formLayout);
+ beginChooser.setDisplaySize(21);
+ beginChooser.setDateChooserTimeEnabled(true);
+ beginChooser.setMandatory(true);
+ beginChooser.setDate(booking.getStart());
+ beginChooser.setEnabled(editable);
+ //end
+ endChooser = uifactory.addDateChooser("booking.end", "", formLayout);
+ endChooser.setDisplaySize(21);
+ endChooser.setDateChooserTimeEnabled(true);
+ endChooser.setMandatory(true);
+ endChooser.setDate(booking.getEnd());
+ endChooser.setEnabled(editable);
+
+ //buffer start
+ beginBufferEl = uifactory.addDropdownSingleselect("booking.beginBuffer", formLayout, bufferKeys, bufferValues, null);
+ beginBufferEl.select(Integer.toString(booking.getStartBuffer()), true);
+ beginBufferEl.setEnabled(editable);
+
+ //buffer end
+ endBufferEl = uifactory.addDropdownSingleselect("booking.endBuffer", formLayout, bufferKeys, bufferValues, null);
+ endBufferEl.select(Integer.toString(booking.getEndBuffer()), true);
+ endBufferEl.setEnabled(editable);
+
+ //room size
+ roomSizeEl = uifactory.addDropdownSingleselect("booking.roomSize", formLayout, roomSizes, roomSizes, null);
+ if(booking.getRoomSize() > 0) {
+ roomSizeEl.select(Integer.toString(booking.getRoomSize()), true);
+ }
+ roomSizeEl.setEnabled(editable);
+
+ autoSignIn = uifactory.addCheckboxesHorizontal("booking.autoSignIn", formLayout, autoSignInKeys, autoSignInValues, null);
+ if(booking.isAutoSignIn()) {
+ autoSignIn.select(autoSignInKeys[0], true);
+ }
+
+ FormLayoutContainer buttonCont = FormLayoutContainer.createButtonLayout("buttons", getTranslator());
+ formLayout.add(buttonCont);
+ uifactory.addFormSubmitButton("ok", buttonCont);
+ uifactory.addFormCancelButton("cancel", buttonCont, ureq, getWindowControl());
+ }
+
+ @Override
+ protected void doDispose() {
+ //
+ }
+
+ public ViteroBooking getUserObject() {
+ return booking;
+ }
+
+ @Override
+ protected boolean validateFormLogic(UserRequest ureq) {
+ boolean allOk = true;
+
+ Date begin = beginChooser.getDate();
+ beginChooser.clearError();
+ if(begin == null) {
+ beginChooser.setErrorKey("form.legende.mandatory", null);
+ allOk = false;
+ } else if(new Date().after(begin)) {
+ beginChooser.setErrorKey("error.bookingInPast", null);
+ allOk = false;
+ }
+
+ Date end = endChooser.getDate();
+ endChooser.clearError();
+ if(end == null) {
+ endChooser.setErrorKey("form.legende.mandatory", null);
+ allOk = false;
+ } else if(new Date().after(begin)) {
+ beginChooser.setErrorKey("error.bookingInPast", null);
+ allOk = false;
+ } else if(end.before(begin)) {
+ beginChooser.setErrorKey("error.bookingInPast", null);
+ allOk = false;
+ }
+
+ roomSizeEl.clearError();
+ if(!roomSizeEl.isOneSelected()) {
+ roomSizeEl.setErrorKey("form.legende.mandatory", null);
+ allOk = false;
+ }
+
+ return allOk && super.validateFormLogic(ureq);
+ }
+
+ @Override
+ protected void formOK(UserRequest ureq) {
+ Date begin = beginChooser.getDate();
+ booking.setStart(begin);
+
+ int beginBuffer = 0;
+ if(beginBufferEl.isOneSelected()) {
+ beginBuffer = Integer.parseInt(beginBufferEl.getSelectedKey());
+ }
+ booking.setStartBuffer(beginBuffer);
+
+ Date end = endChooser.getDate();
+ booking.setEnd(end);
+
+ int endBuffer = 0;
+ if(endBufferEl.isOneSelected()) {
+ endBuffer = Integer.parseInt(endBufferEl.getSelectedKey());
+ }
+ booking.setStartBuffer(endBuffer);
+
+ int roomSize = -1;
+ if(roomSizeEl.isOneSelected()) {
+ roomSize = Integer.parseInt(roomSizeEl.getSelectedKey());
+ }
+ booking.setRoomSize(roomSize);
+
+ boolean auto = autoSignIn.isMultiselect() && autoSignIn.isSelected(0);
+ booking.setAutoSignIn(auto);
+
+ try {
+ if(booking.getBookingId() >= 0) {
+ ViteroBooking updatedBooking = viteroManager.updateBooking(group, ores, booking);
+ if(updatedBooking != null) {
+ showInfo("check.ok");
+ fireEvent(ureq, Event.DONE_EVENT);
+ } else {
+ showError("check.nok");
+ }
+ } else {
+ if(viteroManager.createBooking(group, ores, booking)) {
+ showInfo("check.ok");
+ fireEvent(ureq, Event.DONE_EVENT);
+ } else {
+ showError("check.nok");
+ }
+ }
+ } catch (VmsNotAvailableException e) {
+ showError(VmsNotAvailableException.I18N_KEY);
+ }
+
+ }
+
+ @Override
+ protected void formCancelled(UserRequest ureq) {
+ fireEvent(ureq, Event.CANCELLED_EVENT);
+ }
+}
\ No newline at end of file
diff --git a/src/main/java/com/frentix/olat/vitero/ui/ViteroBookingsAdminController.java b/src/main/java/com/frentix/olat/vitero/ui/ViteroBookingsAdminController.java
new file mode 100644
index 0000000000000000000000000000000000000000..9da39b50708bb5e16263c353924539aad3a4c426
--- /dev/null
+++ b/src/main/java/com/frentix/olat/vitero/ui/ViteroBookingsAdminController.java
@@ -0,0 +1,209 @@
+/**
+ * OLAT - Online Learning and Training<br>
+ * http://www.olat.org
+ * <p>
+ * Licensed under the Apache License, Version 2.0 (the "License"); <br>
+ * you may not use this file except in compliance with the License.<br>
+ * You may obtain a copy of the License at
+ * <p>
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * <p>
+ * Unless required by applicable law or agreed to in writing,<br>
+ * software distributed under the License is distributed on an "AS IS" BASIS, <br>
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. <br>
+ * See the License for the specific language governing permissions and <br>
+ * limitations under the License.
+ * <p>
+ * Copyright (c) frentix GmbH<br>
+ * http://www.frentix.com<br>
+ * <p>
+ */
+package com.frentix.olat.vitero.ui;
+
+import java.util.List;
+
+import org.olat.NewControllerFactory;
+import org.olat.core.CoreSpringFactory;
+import org.olat.core.gui.UserRequest;
+import org.olat.core.gui.components.Component;
+import org.olat.core.gui.components.table.DefaultColumnDescriptor;
+import org.olat.core.gui.components.table.StaticColumnDescriptor;
+import org.olat.core.gui.components.table.TableController;
+import org.olat.core.gui.components.table.TableEvent;
+import org.olat.core.gui.components.table.TableGuiConfiguration;
+import org.olat.core.gui.control.Controller;
+import org.olat.core.gui.control.Event;
+import org.olat.core.gui.control.WindowControl;
+import org.olat.core.gui.control.controller.BasicController;
+import org.olat.core.gui.control.generic.closablewrapper.CloseableModalController;
+import org.olat.core.gui.control.generic.modal.DialogBoxController;
+import org.olat.core.gui.control.generic.modal.DialogBoxUIFactory;
+import org.olat.core.id.OLATResourceable;
+import org.olat.core.id.context.BusinessControl;
+import org.olat.core.id.context.BusinessControlFactory;
+import org.olat.core.util.resource.OresHelper;
+import org.olat.properties.Property;
+import org.olat.repository.RepositoryEntry;
+import org.olat.repository.RepositoryManager;
+
+import com.frentix.olat.vitero.manager.ViteroManager;
+import com.frentix.olat.vitero.manager.VmsNotAvailableException;
+import com.frentix.olat.vitero.model.ViteroBooking;
+import com.frentix.olat.vitero.model.ViteroGroup;
+
+/**
+ *
+ * Description:<br>
+ *
+ * <P>
+ * Initial Date: 10 oct. 2011 <br>
+ *
+ * @author srosse, stephane.rosse@frentix.com, http://www.frentix.com
+ */
+public class ViteroBookingsAdminController extends BasicController {
+
+ private final ViteroManager viteroManager;
+
+ private DialogBoxController dialogCtr;
+ private final TableController tableCtr;
+ private CloseableModalController cmc;
+ private ViteroAdminBookingInfosController infoController;
+
+ public ViteroBookingsAdminController(UserRequest ureq, WindowControl wControl) {
+ super(ureq, wControl);
+
+ viteroManager = (ViteroManager) CoreSpringFactory.getBean("viteroManager");
+
+ TableGuiConfiguration tableConfig = new TableGuiConfiguration();
+ tableConfig.setTableEmptyMessage(translate("table.empty"));
+ tableConfig.setDownloadOffered(true);
+ tableConfig.setColumnMovingOffered(false);
+ tableConfig.setSortingEnabled(true);
+ tableConfig.setDisplayTableHeader(true);
+ tableConfig.setDisplayRowCount(false);
+ tableConfig.setPageingEnabled(false);
+
+ tableCtr = new TableController(tableConfig, ureq, getWindowControl(), getTranslator());
+ listenTo(tableCtr);
+
+ tableCtr.addColumnDescriptor(new DefaultColumnDescriptor("booking.begin", ViteroBookingDataModel.Column.begin.ordinal(), null, ureq.getLocale()));
+ tableCtr.addColumnDescriptor(new DefaultColumnDescriptor("booking.end", ViteroBookingDataModel.Column.end.ordinal(), null, ureq.getLocale()));
+ tableCtr.addColumnDescriptor(new DefaultColumnDescriptor("booking.roomSize", ViteroBookingDataModel.Column.roomSize.ordinal(), null, ureq.getLocale()));
+ tableCtr.addColumnDescriptor(new DefaultColumnDescriptor("booking.resource", ViteroBookingDataModel.Column.resource.ordinal(), "resource", ureq.getLocale()));
+
+ tableCtr.addColumnDescriptor(new StaticColumnDescriptor("infos", "table.action", translate("booking.infos")));
+ tableCtr.addColumnDescriptor(new StaticColumnDescriptor("delete", "table.action", translate("delete")));
+
+ tableCtr.setSortColumn(0, false);
+
+ reloadModel();
+
+ putInitialPanel(tableCtr.getInitialComponent());
+ }
+
+ @Override
+ protected void doDispose() {
+ //auto disposed
+ }
+
+ @Override
+ protected void event(UserRequest ureq, Component source, Event event) {
+ //nothing to do
+ }
+
+ @Override
+ protected void event(UserRequest ureq, Controller source, Event event) {
+ if(source == tableCtr) {
+ if(event instanceof TableEvent) {
+ TableEvent e = (TableEvent)event;
+ int row = e.getRowId();
+ ViteroBooking booking = (ViteroBooking)tableCtr.getTableDataModel().getObject(row);
+ if("delete".equals(e.getActionId())) {
+ confirmDeleteVitero(ureq, booking);
+ } else if("infos".equals(e.getActionId())) {
+ openInfoBox(ureq, booking);
+ } else if("resource".equals(e.getActionId())) {
+ openResource(ureq, booking);
+ }
+ }
+ } else if(source == dialogCtr) {
+ if (DialogBoxUIFactory.isOkEvent(event)) {
+ ViteroBooking booking = (ViteroBooking)dialogCtr.getUserObject();
+ deleteBooking(ureq, booking);
+ }
+ } else if (source == cmc ) {
+ removeAsListenerAndDispose(infoController);
+ removeAsListenerAndDispose(cmc);
+ } else if (source == infoController) {
+ cmc.deactivate();
+ removeAsListenerAndDispose(infoController);
+ removeAsListenerAndDispose(cmc);
+ reloadModel();
+ }
+ }
+
+ protected void openResource(UserRequest ureq, ViteroBooking booking) {
+ Property prop = booking.getProperty();
+ if(prop != null) {
+ String url;
+ if(prop.getGrp() != null) {
+ url = "[BusinessGroup:" + prop.getGrp().getKey() + "]";
+ } else {
+ OLATResourceable ores = OresHelper.createOLATResourceableInstance(prop.getResourceTypeName(), prop.getResourceTypeId());
+ RepositoryEntry re = RepositoryManager.getInstance().lookupRepositoryEntry(ores, false);
+ if(re != null) {
+ url = "[RepositoryEntry:" + re.getKey() + "]";
+ } else {
+ showWarning("resource.dont.exist");
+ return;
+ }
+ }
+ BusinessControl bc = BusinessControlFactory.getInstance().createFromString(url);
+ WindowControl bwControl = BusinessControlFactory.getInstance().createBusinessWindowControl(bc, getWindowControl());
+ NewControllerFactory.getInstance().launch(ureq, bwControl);
+ }
+ }
+
+ protected void openInfoBox(UserRequest ureq, ViteroBooking booking) {
+ removeAsListenerAndDispose(infoController);
+ removeAsListenerAndDispose(cmc);
+
+ try {
+ ViteroGroup group = viteroManager.getGroup(booking.getGroupId());
+ infoController = new ViteroAdminBookingInfosController(ureq, getWindowControl(), booking, group);
+ listenTo(infoController);
+
+ cmc = new CloseableModalController(getWindowControl(), translate("close"), infoController.getInitialComponent(), true, translate("booking.raw.title"));
+ listenTo(cmc);
+ cmc.activate();
+ } catch (VmsNotAvailableException e) {
+ showError(VmsNotAvailableException.I18N_KEY);
+ }
+ }
+
+ protected void deleteBooking(UserRequest ureq, ViteroBooking booking) {
+ try {
+ if( viteroManager.deleteBooking(booking)) {
+ showInfo("delete.ok");
+ } else {
+ showError("delete.nok");
+ }
+ reloadModel();
+ } catch (VmsNotAvailableException e) {
+ showError(VmsNotAvailableException.I18N_KEY);
+ }
+ }
+
+ protected void confirmDeleteVitero(UserRequest ureq, ViteroBooking booking) {
+ String title = translate("delete");
+ String text = translate("delete.confirm");
+ dialogCtr = activateOkCancelDialog(ureq, title, text, dialogCtr);
+ dialogCtr.setUserObject(booking);
+ }
+
+ protected void reloadModel() {
+ List<ViteroBooking> bookings = viteroManager.getBookings(null, null);
+ ViteroBookingDataModel tableModel = new ViteroBookingDataModel(bookings);
+ tableCtr.setTableDataModel(tableModel);
+ }
+}
\ No newline at end of file
diff --git a/src/main/java/com/frentix/olat/vitero/ui/ViteroBookingsController.java b/src/main/java/com/frentix/olat/vitero/ui/ViteroBookingsController.java
new file mode 100644
index 0000000000000000000000000000000000000000..8eb51ceeaa4d1a6722594a86b133b74ec7da7673
--- /dev/null
+++ b/src/main/java/com/frentix/olat/vitero/ui/ViteroBookingsController.java
@@ -0,0 +1,182 @@
+/**
+ * OLAT - Online Learning and Training<br>
+ * http://www.olat.org
+ * <p>
+ * Licensed under the Apache License, Version 2.0 (the "License"); <br>
+ * you may not use this file except in compliance with the License.<br>
+ * You may obtain a copy of the License at
+ * <p>
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * <p>
+ * Unless required by applicable law or agreed to in writing,<br>
+ * software distributed under the License is distributed on an "AS IS" BASIS, <br>
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. <br>
+ * See the License for the specific language governing permissions and <br>
+ * limitations under the License.
+ * <p>
+ * Copyright (c) frentix GmbH<br>
+ * http://www.frentix.com<br>
+ * <p>
+ */
+package com.frentix.olat.vitero.ui;
+
+import java.util.List;
+
+import org.olat.core.CoreSpringFactory;
+import org.olat.core.gui.UserRequest;
+import org.olat.core.gui.components.Component;
+import org.olat.core.gui.components.table.DefaultColumnDescriptor;
+import org.olat.core.gui.components.table.TableController;
+import org.olat.core.gui.components.table.TableDataModel;
+import org.olat.core.gui.components.table.TableEvent;
+import org.olat.core.gui.components.table.TableGuiConfiguration;
+import org.olat.core.gui.components.velocity.VelocityContainer;
+import org.olat.core.gui.control.Controller;
+import org.olat.core.gui.control.Event;
+import org.olat.core.gui.control.WindowControl;
+import org.olat.core.gui.control.controller.BasicController;
+import org.olat.core.gui.media.RedirectMediaResource;
+import org.olat.core.id.OLATResourceable;
+import org.olat.group.BusinessGroup;
+
+import com.frentix.olat.vitero.manager.ViteroManager;
+import com.frentix.olat.vitero.manager.VmsNotAvailableException;
+import com.frentix.olat.vitero.model.StartBookingComparator;
+import com.frentix.olat.vitero.model.ViteroBooking;
+
+import edu.emory.mathcs.backport.java.util.Collections;
+
+/**
+ *
+ * Description:<br>
+ *
+ * <P>
+ * Initial Date: 6 oct. 2011 <br>
+ *
+ * @author srosse, stephane.rosse@frentix.com, http://www.frentix.com
+ */
+public class ViteroBookingsController extends BasicController {
+
+ private final VelocityContainer runVC;
+ private final TableController tableCtr;
+
+ private final BusinessGroup group;
+ private final OLATResourceable ores;
+ private final ViteroManager viteroManager;
+
+ public ViteroBookingsController(UserRequest ureq, WindowControl wControl,
+ BusinessGroup group, OLATResourceable ores) {
+ super(ureq, wControl);
+
+ this.ores = ores;
+ this.group = group;
+ viteroManager = (ViteroManager) CoreSpringFactory.getBean("viteroManager");
+
+ TableGuiConfiguration tableConfig = new TableGuiConfiguration();
+ tableConfig.setTableEmptyMessage(translate("table.empty"));
+ tableConfig.setColumnMovingOffered(true);
+ tableConfig.setSortingEnabled(true);
+ tableCtr = new TableController(tableConfig, ureq, wControl, getTranslator());
+ tableCtr.addColumnDescriptor(new DefaultColumnDescriptor("booking.begin", ViteroBookingDataModel.Column.begin.ordinal(), null, ureq.getLocale()));
+ tableCtr.addColumnDescriptor(new DefaultColumnDescriptor("booking.end", ViteroBookingDataModel.Column.end.ordinal(), null, ureq.getLocale()));
+
+ StartColumnDescriptor startRoom = new StartColumnDescriptor("start", "start", ureq.getLocale(), viteroManager, getTranslator());
+ startRoom.setIsPopUpWindowAction(true, "");
+ tableCtr.addColumnDescriptor(startRoom);
+
+ tableCtr.addColumnDescriptor(new SignColumnDescriptor("signin", ViteroBookingDataModel.Column.sign.ordinal(), ureq.getLocale(), getTranslator()));
+
+ loadModel();
+
+ tableCtr.setSortColumn(1, true);// timeframe
+ listenTo(tableCtr);
+
+ runVC = createVelocityContainer("run");
+ runVC.put("bookings", tableCtr.getInitialComponent());
+
+ putInitialPanel(runVC);
+ }
+
+ @Override
+ protected void doDispose() {
+ //
+ }
+
+ @Override
+ protected void event(UserRequest ureq, Component source, Event event) {
+ // nothing to do
+ }
+
+ @Override
+ protected void event(UserRequest ureq, Controller source, Event event) {
+ if(source == tableCtr) {
+ if(event instanceof TableEvent) {
+ TableEvent e = (TableEvent)event;
+ int row = e.getRowId();
+ ViteroBooking booking = (ViteroBooking)tableCtr.getTableDataModel().getObject(row);
+ if("start".equals(e.getActionId())) {
+ openVitero(ureq, booking);
+ } else if("signin".equals(e.getActionId())) {
+ signInVitero(ureq, booking);
+ } else if("signout".equals(e.getActionId())) {
+ signOutVitero(ureq, booking);
+ }
+ }
+ }
+ super.event(ureq, source, event);
+ }
+
+ protected void loadModel() {
+ try {
+ List<ViteroBooking> bookings = viteroManager.getBookings(group, ores);
+ List<ViteroBooking> myBookings = viteroManager.getBookingInFutures(getIdentity());
+ FilterBookings.filterMyFutureBookings(bookings, myBookings);
+ Collections.sort(bookings, new StartBookingComparator());
+ TableDataModel tableData = new ViteroBookingDataModel(bookings, myBookings);
+ tableCtr.setTableDataModel(tableData);
+ } catch (VmsNotAvailableException e) {
+ TableDataModel tableData = new ViteroBookingDataModel();
+ tableCtr.setTableDataModel(tableData);
+ showError(VmsNotAvailableException.I18N_KEY);
+ }
+ }
+
+ protected void signInVitero(UserRequest ureq, ViteroBooking booking) {
+ try {
+ boolean ok = viteroManager.addToRoom(booking, ureq.getIdentity(), null);
+ if(ok) {
+ showInfo("signin.ok");
+ } else {
+ showError("signin.nok");
+ }
+ loadModel();
+ } catch (VmsNotAvailableException e) {
+ showError(VmsNotAvailableException.I18N_KEY);
+ }
+
+ }
+
+ protected void signOutVitero(UserRequest ureq, ViteroBooking booking) {
+ try {
+ boolean ok = viteroManager.removeFromRoom(booking, ureq.getIdentity());
+ if(ok) {
+ showInfo("signout.ok");
+ } else {
+ showError("signout.nok");
+ }
+ loadModel();
+ } catch (VmsNotAvailableException e) {
+ showError(VmsNotAvailableException.I18N_KEY);
+ }
+ }
+
+ protected void openVitero(UserRequest ureq, ViteroBooking booking) {
+ try {
+ String url = viteroManager.getURLToBooking(ureq.getIdentity(), booking);
+ RedirectMediaResource redirect = new RedirectMediaResource(url);
+ ureq.getDispatchResult().setResultingMediaResource(redirect);
+ } catch (VmsNotAvailableException e) {
+ showError(VmsNotAvailableException.I18N_KEY);
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/main/java/com/frentix/olat/vitero/ui/ViteroBookingsEditController.java b/src/main/java/com/frentix/olat/vitero/ui/ViteroBookingsEditController.java
new file mode 100644
index 0000000000000000000000000000000000000000..f073dbe436096af889a82d600bac3b857cca312d
--- /dev/null
+++ b/src/main/java/com/frentix/olat/vitero/ui/ViteroBookingsEditController.java
@@ -0,0 +1,279 @@
+/**
+ * OLAT - Online Learning and Training<br>
+ * http://www.olat.org
+ * <p>
+ * Licensed under the Apache License, Version 2.0 (the "License"); <br>
+ * you may not use this file except in compliance with the License.<br>
+ * You may obtain a copy of the License at
+ * <p>
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * <p>
+ * Unless required by applicable law or agreed to in writing,<br>
+ * software distributed under the License is distributed on an "AS IS" BASIS, <br>
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. <br>
+ * See the License for the specific language governing permissions and <br>
+ * limitations under the License.
+ * <p>
+ * Copyright (c) frentix GmbH<br>
+ * http://www.frentix.com<br>
+ * <p>
+ */
+package com.frentix.olat.vitero.ui;
+
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.List;
+
+import org.olat.core.CoreSpringFactory;
+import org.olat.core.gui.UserRequest;
+import org.olat.core.gui.components.form.flexible.FormItem;
+import org.olat.core.gui.components.form.flexible.FormItemContainer;
+import org.olat.core.gui.components.form.flexible.elements.FormLink;
+import org.olat.core.gui.components.form.flexible.impl.FormBasicController;
+import org.olat.core.gui.components.form.flexible.impl.FormEvent;
+import org.olat.core.gui.components.form.flexible.impl.FormLayoutContainer;
+import org.olat.core.gui.components.link.Link;
+import org.olat.core.gui.control.Controller;
+import org.olat.core.gui.control.Event;
+import org.olat.core.gui.control.WindowControl;
+import org.olat.core.gui.control.generic.closablewrapper.CloseableModalController;
+import org.olat.core.gui.control.generic.modal.DialogBoxController;
+import org.olat.core.gui.control.generic.modal.DialogBoxUIFactory;
+import org.olat.core.id.OLATResourceable;
+import org.olat.course.editor.NodeEditController;
+import org.olat.group.BusinessGroup;
+
+import com.frentix.olat.vitero.manager.ViteroManager;
+import com.frentix.olat.vitero.manager.VmsNotAvailableException;
+import com.frentix.olat.vitero.model.ViteroBooking;
+
+/**
+ *
+ * Description:<br>
+ *
+ * <P>
+ * Initial Date: 6 oct. 2011 <br>
+ *
+ * @author srosse, stephane.rosse@frentix.com, http://www.frentix.com
+ */
+public class ViteroBookingsEditController extends FormBasicController {
+
+ private FormLink newButton;
+ private FormLink occupiedRoomsLink;
+ private final List<BookingDisplay> bookingDisplays = new ArrayList<BookingDisplay>();
+
+ private CloseableModalController cmc;
+ private DialogBoxController dialogCtr;
+ private ViteroBookingEditController bookingController;
+ private ViteroRoomsOverviewController roomsOverviewController;
+ private ViteroUserToGroupController usersController;
+
+ private final String resourceName;
+ private final BusinessGroup group;
+ private final OLATResourceable ores;
+ private final ViteroManager viteroManager;
+
+ public ViteroBookingsEditController(UserRequest ureq, WindowControl wControl, BusinessGroup group, OLATResourceable ores, String resourceName) {
+ super(ureq, wControl, "edit");
+
+ this.group = group;
+ this.ores = ores;
+ this.resourceName = resourceName;
+ viteroManager = (ViteroManager)CoreSpringFactory.getBean("viteroManager");
+
+ initForm(ureq);
+ }
+
+ @Override
+ protected void initForm(FormItemContainer formLayout, Controller listener, UserRequest ureq) {
+ reloadModel();
+
+ FormLayoutContainer buttonLayout = FormLayoutContainer.createButtonLayout("buttons-cont", getTranslator());
+ formLayout.add(buttonLayout);
+ newButton = uifactory.addFormLink("new", buttonLayout, Link.BUTTON);
+ occupiedRoomsLink = uifactory.addFormLink("roomsOverview", buttonLayout, Link.BUTTON);
+ }
+
+ @Override
+ protected void doDispose() {
+ // nothing to dispose
+ }
+
+ protected void reloadModel() {
+ bookingDisplays.clear();
+ List<ViteroBooking> bookings = viteroManager.getBookings(group, ores);
+ int i=0;
+ for(ViteroBooking booking:bookings) {
+ BookingDisplay display = new BookingDisplay(booking);
+ display.setDeleteButton(uifactory.addFormLink("delete_" + i++, "delete", "delete", flc, Link.BUTTON));
+ display.setEditButton(uifactory.addFormLink("edit_" + i++, "edit", "edit", flc, Link.BUTTON));
+ display.setUsersButton(uifactory.addFormLink("users_" + i++, "users", "users", flc, Link.BUTTON));
+ bookingDisplays.add(display);
+ }
+ flc.contextPut("bookingDisplays", bookingDisplays);
+ }
+
+ @Override
+ protected void formOK(UserRequest ureq) {
+ fireEvent(ureq, NodeEditController.NODECONFIG_CHANGED_EVENT);
+ }
+
+ @Override
+ protected void formInnerEvent(UserRequest ureq, FormItem source, FormEvent event) {
+ if (source == newButton) {
+ newBooking(ureq);
+ } else if (source == occupiedRoomsLink) {
+ occupiedRooms(ureq);
+ } else if (source instanceof FormLink) {
+ for(BookingDisplay display: bookingDisplays) {
+ if(display.getDeleteButton() == source) {
+ confirmDeleteBooking(ureq, display);
+ break;
+ } else if(display.getEditButton() == source) {
+ ViteroBooking viteroBooking = display.getMeeting();
+ editBooking(ureq, viteroBooking);
+ break;
+ } else if(display.getUsersButton() == source) {
+ ViteroBooking viteroBooking = display.getMeeting();
+ usersBooking(ureq, viteroBooking);
+ break;
+ }
+ }
+ reloadModel();
+ }
+ super.formInnerEvent(ureq, source, event);
+ }
+
+ @Override
+ protected void event(UserRequest ureq, Controller source, Event event) {
+ if (source == cmc ) {
+ removeAsListenerAndDispose(bookingController);
+ removeAsListenerAndDispose(cmc);
+ } else if (source == bookingController) {
+ if(Event.DONE_EVENT.equals(event)) {
+ fireEvent(ureq, event);
+ }
+ cmc.deactivate();
+ removeAsListenerAndDispose(bookingController);
+ removeAsListenerAndDispose(cmc);
+ reloadModel();
+ } else if(source == dialogCtr) {
+ if (DialogBoxUIFactory.isOkEvent(event)) {
+ ViteroBooking booking = (ViteroBooking)dialogCtr.getUserObject();
+ deleteBooking(ureq, booking);
+ }
+ }
+ }
+
+ protected void occupiedRooms(UserRequest ureq) {
+ removeAsListenerAndDispose(bookingController);
+
+ roomsOverviewController = new ViteroRoomsOverviewController(ureq, getWindowControl());
+ listenTo(roomsOverviewController);
+
+ removeAsListenerAndDispose(cmc);
+ cmc = new CloseableModalController(getWindowControl(), translate("close"), roomsOverviewController.getInitialComponent(), true, translate("roomsOverview"));
+ listenTo(cmc);
+ cmc.activate();
+ }
+
+ protected void deleteBooking(UserRequest ureq, ViteroBooking booking) {
+ try {
+ if(viteroManager.deleteBooking(booking)) {
+ showInfo("delete.ok");
+ } else {
+ showError("delete.nok");
+ }
+ reloadModel();
+ } catch (VmsNotAvailableException e) {
+ showError(VmsNotAvailableException.I18N_KEY);
+ }
+ }
+
+ protected void confirmDeleteBooking(UserRequest ureq, BookingDisplay bookingDisplay) {
+ String title = translate("delete");
+ String text = translate("delete.confirm");
+ dialogCtr = activateOkCancelDialog(ureq, title, text, dialogCtr);
+ dialogCtr.setUserObject(bookingDisplay.getMeeting());
+ }
+
+ protected void newBooking(UserRequest ureq) {
+ try {
+ ViteroBooking viteroBooking = viteroManager.createBooking(resourceName);
+ editBooking(ureq, viteroBooking);
+ } catch (VmsNotAvailableException e) {
+ showError(VmsNotAvailableException.I18N_KEY);
+ }
+ }
+
+ protected void editBooking(UserRequest ureq, ViteroBooking viteroBooking) {
+ removeAsListenerAndDispose(bookingController);
+
+ bookingController = new ViteroBookingEditController(ureq, getWindowControl(), group, ores, viteroBooking);
+ listenTo(bookingController);
+
+ removeAsListenerAndDispose(cmc);
+ cmc = new CloseableModalController(getWindowControl(), translate("close"), bookingController.getInitialComponent(), true, translate("edit"));
+ listenTo(cmc);
+ cmc.activate();
+ }
+
+ protected void usersBooking(UserRequest ureq, ViteroBooking viteroBooking) {
+ removeAsListenerAndDispose(usersController);
+
+ usersController = new ViteroUserToGroupController(ureq, getWindowControl(), group, ores, viteroBooking);
+ listenTo(usersController);
+
+ removeAsListenerAndDispose(cmc);
+ cmc = new CloseableModalController(getWindowControl(), translate("close"), usersController.getInitialComponent(), true, translate("users"));
+ listenTo(cmc);
+ cmc.activate();
+ }
+
+ public class BookingDisplay {
+ private final ViteroBooking meeting;
+ private FormLink deleteButton;
+ private FormLink editButton;
+ private FormLink usersButton;
+
+ public BookingDisplay(ViteroBooking meeting) {
+ this.meeting = meeting;
+ }
+
+ public ViteroBooking getMeeting() {
+ return meeting;
+ }
+
+ public Date getBegin() {
+ return meeting.getStart();
+ }
+
+ public Date getEnd() {
+ return meeting.getEnd();
+ }
+
+ public FormLink getDeleteButton() {
+ return deleteButton;
+ }
+
+ public void setDeleteButton(FormLink deleteButton) {
+ this.deleteButton = deleteButton;
+ }
+
+ public FormLink getEditButton() {
+ return editButton;
+ }
+
+ public void setEditButton(FormLink editButton) {
+ this.editButton = editButton;
+ }
+
+ public FormLink getUsersButton() {
+ return usersButton;
+ }
+
+ public void setUsersButton(FormLink usersButton) {
+ this.usersButton = usersButton;
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/main/java/com/frentix/olat/vitero/ui/ViteroBookingsRunController.java b/src/main/java/com/frentix/olat/vitero/ui/ViteroBookingsRunController.java
new file mode 100644
index 0000000000000000000000000000000000000000..da97b720deff597ef52eeff7c084170b6c8b78b9
--- /dev/null
+++ b/src/main/java/com/frentix/olat/vitero/ui/ViteroBookingsRunController.java
@@ -0,0 +1,126 @@
+/**
+ * OLAT - Online Learning and Training<br>
+ * http://www.olat.org
+ * <p>
+ * Licensed under the Apache License, Version 2.0 (the "License"); <br>
+ * you may not use this file except in compliance with the License.<br>
+ * You may obtain a copy of the License at
+ * <p>
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * <p>
+ * Unless required by applicable law or agreed to in writing,<br>
+ * software distributed under the License is distributed on an "AS IS" BASIS, <br>
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. <br>
+ * See the License for the specific language governing permissions and <br>
+ * limitations under the License.
+ * <p>
+ * Copyright (c) frentix GmbH<br>
+ * http://www.frentix.com<br>
+ * <p>
+ */
+package com.frentix.olat.vitero.ui;
+
+import org.olat.core.gui.UserRequest;
+import org.olat.core.gui.components.Component;
+import org.olat.core.gui.components.link.Link;
+import org.olat.core.gui.components.link.LinkFactory;
+import org.olat.core.gui.components.segmentedview.SegmentViewComponent;
+import org.olat.core.gui.components.segmentedview.SegmentViewEvent;
+import org.olat.core.gui.components.segmentedview.SegmentViewFactory;
+import org.olat.core.gui.components.velocity.VelocityContainer;
+import org.olat.core.gui.control.Event;
+import org.olat.core.gui.control.WindowControl;
+import org.olat.core.gui.control.controller.BasicController;
+import org.olat.core.id.OLATResourceable;
+import org.olat.group.BusinessGroup;
+
+/**
+ *
+ * Description:<br>
+ *
+ * <P>
+ * Initial Date: 13 oct. 2011 <br>
+ *
+ * @author srosse, stephane.rosse@frentix.com, http://www.frentix.com
+ */
+public class ViteroBookingsRunController extends BasicController {
+
+ private Link bookingsLink;
+ private Link adminLink;
+ private SegmentViewComponent segmentView;
+ private VelocityContainer mainVC;
+
+ private ViteroBookingsController bookingsController;
+ private ViteroBookingsEditController adminController;
+
+ private final BusinessGroup group;
+ private final OLATResourceable ores;
+ private final String resourceName;
+
+ public ViteroBookingsRunController(UserRequest ureq, WindowControl wControl, BusinessGroup group, OLATResourceable ores,
+ String resourceName, boolean admin) {
+ super(ureq, wControl);
+
+ this.group = group;
+ this.ores = ores;
+ this.resourceName = resourceName;
+
+ if(ureq.getUserSession().getRoles().isGuestOnly()) {
+
+ } else if(admin) {
+ mainVC = createVelocityContainer("run_admin");
+
+ segmentView = SegmentViewFactory.createSegmentView("segments", mainVC, this);
+ bookingsLink = LinkFactory.createLink("booking.title", mainVC, this);
+ segmentView.addSegment(bookingsLink, true);
+
+ adminLink = LinkFactory.createLink("booking.admin.title", mainVC, this);
+ segmentView.addSegment(adminLink, false);
+
+ doOpenBookings(ureq);
+
+ putInitialPanel(mainVC);
+ } else {
+ bookingsController = new ViteroBookingsController(ureq, wControl,group, ores);
+ listenTo(bookingsController);
+ putInitialPanel(bookingsController.getInitialComponent());
+ }
+ }
+
+ @Override
+ protected void doDispose() {
+ //
+ }
+
+ @Override
+ protected void event(UserRequest ureq, Component source, Event event) {
+ if(source == segmentView) {
+ if(event instanceof SegmentViewEvent) {
+ SegmentViewEvent sve = (SegmentViewEvent)event;
+ String segmentCName = sve.getComponentName();
+ Component clickedLink = mainVC.getComponent(segmentCName);
+ if (clickedLink == bookingsLink) {
+ doOpenBookings(ureq);
+ } else if (clickedLink == adminLink){
+ doOpenAdmin(ureq);
+ }
+ }
+ }
+ }
+
+ private void doOpenBookings(UserRequest ureq) {
+ if(bookingsController == null) {
+ bookingsController = new ViteroBookingsController(ureq, getWindowControl(), group, ores);
+ listenTo(bookingsController);
+ }
+ mainVC.put("segmentCmp", bookingsController.getInitialComponent());
+ }
+
+ private void doOpenAdmin(UserRequest ureq) {
+ if(adminController == null) {
+ adminController = new ViteroBookingsEditController(ureq, getWindowControl(), group, ores, resourceName);
+ listenTo(adminController);
+ }
+ mainVC.put("segmentCmp", adminController.getInitialComponent());
+ }
+}
\ No newline at end of file
diff --git a/src/main/java/com/frentix/olat/vitero/ui/ViteroConfigurationController.java b/src/main/java/com/frentix/olat/vitero/ui/ViteroConfigurationController.java
new file mode 100644
index 0000000000000000000000000000000000000000..65b5f78e0bb028202ad17e371bf5c58aee23d7f2
--- /dev/null
+++ b/src/main/java/com/frentix/olat/vitero/ui/ViteroConfigurationController.java
@@ -0,0 +1,274 @@
+/**
+ * OLAT - Online Learning and Training<br>
+ * http://www.olat.org
+ * <p>
+ * Licensed under the Apache License, Version 2.0 (the "License"); <br>
+ * you may not use this file except in compliance with the License.<br>
+ * You may obtain a copy of the License at
+ * <p>
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * <p>
+ * Unless required by applicable law or agreed to in writing,<br>
+ * software distributed under the License is distributed on an "AS IS" BASIS, <br>
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. <br>
+ * See the License for the specific language governing permissions and <br>
+ * limitations under the License.
+ * <p>
+ * Copyright (c) frentix GmbH<br>
+ * http://www.frentix.com<br>
+ * <p>
+ */
+package com.frentix.olat.vitero.ui;
+
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.util.List;
+import java.util.TimeZone;
+
+import org.olat.core.CoreSpringFactory;
+import org.olat.core.gui.UserRequest;
+import org.olat.core.gui.components.form.flexible.FormItem;
+import org.olat.core.gui.components.form.flexible.FormItemContainer;
+import org.olat.core.gui.components.form.flexible.elements.FormLink;
+import org.olat.core.gui.components.form.flexible.elements.MultipleSelectionElement;
+import org.olat.core.gui.components.form.flexible.elements.SingleSelection;
+import org.olat.core.gui.components.form.flexible.elements.TextElement;
+import org.olat.core.gui.components.form.flexible.impl.FormBasicController;
+import org.olat.core.gui.components.form.flexible.impl.FormEvent;
+import org.olat.core.gui.components.form.flexible.impl.FormLayoutContainer;
+import org.olat.core.gui.components.link.Link;
+import org.olat.core.gui.control.Controller;
+import org.olat.core.gui.control.WindowControl;
+import org.olat.core.util.StringHelper;
+
+import com.frentix.olat.vitero.ViteroModule;
+import com.frentix.olat.vitero.ViteroTimezoneIDs;
+import com.frentix.olat.vitero.manager.ViteroManager;
+import com.frentix.olat.vitero.manager.VmsNotAvailableException;
+import com.frentix.olat.vitero.model.ViteroCustomer;
+
+import edu.emory.mathcs.backport.java.util.Arrays;
+
+/**
+ *
+ * Description:<br>
+ *
+ * <P>
+ * Initial Date: 10 oct. 2011 <br>
+ *
+ * @author srosse, stephane.rosse@frentix.com, http://www.frentix.com
+ */
+public class ViteroConfigurationController extends FormBasicController {
+
+ private final ViteroModule viteroModule;
+ private final ViteroManager viteroManager;
+
+ private FormLink checkLink;
+ private TextElement urlEl;
+ private TextElement loginEl;
+ private TextElement passwordEl;
+ private MultipleSelectionElement viteroEnabled;
+ private SingleSelection timeZoneEl;
+
+ private SingleSelection customersEl;
+
+ private static final String[] enabledKeys = new String[]{"on"};
+ private String[] enabledValues;
+ private String[] customerKeys;
+ private String[] customerValues;
+
+ public ViteroConfigurationController(UserRequest ureq, WindowControl wControl, ViteroModule viteroModule) {
+ super(ureq, wControl, "adminconfig");
+
+ this.viteroModule = viteroModule;
+ viteroManager = (ViteroManager)CoreSpringFactory.getBean("viteroManager");
+
+ enabledValues = new String[]{translate("enabled")};
+
+ try {
+ List<ViteroCustomer> customers = viteroManager.getCustomers();
+ customerKeys = new String[customers.size()];
+ customerValues = new String[customers.size()];
+ int i=0;
+ for(ViteroCustomer customer:customers) {
+ customerKeys[i] = Integer.toString(customer.getCustomerId());
+ customerValues[i++] = customer.getName();
+ }
+ } catch (VmsNotAvailableException e) {
+ customerKeys = new String[0];
+ customerValues = new String[0];
+ }
+
+ initForm(ureq);
+ }
+
+ @Override
+ protected void initForm(FormItemContainer formLayout, Controller listener, UserRequest ureq) {
+ if(formLayout instanceof FormLayoutContainer) {
+ FormLayoutContainer layoutContainer = (FormLayoutContainer)formLayout;
+
+ //module configuration
+ FormLayoutContainer moduleFlc = FormLayoutContainer.createDefaultFormLayout("flc_module", getTranslator());
+ layoutContainer.add(moduleFlc);
+
+ viteroEnabled = uifactory.addCheckboxesHorizontal("vitero.module.enabled", moduleFlc, enabledKeys, enabledValues, null);
+ viteroEnabled.select(enabledKeys[0], viteroModule.isEnabled());
+ viteroEnabled.addActionListener(listener, FormEvent.ONCHANGE);
+
+ //spacer
+ uifactory.addSpacerElement("Spacer", moduleFlc, false);
+
+ String[] timeZoneKeys = ViteroTimezoneIDs.TIMEZONE_IDS;
+ String[] timeZoneValues = new String[timeZoneKeys.length];
+ int i=0;
+ for(String timeZoneKey:timeZoneKeys) {
+ TimeZone timezone = TimeZone.getTimeZone(timeZoneKey);
+ if(timezone == null) {
+ timeZoneValues[i++] = timeZoneKey;
+ } else {
+ String value = timezone.getDisplayName(false, TimeZone.LONG);
+ timeZoneValues[i++] = value;
+ }
+ }
+
+ timeZoneEl = uifactory.addDropdownSingleselect("option.olatTimeZone", moduleFlc, timeZoneKeys, timeZoneValues, null);
+ timeZoneEl.select(viteroModule.getTimeZoneId(), true);
+
+ //account configuration
+ String vmsUri = viteroModule.getVmsURI().toString();
+ urlEl = uifactory.addTextElement("vitero-url", "option.baseurl", 255, vmsUri, moduleFlc);
+ urlEl.setDisplaySize(60);
+ String login = viteroModule.getAdminLogin();
+ loginEl = uifactory.addTextElement("vitero-login", "option.adminlogin", 32, login, moduleFlc);
+ String password = viteroModule.getAdminPassword();
+ passwordEl = uifactory.addPasswordElement("vitero-password", "option.adminpassword", 32, password, moduleFlc);
+ String customerId = Integer.toString(viteroModule.getCustomerId());
+
+ customersEl = uifactory.addDropdownSingleselect("option.customerId", moduleFlc, customerKeys, customerValues, null);
+ if(StringHelper.containsNonWhitespace(customerId) && Arrays.asList(customerKeys).contains(customerId)) {
+ customersEl.select(customerId, true);
+ }
+
+ //buttons save - check
+ FormLayoutContainer buttonLayout = FormLayoutContainer.createButtonLayout("save", getTranslator());
+ moduleFlc.add(buttonLayout);
+ uifactory.addFormSubmitButton("save", buttonLayout);
+ checkLink = uifactory.addFormLink("check", buttonLayout, Link.BUTTON);
+ }
+ }
+
+ @Override
+ protected void doDispose() {
+ //
+ }
+
+ @Override
+ protected void formOK(UserRequest ureq) {
+ try {
+ String url = urlEl.getValue();
+ viteroModule.setVmsURI(new URI(url));
+
+ String login = loginEl.getValue();
+ viteroModule.setAdminLogin(login);
+
+ String password = passwordEl.getValue();
+ viteroModule.setAdminPassword(password);
+
+ String customerId = customersEl.getSelectedKey();
+ viteroModule.setCustomerId(Integer.parseInt(customerId));
+
+ if(timeZoneEl.isOneSelected()) {
+ String timeZoneId = timeZoneEl.getSelectedKey();
+ viteroModule.setTimeZoneId(timeZoneId);
+ }
+ } catch (URISyntaxException e) {
+ logError("", e);
+ urlEl.setErrorKey("error.url.invalid", null);
+ } catch(NumberFormatException e) {
+ logError("", e);
+ urlEl.setErrorKey("error.customer.invalid", null);
+ }
+ }
+
+ @Override
+ protected boolean validateFormLogic(UserRequest ureq) {
+ boolean allOk = true;
+
+ String url = urlEl.getValue();
+ urlEl.clearError();
+ if(StringHelper.containsNonWhitespace(url)) {
+ try {
+ new URI(url);
+ } catch(Exception e) {
+ urlEl.setErrorKey("error.url.invalid", null);
+ allOk = false;
+ }
+ } else {
+ urlEl.setErrorKey("form.legende.mandatory", null);
+ allOk = false;
+ }
+
+ String login = loginEl.getValue();
+ loginEl.clearError();
+ if(!StringHelper.containsNonWhitespace(login)) {
+ loginEl.setErrorKey("form.legende.mandatory", null);
+ allOk = false;
+ }
+
+ String password = passwordEl.getValue();
+ passwordEl.clearError();
+ if(!StringHelper.containsNonWhitespace(password)) {
+ passwordEl.setErrorKey("form.legende.mandatory", null);
+ allOk = false;
+ }
+
+ customersEl.clearError();
+ if(customersEl.isOneSelected()) {
+ try {
+ String customerId = customersEl.getSelectedKey();
+ Integer.parseInt(customerId);
+ } catch(Exception e) {
+ customersEl.setErrorKey("error.customer.invalid", null);
+ allOk = false;
+ }
+ } else {
+ customersEl.setErrorKey("form.legende.mandatory", null);
+ allOk = false;
+ }
+
+ return allOk && super.validateFormLogic(ureq);
+ }
+
+ @Override
+ protected void formInnerEvent(UserRequest ureq, FormItem source, FormEvent event) {
+ if(source == viteroEnabled) {
+ boolean enabled = viteroEnabled.isSelected(0);
+ viteroModule.setEnabled(enabled);
+ } else if(source == checkLink) {
+ if(validateFormLogic(ureq)) {
+ checkConnection(ureq);
+ }
+ }
+ super.formInnerEvent(ureq, source, event);
+ }
+
+ protected void checkConnection(UserRequest ureq) {
+ String url = urlEl.getValue();
+ String login = loginEl.getValue();
+ String password = passwordEl.getValue();
+ String customerId = customersEl.isOneSelected() ? customersEl.getSelectedKey() : "";
+
+ try {
+ boolean ok = viteroManager.checkConnection(url, login, password, Integer.parseInt(customerId));
+ if(ok) {
+ showInfo("check.ok");
+ } else {
+ showError("check.nok");
+ }
+ } catch (NumberFormatException e) {
+ showError("error.customer.invalid");
+ } catch (VmsNotAvailableException e) {
+ showError(VmsNotAvailableException.I18N_KEY);
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/main/java/com/frentix/olat/vitero/ui/ViteroRoomsOverviewController.java b/src/main/java/com/frentix/olat/vitero/ui/ViteroRoomsOverviewController.java
new file mode 100644
index 0000000000000000000000000000000000000000..710eec1aaaf5271bd1044a60b6965dc5ac52d23c
--- /dev/null
+++ b/src/main/java/com/frentix/olat/vitero/ui/ViteroRoomsOverviewController.java
@@ -0,0 +1,101 @@
+/**
+ * OLAT - Online Learning and Training<br>
+ * http://www.olat.org
+ * <p>
+ * Licensed under the Apache License, Version 2.0 (the "License"); <br>
+ * you may not use this file except in compliance with the License.<br>
+ * You may obtain a copy of the License at
+ * <p>
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * <p>
+ * Unless required by applicable law or agreed to in writing,<br>
+ * software distributed under the License is distributed on an "AS IS" BASIS, <br>
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. <br>
+ * See the License for the specific language governing permissions and <br>
+ * limitations under the License.
+ * <p>
+ * Copyright (c) frentix GmbH<br>
+ * http://www.frentix.com<br>
+ * <p>
+ */
+package com.frentix.olat.vitero.ui;
+
+import java.util.Date;
+import java.util.List;
+
+import org.olat.core.CoreSpringFactory;
+import org.olat.core.gui.UserRequest;
+import org.olat.core.gui.components.Component;
+import org.olat.core.gui.components.table.DefaultColumnDescriptor;
+import org.olat.core.gui.components.table.TableController;
+import org.olat.core.gui.components.table.TableGuiConfiguration;
+import org.olat.core.gui.control.Event;
+import org.olat.core.gui.control.WindowControl;
+import org.olat.core.gui.control.controller.BasicController;
+
+import com.frentix.olat.vitero.manager.ViteroManager;
+import com.frentix.olat.vitero.model.ViteroBooking;
+import com.ibm.icu.util.Calendar;
+
+/**
+ *
+ * Description:<br>
+ *
+ * <P>
+ * Initial Date: 10 oct. 2011 <br>
+ *
+ * @author srosse, stephane.rosse@frentix.com, http://www.frentix.com
+ */
+public class ViteroRoomsOverviewController extends BasicController {
+
+ private final TableController tableCtr;
+ private final ViteroManager viteroManager;
+
+ public ViteroRoomsOverviewController(UserRequest ureq, WindowControl wControl) {
+ super(ureq, wControl);
+
+ viteroManager = (ViteroManager)CoreSpringFactory.getBean("viteroManager");
+
+ TableGuiConfiguration tableConfig = new TableGuiConfiguration();
+ tableConfig.setTableEmptyMessage(translate("table.empty"));
+ tableConfig.setDownloadOffered(true);
+ tableConfig.setColumnMovingOffered(false);
+ tableConfig.setSortingEnabled(true);
+ tableConfig.setDisplayTableHeader(true);
+ tableConfig.setDisplayRowCount(false);
+ tableConfig.setPageingEnabled(false);
+
+ tableCtr = new TableController(tableConfig, ureq, getWindowControl(), getTranslator());
+ listenTo(tableCtr);
+
+ tableCtr.addColumnDescriptor(new DefaultColumnDescriptor("booking.begin", ViteroBookingDataModel.Column.begin.ordinal(), null, ureq.getLocale()));
+ tableCtr.addColumnDescriptor(new DefaultColumnDescriptor("booking.end", ViteroBookingDataModel.Column.end.ordinal(), null, ureq.getLocale()));
+ tableCtr.addColumnDescriptor(new DefaultColumnDescriptor("booking.roomSize", ViteroBookingDataModel.Column.roomSize.ordinal(), null, ureq.getLocale()));
+
+ Calendar cal = Calendar.getInstance();
+ Date begin = cal.getTime();
+ cal.add(Calendar.DATE, 2);
+ Date end = cal.getTime();
+
+ List<ViteroBooking> bookings = viteroManager.getBookingByDate(begin, end);
+ ViteroBookingDataModel tableModel = new ViteroBookingDataModel(bookings);
+ tableCtr.setTableDataModel(tableModel);
+
+ putInitialPanel(tableCtr.getInitialComponent());
+ }
+
+ @Override
+ protected void doDispose() {
+ //
+ }
+
+ @Override
+ protected void event(UserRequest ureq, Component source, Event event) {
+ //
+ }
+
+
+
+
+
+}
diff --git a/src/main/java/com/frentix/olat/vitero/ui/ViteroUserToGroupController.java b/src/main/java/com/frentix/olat/vitero/ui/ViteroUserToGroupController.java
new file mode 100644
index 0000000000000000000000000000000000000000..5f2a165c80203356f9062b88f1039a79086b08fc
--- /dev/null
+++ b/src/main/java/com/frentix/olat/vitero/ui/ViteroUserToGroupController.java
@@ -0,0 +1,363 @@
+/**
+ * OLAT - Online Learning and Training<br>
+ * http://www.olat.org
+ * <p>
+ * Licensed under the Apache License, Version 2.0 (the "License"); <br>
+ * you may not use this file except in compliance with the License.<br>
+ * You may obtain a copy of the License at
+ * <p>
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * <p>
+ * Unless required by applicable law or agreed to in writing,<br>
+ * software distributed under the License is distributed on an "AS IS" BASIS, <br>
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. <br>
+ * See the License for the specific language governing permissions and <br>
+ * limitations under the License.
+ * <p>
+ * Copyright (c) frentix GmbH<br>
+ * http://www.frentix.com<br>
+ * <p>
+ */
+package com.frentix.olat.vitero.ui;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Locale;
+import java.util.Set;
+
+import org.olat.basesecurity.BaseSecurity;
+import org.olat.basesecurity.BaseSecurityManager;
+import org.olat.core.CoreSpringFactory;
+import org.olat.core.gui.UserRequest;
+import org.olat.core.gui.components.Component;
+import org.olat.core.gui.components.table.ColumnDescriptor;
+import org.olat.core.gui.components.table.CustomRenderColumnDescriptor;
+import org.olat.core.gui.components.table.TableController;
+import org.olat.core.gui.components.table.TableDataModel;
+import org.olat.core.gui.components.table.TableEvent;
+import org.olat.core.gui.components.table.TableGuiConfiguration;
+import org.olat.core.gui.components.table.TableMultiSelectEvent;
+import org.olat.core.gui.components.velocity.VelocityContainer;
+import org.olat.core.gui.control.Controller;
+import org.olat.core.gui.control.Event;
+import org.olat.core.gui.control.WindowControl;
+import org.olat.core.gui.control.controller.BasicController;
+import org.olat.core.gui.translator.Translator;
+import org.olat.core.id.Identity;
+import org.olat.core.id.OLATResourceable;
+import org.olat.core.id.UserConstants;
+import org.olat.course.CourseFactory;
+import org.olat.course.ICourse;
+import org.olat.course.groupsandrights.CourseGroupManager;
+import org.olat.group.BusinessGroup;
+import org.olat.repository.RepositoryEntry;
+import org.olat.repository.RepositoryManager;
+import org.olat.user.UserManager;
+import org.olat.user.propertyhandlers.UserPropertyHandler;
+
+import com.frentix.olat.vitero.manager.ViteroManager;
+import com.frentix.olat.vitero.manager.VmsNotAvailableException;
+import com.frentix.olat.vitero.model.GroupRole;
+import com.frentix.olat.vitero.model.ViteroBooking;
+
+/**
+ *
+ * Description:<br>
+ *
+ * <P>
+ * Initial Date: 7 oct. 2011 <br>
+ *
+ * @author srosse, stephane.rosse@frentix.com, http://www.frentix.com
+ */
+public class ViteroUserToGroupController extends BasicController {
+
+ private final ViteroBooking booking;
+ private final ViteroManager viteroManager;
+ private final RepositoryManager repositoryManager;
+ private final BaseSecurity securityManager;
+ private CourseGroupManager courseGroupManager;
+ private final BusinessGroup group;
+ private final OLATResourceable ores;
+
+ private final TableController tableCtr;
+ private final VelocityContainer mainVC;
+
+ public ViteroUserToGroupController(UserRequest ureq, WindowControl wControl, BusinessGroup group, OLATResourceable ores, ViteroBooking booking) {
+ super(ureq, wControl);
+
+ this.ores = ores;
+ this.group = group;
+ this.booking = booking;
+ viteroManager = (ViteroManager)CoreSpringFactory.getBean("viteroManager");
+ repositoryManager = RepositoryManager.getInstance();
+ securityManager = BaseSecurityManager.getInstance();
+
+ mainVC = createVelocityContainer("user_admin");
+
+ TableGuiConfiguration tableConfig = new TableGuiConfiguration();
+ tableConfig.setTableEmptyMessage(translate("vc.table.empty"));
+
+ Translator trans = UserManager.getInstance().getPropertyHandlerTranslator(getTranslator());
+ tableCtr = new TableController(tableConfig, ureq, getWindowControl(), trans, true);
+ listenTo(tableCtr);
+
+ tableCtr.addColumnDescriptor(getColumnDescriptor(Col.firstName.ordinal(), UserConstants.FIRSTNAME, ureq.getLocale()));
+ tableCtr.addColumnDescriptor(getColumnDescriptor(Col.lastName.ordinal(), UserConstants.LASTNAME, ureq.getLocale()));
+ tableCtr.addColumnDescriptor(getColumnDescriptor(Col.email.ordinal(), UserConstants.EMAIL, ureq.getLocale()));
+ tableCtr.addColumnDescriptor(new CustomRenderColumnDescriptor("user.role", Col.role.ordinal(),null, ureq.getLocale(),
+ ColumnDescriptor.ALIGNMENT_LEFT, new RoleCellRenderer(getTranslator())));
+ tableCtr.addColumnDescriptor(new SignColumnDescriptor("signin", Col.sign.ordinal(), ureq.getLocale(), getTranslator()));
+
+ tableCtr.addMultiSelectAction("signin", "signin");
+ tableCtr.addMultiSelectAction("signout", "signout");
+ tableCtr.addMultiSelectAction("reload", "reload");
+ tableCtr.setMultiSelect(true);
+
+ loadModel();
+ mainVC.put("userTable", tableCtr.getInitialComponent());
+
+ putInitialPanel(mainVC);
+ }
+
+ private ColumnDescriptor getColumnDescriptor(int pos, String attrName, Locale locale) {
+ List<UserPropertyHandler> userPropertyHandlers = UserManager.getInstance().getAllUserPropertyHandlers();
+ for(UserPropertyHandler handler:userPropertyHandlers) {
+ if(handler.getName().equals(attrName)) {
+ return handler.getColumnDescriptor(pos, null, locale);
+ }
+ }
+ return null;
+ }
+
+ @Override
+ protected void doDispose() {
+ //
+ }
+
+ @Override
+ protected void event(UserRequest ureq, Component source, Event event) {
+ //
+ }
+
+ @Override
+ protected void event(UserRequest ureq, Controller source, Event event) {
+ if(source == tableCtr) {
+ if(event instanceof TableEvent) {
+ TableEvent e = (TableEvent)event;
+ int row = e.getRowId();
+ Identity identity = (Identity)tableCtr.getTableDataModel().getObject(row);
+ if("signin".equals(e.getActionId())) {
+ signIn(ureq, Collections.singletonList(identity));
+ } else if("signout".equals(e.getActionId())) {
+ signOut(ureq, Collections.singletonList(identity));
+ }
+ } else if(event instanceof TableMultiSelectEvent) {
+ TableMultiSelectEvent e = (TableMultiSelectEvent)event;
+ List<Identity> identities = new ArrayList<Identity>();
+ for (int i = e.getSelection().nextSetBit(0); i >= 0; i = e.getSelection().nextSetBit(i + 1)) {
+ Identity identity = (Identity)tableCtr.getTableDataModel().getObject(i);
+ identities.add(identity);
+ }
+ if("signin".equals(e.getAction())) {
+ signIn(ureq, identities);
+ } else if("signout".equals(e.getAction())) {
+ signOut(ureq, identities);
+ } else if("reload".equals(e.getAction())) {
+ loadModel();
+ }
+ }
+
+ }
+ super.event(ureq, source, event);
+ }
+
+ private void signIn(UserRequest ureq, List<Identity> identities) {
+ try {
+ ResourceMembers members = ((UserToGroupDataModel)tableCtr.getTableDataModel()).getMembers();
+
+ for(Identity identity:identities) {
+ boolean upgrade = members.getCoaches().contains(identity) || members.getOwners().contains(identity);
+ GroupRole role = upgrade ? GroupRole.teamleader : null;
+ if(viteroManager.addToRoom(booking, identity, role)) {
+ showInfo("signin.ok");
+ } else {
+ showInfo("signin.nok");
+ break;
+ }
+ }
+
+ loadModel();
+ } catch (VmsNotAvailableException e) {
+ showError(VmsNotAvailableException.I18N_KEY);
+ }
+ }
+
+ private void signOut(UserRequest ureq, List<Identity> identities) {
+ try {
+ for(Identity identity:identities) {
+ if(viteroManager.removeFromRoom(booking, identity)) {
+ showInfo("signout.ok");
+ } else {
+ showInfo("signout.nok");
+ break;
+ }
+ }
+ loadModel();
+ } catch (VmsNotAvailableException e) {
+ showError(VmsNotAvailableException.I18N_KEY);
+ }
+ }
+
+ private void loadModel() {
+ try {
+ List<Identity> identitiesInGroup = viteroManager.getIdentitiesInBooking(booking);
+ ResourceMembers members = getIdentitiesInResource();
+ tableCtr.setTableDataModel(new UserToGroupDataModel(members, identitiesInGroup));
+
+ int numOfFreePlaces = booking.getRoomSize() - identitiesInGroup.size();
+ mainVC.contextPut("freePlaces", new String[]{Integer.toString(numOfFreePlaces)});
+ } catch (VmsNotAvailableException e) {
+ showError(VmsNotAvailableException.I18N_KEY);
+ }
+ }
+
+ private ResourceMembers getIdentitiesInResource() {
+ Set<Identity> owners = new HashSet<Identity>();
+ Set<Identity> coaches = new HashSet<Identity>();
+ Set<Identity> participants = new HashSet<Identity>();
+
+ if(group != null) {
+ owners.addAll(securityManager.getIdentitiesOfSecurityGroup(group.getOwnerGroup()));
+ participants.addAll(securityManager.getIdentitiesOfSecurityGroup(group.getPartipiciantGroup()));
+ } else {
+ RepositoryEntry repoEntry = repositoryManager.lookupRepositoryEntry(ores, false);
+ if ("CourseModule".equals(ores.getResourceableTypeName())) {
+ if(courseGroupManager == null) {
+ ICourse course = CourseFactory.loadCourse(ores);
+ courseGroupManager = course.getCourseEnvironment().getCourseGroupManager();
+ }
+ coaches.addAll(courseGroupManager.getCoachesFromArea(null));
+ coaches.addAll(courseGroupManager.getCoachesFromLearningGroup(null));
+ participants.addAll(courseGroupManager.getParticipantsFromArea(null));
+ participants.addAll(courseGroupManager.getParticipantsFromLearningGroup(null));
+ }
+
+ List<Identity> repoOwners = securityManager.getIdentitiesOfSecurityGroup(repoEntry.getOwnerGroup());
+ owners.addAll(repoOwners);
+ }
+ return new ResourceMembers(owners, coaches, participants);
+ }
+
+ public class ResourceMembers {
+ private final List<Identity> owners = new ArrayList<Identity>();
+ private final List<Identity> coaches = new ArrayList<Identity>();
+ private final List<Identity> participants = new ArrayList<Identity>();
+
+ public ResourceMembers() {
+ //
+ }
+
+ public ResourceMembers(Collection<Identity> owners, Collection<Identity> coaches, Collection<Identity> participants) {
+ this.owners.addAll(owners);
+ this.coaches.addAll(coaches);
+ this.participants.addAll(participants);
+
+ //remove duplicates
+ coaches.removeAll(owners);
+ participants.removeAll(owners);
+ participants.removeAll(coaches);
+ }
+
+ public List<Identity> getOwners() {
+ return owners;
+ }
+
+ public List<Identity> getCoaches() {
+ return coaches;
+ }
+
+ public List<Identity> getParticipants() {
+ return participants;
+ }
+ }
+
+ public class UserToGroupDataModel implements TableDataModel {
+
+ private ResourceMembers members;
+ private List<Identity> identities;
+ private final List<Identity> identitiesInGroup;
+
+ public UserToGroupDataModel(ResourceMembers members, List<Identity> identitiesInGroup) {
+ this.members = members;
+ this.identitiesInGroup = identitiesInGroup;
+
+ identities = new ArrayList<Identity>();
+ identities.addAll(members.getOwners());
+ identities.addAll(members.getCoaches());
+ identities.addAll(members.getParticipants());
+ }
+
+ public ResourceMembers getMembers() {
+ return members;
+ }
+
+ @Override
+ public int getColumnCount() {
+ return 5;
+ }
+
+ @Override
+ public int getRowCount() {
+ return identities == null ? 0 : identities.size();
+ }
+
+ @Override
+ public Object getValueAt(int row, int col) {
+ Identity identity = getObject(row);
+ switch(Col.values()[col]) {
+ case firstName: return identity.getUser().getProperty(UserConstants.FIRSTNAME, null);
+ case lastName: return identity.getUser().getProperty(UserConstants.LASTNAME, null);
+ case email: return identity.getUser().getProperty(UserConstants.EMAIL, null);
+ case role: {
+ if(members == null) return null;
+ if(members.owners.contains(identity)) return "owner";
+ if(members.coaches.contains(identity)) return "coach";
+ return null;
+ }
+ case sign: {
+ if(identitiesInGroup.contains(identity)) {
+ return Sign.signout;
+ }
+ return Sign.signin;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public Identity getObject(int row) {
+ return identities.get(row);
+ }
+
+ @Override
+ public void setObjects(List objects) {
+ this.identities = objects;
+ }
+
+ @Override
+ public Object createCopyWithEmptyList() {
+ return new UserToGroupDataModel(new ResourceMembers(), identitiesInGroup);
+ }
+ }
+
+ public enum Col {
+ firstName,
+ lastName,
+ email,
+ role,
+ sign,
+ }
+}
\ No newline at end of file
diff --git a/src/main/java/com/frentix/olat/vitero/ui/_chelp/ced-vitero-config.html b/src/main/java/com/frentix/olat/vitero/ui/_chelp/ced-vitero-config.html
new file mode 100644
index 0000000000000000000000000000000000000000..84a8e27cc8b1f457ab10c83677cacdbc427f96cd
--- /dev/null
+++ b/src/main/java/com/frentix/olat/vitero/ui/_chelp/ced-vitero-config.html
@@ -0,0 +1,30 @@
+<p>
+ $r.translate("chelp.vitero1")
+ <br />
+ <a href="http://www.vitero.de" target="_blank" class="b_extern">http://www.vitero.de</a>
+</p>
+<p>
+ $r.translate("chelp.vitero2")
+ <br />
+ $r.contextHelpRelativeLink("module")
+</p>
+<p>
+ $r.translate("chelp.vitero3")
+</p>
+<p>
+ $r.translate("chelp.vitero4")
+</p>
+<p>
+ $r.translate("chelp.vitero5")
+</p>
+<p>
+ $r.translate("chelp.vitero6")
+</p>
+<p>
+ $r.translate("chelp.vitero7")
+</p>
+<p class="b_note">
+ $r.translate("chelp.vitero8")
+</p>
+
+
diff --git a/src/main/java/com/frentix/olat/vitero/ui/_chelp/module.html b/src/main/java/com/frentix/olat/vitero/ui/_chelp/module.html
new file mode 100644
index 0000000000000000000000000000000000000000..360d9eaae30d2b604555519d52a723e2b3b07fc4
--- /dev/null
+++ b/src/main/java/com/frentix/olat/vitero/ui/_chelp/module.html
@@ -0,0 +1,22 @@
+<p>
+ $r.translate("chelp.vitero1")
+ <br />
+ <a href="http://www.vitero.de" target="_blank" class="b_extern">http://www.vitero.de</a>
+</p>
+<p>
+ $r.translate("chelp.module1")
+</p>
+<p>
+ $r.translate("chelp.module2")
+</p>
+<p>
+ $r.translate("chelp.module3")
+</p>
+<p>
+ $r.translate("chelp.module4")
+</p>
+<p class="b_note">
+ $r.translate("chelp.module5")
+</p>
+
+
diff --git a/src/main/java/com/frentix/olat/vitero/ui/_content/adminconfig.html b/src/main/java/com/frentix/olat/vitero/ui/_content/adminconfig.html
new file mode 100644
index 0000000000000000000000000000000000000000..0cc61f52eae2e4802a6de8ce0c663a34b35502df
--- /dev/null
+++ b/src/main/java/com/frentix/olat/vitero/ui/_content/adminconfig.html
@@ -0,0 +1,7 @@
+<fieldset>
+ <legend>$r.translate("vitero.title")</legend>
+ $r.contextHelpWithWrapper("com.frentix.olat.vitero.ui","module.html","help.hover.vitero")
+ <p>$r.translate("vitero.intro")</p>
+
+ $r.render("flc_module")
+</fieldset>
\ No newline at end of file
diff --git a/src/main/java/com/frentix/olat/vitero/ui/_content/edit.html b/src/main/java/com/frentix/olat/vitero/ui/_content/edit.html
new file mode 100644
index 0000000000000000000000000000000000000000..68003bdee9139eb07f5d697b0caef9fc894d9cf6
--- /dev/null
+++ b/src/main/java/com/frentix/olat/vitero/ui/_content/edit.html
@@ -0,0 +1,29 @@
+<fieldset>
+ <legend>$r.translate("booking.admin.title")</legend>
+ $r.contextHelpWithWrapper("com.frentix.olat.vitero.ui","ced-vitero-config.html","help.hover.vitero")
+ <table>
+ <tr>
+ <td>$r.translate("booking.begin")</td>
+ <td>$r.translate("booking.end")</td>
+ <td colspan="3"></td>
+ </tr>
+
+ #foreach($bookingDisplay in $bookingDisplays)
+ <tr>
+ <td>$r.formatDateAndTime($bookingDisplay.begin)</td>
+ <td>$r.formatDateAndTime($bookingDisplay.end)</td>
+ <td>
+ $r.render($bookingDisplay.editButton.component.componentName)
+ </td>
+ <td>
+ $r.render($bookingDisplay.usersButton.component.componentName)
+ </td>
+ <td>
+ $r.render($bookingDisplay.deleteButton.component.componentName)
+ </td>
+ </tr>
+ #end
+ </table>
+
+ $r.render("buttons-cont")
+</fieldset>
\ No newline at end of file
diff --git a/src/main/java/com/frentix/olat/vitero/ui/_content/run.html b/src/main/java/com/frentix/olat/vitero/ui/_content/run.html
new file mode 100644
index 0000000000000000000000000000000000000000..c354ca3e2ddac7ac773fcaf368ee8b8cf43a0771
--- /dev/null
+++ b/src/main/java/com/frentix/olat/vitero/ui/_content/run.html
@@ -0,0 +1 @@
+$r.render("bookings")
\ No newline at end of file
diff --git a/src/main/java/com/frentix/olat/vitero/ui/_content/run_admin.html b/src/main/java/com/frentix/olat/vitero/ui/_content/run_admin.html
new file mode 100644
index 0000000000000000000000000000000000000000..3d776f938257908fbbff3a476ab4ca371c009513
--- /dev/null
+++ b/src/main/java/com/frentix/olat/vitero/ui/_content/run_admin.html
@@ -0,0 +1,7 @@
+<div class="b_clearfix">
+ $r.render("segments") <br/>
+
+ #if($r.available("segmentCmp"))
+ $r.render("segmentCmp")
+ #end
+</div>
\ No newline at end of file
diff --git a/src/main/java/com/frentix/olat/vitero/ui/_content/user_admin.html b/src/main/java/com/frentix/olat/vitero/ui/_content/user_admin.html
new file mode 100644
index 0000000000000000000000000000000000000000..719235ccf6c397566d349a0dd0b738c2a3bbd224
--- /dev/null
+++ b/src/main/java/com/frentix/olat/vitero/ui/_content/user_admin.html
@@ -0,0 +1,6 @@
+<fieldset>
+ <legend>$r.translate("users.title")</legend>
+ <p>$r.translate("users.intro")</p>
+ $r.translate('available.places', $freePlaces)<br/>
+ $r.render("userTable")
+</fieldset>
\ No newline at end of file
diff --git a/src/main/java/com/frentix/olat/vitero/ui/_content/vitero_admin.html b/src/main/java/com/frentix/olat/vitero/ui/_content/vitero_admin.html
new file mode 100644
index 0000000000000000000000000000000000000000..3d776f938257908fbbff3a476ab4ca371c009513
--- /dev/null
+++ b/src/main/java/com/frentix/olat/vitero/ui/_content/vitero_admin.html
@@ -0,0 +1,7 @@
+<div class="b_clearfix">
+ $r.render("segments") <br/>
+
+ #if($r.available("segmentCmp"))
+ $r.render("segmentCmp")
+ #end
+</div>
\ No newline at end of file
diff --git a/src/main/java/com/frentix/olat/vitero/ui/_content/vms_user_admin.html b/src/main/java/com/frentix/olat/vitero/ui/_content/vms_user_admin.html
new file mode 100644
index 0000000000000000000000000000000000000000..99bd0edff71714c53db9ed854762079809d34d4a
--- /dev/null
+++ b/src/main/java/com/frentix/olat/vitero/ui/_content/vms_user_admin.html
@@ -0,0 +1 @@
+$r.render("userTable")
\ No newline at end of file
diff --git a/src/main/java/com/frentix/olat/vitero/ui/_i18n/LocalStrings_de.properties b/src/main/java/com/frentix/olat/vitero/ui/_i18n/LocalStrings_de.properties
new file mode 100644
index 0000000000000000000000000000000000000000..fbfb304137ca2e47068e17543bd2e20e85762975
--- /dev/null
+++ b/src/main/java/com/frentix/olat/vitero/ui/_i18n/LocalStrings_de.properties
@@ -0,0 +1,76 @@
+admin.menu.title=vitero Teamraum
+admin.menu.title.alt=Konfiguration eines vitero virtual team room Servers
+vitero.title=vitero Teamraum Konfiguration
+vitero.intro=Verfügen Sie über einen vitero virtual team room Server der Firma vitero GmbH, so können Sie das vitero Modul hier einschalten und die vitero Zugangsdaten eingeben. Nach erfolgreicher Konfiguration steht den Kursautoren der Kursbaustein "vitero Teamraum" zur Verfügung. Weitere Informationen über die Konfiguration und Funktionen finden Sie in der Hilfe rechts und auf der Webseite der Firma vitero GmbH.
+vitero.module.enabled=Modul "vitero Teamraum"
+vitero.account=Konfiguration
+enabled=eingeschaltet
+signin=Eintragen
+signin.ok=Die Teilnahme für diesen Termin wurde erfolgreich eingetragen
+signin.nok=Die Teilnahme für diesen Termin konnte nicht eingetragen werden. Prüfen Sie ob für diesen Termin noch freie Plätze vorhanden sind.
+signout=Austragen
+signout.ok=Die Teilnahme an diesem Termin wurde erfolgreich aufgehoben.
+signout.nok=Die Teilnahme an diesem Termin konnte aus unbekannten Gründen nicht aufgehoben werden. Bitte versuchen Sie es später noch einmal oder Kontaktieren Sie Ihren Betreuer.
+users=Teilnehmerliste
+users.title=Teilnehmerliste
+users.intro=Wählen Sie die Teilnehmer für diesen vitero Termin aus der Liste der Kursbesitzer, -betreuer und -teilnehmer aus.
+user.role=vitero Rolle
+users.empty=In diesem Termin sind keine Benutzer eingetragen.
+available.places=Für diesen Termin sind noch {0} Plätze frei.
+role.teamLeader=Teamleader
+roomsOverview=Auslastung Teamräume
+reload=Aktualisieren
+new=Termin anlegen
+new.booking.warning=Die Angabe können nicht mehr verändert werden!
+delete.ok=Der Termin wurde erfolgreich gelöscht.
+delete.nok=Der Termin konnte aus unbekannten Gründen nicht gelöscht werden. Bitte versuchen Sie es später noch einmal oder kontaktieren Sie den Administrator.
+delete.confirm=Wollen Sie diesen Termin wirklich löschen? Der Termin wird von dem vitero System entfernt und kann nicht wiederhergestellt werden.
+booking.id=Terminidentifikator
+booking.infos=Detailinformationen
+booking.begin=Begin
+booking.beginBuffer=Begin Buffer (Minuten)
+booking.end=Ende
+booking.endBuffer=Ende Buffer (Minuten)
+booking.resource=Ressourcenname
+booking.title=Termine
+booking.admin.title=Terminverwaltung
+booking.autoSignIn=Einschreibung durch Benutzer
+booking.roomSize=Raumgrösse
+booking.raw=Termin
+booking.raw.title=Detailinformationen Termin
+group.id=Gruppenidentifikator
+group.name=Gruppenname
+group.numOfParticipants=Teilnehmerzahl
+table.empty=Derzeit sind keine Meetings geplant.
+check=Serververbindung testen
+check.ok=Der Verbindungstest war erfolgreich, Sie können vitero nun benutzen.
+check.nok=Der Verbindungstest war nicht erfolgreich. Bitte prüfen Sie die Server URL, der Benutzername und das Passwort des Systembenutzers!
+option.olatTimeZone=Zeitzone OLAT Server
+option.baseurl=URL vitero Server
+option.adminlogin=Web Service Benutzername
+option.adminpassword=Web Service Passwort
+option.customerId=Kundenidentifikator
+error.bookingInPast=Der Termin kann sich nicht in der Vergangenheit befinden.
+error.bookingDatesInverted=Das Datum für das Ende des Termins darf nicht vor dem Begin Datum sein.
+error.vmsNotAvailable=vitero Server ist nicht verfügbar
+error.url.invalid=Die angegebene vitero Server URL ist nicht gültig
+error.customer.invalid=Der angegebene Kundenidentifikator ist nicht gültig
+help.hover.vitero=Hilfe zu "$\:chelp.module.title"
+chelp.ced-vitero-config.title=$\:help.hover.vitero
+chelp.vitero1=Mit dem Kursbaustein "vitero Teamraum" können Sie vitero Termine mit Videokonferenz, Dokument. und Desktopsharing und vielem mehr. direkt in Ihren OLAT Kursen einbinden. Mehr zu den Funktionen des vitero virtual team room Systems erfahren Sie auf der Homepage von vitero GmbH:
+chelp.vitero2=Um die vitero Anbindung nutzen zu können müssen Sie über eine vitero Lizenz verfügen und in der Administrationsumgebung die Zugangsdaten eintragen:
+chelp.vitero3=Im Kurseditor wählen sie den vitero Kursbaustein und binden diesen in Ihre Kursstruktur ein und publizieren diesen.
+chelp.vitero4=Im Kurseditor oder in der publizierten Ansicht können Sie nun vitero Termine erfassen. Wählen Sie dazu die Schaltfläche "$:new". Zuvor können Sie mit der Schaltfläche "$:roomsOverview" die aktuelle Auslastung der verfügbaren Teamräume ansehen um einen freien Termin zu finden.
+chelp.vitero5=Geben Sie nun das Start- und das Enddatum des Termins ein und wählen Sie die Grösse des Raums. Mit "$:booking.beginBuffer" können sie festlegen wieviele Minuten vor dem Startdatum der Raum betreten werden kann. Mit "$:booking.endBuffer" legen Sie fest, wieviele Minuten nach Terminende der Termin definitiv geschlossen wird.
+chelp.vitero6=Mit der Option "$:booking.autoSignIn" ermöglichen Sie es allen Benutzern welche Zugriff auf den Kursbaustein haben sich selbständig in diesen Termin einzutragen. Dies ist so lange möglich wie es noch freie Plätze hat. Ist diese Option ausgeschaltet, dann können nur Kursbesitzer Benutzer in die Termine eintragen.
+chelp.vitero7=Für Benutzer sind Termine nur dann sichtbar wenn sie in diesem Termin eingetragen sind oder der Termin für die freie Einschreibung konfiguriert werden.
+chelp.vitero8=Ist ein Termin angelegt, so kann er nicht mehr geändert werden, die Daten sind nicht mehr änderbar.
+chelp.module.title=vitero: Konfiguration
+chelp.module1=Um die vitero Anbindung nutzen zu können müssen Sie über eine vitero Lizenz verfügen und in der Administrationsumgebung die Zugangsdaten für das Web Service API eintragen.
+chelp.module2=Unter "$:option.olatTimeZone" können Sie die Zeitzone Ihres OLAT Systems einstellen. Dies ist notwendig um die zeiten der Termine mit dem vitero System abzugleichen.
+chelp.module3=Die folgenden Angaben erhalten Sie von Ihrem vitero oder OLAT Administrator: "$:option.baseurl", "$:option.adminlogin", "$:option.adminpassword" und "$:option.customerId".
+chelp.module4=Nach erfolgter Eingabe wählen Sie die Schaltfläche "$:check" um die Konfiguration und die Verbindung zum vitero Server zu prüfen. Danach können Sie die Konfiguration speichern und vitero in Ihren in Ihren Kursen nutzen.
+chelp.module5=Bitte beachten Sie, dass für die OLAT Anbindung auf dem vitero Server automatisch Benutzerkonten eingerichtet werden. Allfällige bereits bestehende Benutzerkonten und Termine werden nicht berücksichtigt.
+
+
+
diff --git a/src/main/java/com/frentix/olat/vitero/ui/_i18n/LocalStrings_en.properties b/src/main/java/com/frentix/olat/vitero/ui/_i18n/LocalStrings_en.properties
new file mode 100644
index 0000000000000000000000000000000000000000..b43d5177bc1eafc119c90ef4d9899e009a3fcc54
--- /dev/null
+++ b/src/main/java/com/frentix/olat/vitero/ui/_i18n/LocalStrings_en.properties
@@ -0,0 +1,76 @@
+admin.menu.title=vitero team room
+admin.menu.title.alt=Configuration of a vitero virtual team room servers
+vitero.title=vitero team room configuration
+vitero.intro=If you have a vitero virtual team room server from vitero GmbH you can enable the vitero module here and enter the vitero access informations. You can then use the "vitero team room" course element in your OLAT courses to create vitero meetings. More information about vitero and the configuration option can be found in the help at the right side and the vitero GmbH website.
+vitero.module.enabled=Module "vitero team room"
+vitero.account=Configuration
+enabled=enabled
+signin=Sign in
+signin.ok=The sign in for this meeting was successful.
+signin.nok=The sign in for this meeting was not successful. Please check if there are still free seats availabe.
+signout=Sign out
+signout.ok=The sign out for this meeting was successful.
+signout.nok=The sign out for this meeting was not successful for unknown reasons. Please try it again later or contact your supervisor. ntaktieren Sie Ihren Betreuer.
+users=Participant list
+users.title=Participant list
+users.intro=Sign in users from the list of the course owners, coaches or participants to this vitero meeting.
+user.role=vitero role
+users.empty=There are no users in this meeting.
+available.places={0} seats are available for this meeting
+role.teamLeader=Team leader
+roomsOverview=Team room utilisation
+reload=reload
+new=Create meeting
+new.booking.warning=The meeting settings are final and can not be modified later!
+delete.ok=The meeting has successfuly been deleted
+delete.nok=The meeting could not be deleted for unknown reasons. Please try again later or contact the administrator.
+delete.confirm=Do you really want to delete the meeting? The meeting will also be removed on the vitero server and can not be restored.
+booking.id=Meeting identifyer
+booking.infos=Detail information
+booking.begin=Begin
+booking.beginBuffer=Begin buffer (minutes)
+booking.end=Ende
+booking.endBuffer=Ende buffer (minutes)
+booking.resource=Ressource name
+booking.title=Meetings
+booking.admin.title=Meetings administration
+booking.autoSignIn=User can sign in themselfs
+booking.roomSize=Room size
+booking.raw=Meeting
+booking.raw.title=Meeting detail information
+group.id=Groupe identifyer
+group.name=Group name
+group.numOfParticipants=Booked seats
+table.empty=There are no scheduled meetings available at this point
+check=Test server connection
+check.ok=The server connection and configuration test was successful. You can now use vitero in OLAT.
+check.nok=The server connection and configuration test was not successful. Please check the server URL, the system user name and password you configured.
+option.olatTimeZone=Time Zone OLAT server
+option.baseurl=URL vitero server
+option.adminlogin=Web service user name
+option.adminpassword=Web service password
+option.customerId=Client identifyer
+error.bookingInPast=The meeting date can not be in the past.
+error.bookingDatesInverted=The end date of the meeting must not be before the begin date.
+error.vmsNotAvailable=The vitero server is not available
+error.url.invalid=The vitero server URL is not valid
+error.customer.invalid=The vitero client identifyer is not valid
+help.hover.vitero=Help for "$\:chelp.module.title"
+chelp.ced-vitero-config.title=$\:help.hover.vitero
+chelp.vitero1=Using the course element "vitero team room" you can embedd vitero meetings including video conferencing, desktop and document sharing and more. More information about the vitero virtual team room system can be found on the vitero GmbH website:
+chelp.vitero2=To be able to use the vitero system you need to have a vitero license and add the access information in the administration area:
+chelp.vitero3=Choose the vitero course element in the course editor, add it to your course structure and publish the course.
+chelp.vitero4=After publishing you can create vitero meetings either from within the course editor or also from the published view. Use the button "$:new" to add a meeting. Using the button "$:roomsOverview" you can preview the current booking of the team rooms to find a free spot.
+chelp.vitero5=Add the start and end date for your meeting and select the room size. With the option "$:booking.beginBuffer" you can specify how many minutes in advance the meeting room can be entered by the participants, with "$:booking.endBuffer" you define how many minutes after the meeting finished the room is still available.
+chelp.vitero6=Using the option "$:booking.autoSignIn" allows every user with access to the course element to sign in to this meeting themselfes as long as there are still available seats. If you turn off this option, only course administrators can sign in users to a meeting.
+chelp.vitero7=Users can see meetings when they are signed into a meeting or when a meeting is configured with the "$:booking.autoSignIn" option.
+chelp.vitero8=Note that the meeting parameters can not be changed after the meeting has been created.
+chelp.module.title=vitero: Configuration
+chelp.module1=To be able to use the vitero system you need to have a vitero license and add the access information for the vitero web service API in the administration area.
+chelp.module2=With "$:option.olatTimeZone" you can set the time zone of your OLAT system. This is important to synchronize the meeting schedule with the vitero system.
+chelp.module3=The following information have to be optained by your vitero or OLAT administrator: "$:option.baseurl", "$:option.adminlogin", "$:option.adminpassword" and "$:option.customerId".
+chelp.module4=When you have entered all the configuration options you should use the button "$:check" to test the configuration and the connection to the vitero server. When successful, you can save the form and use vitero in your courses.
+chelp.module5=Please note that OLAT will create users on the vitero server automatically and independently of existing vitero users. Previously created user accounts or meetings will not be used or modified by OLAT.
+
+
+
diff --git a/src/main/java/de/bps/course/nodes/VCCourseNode.java b/src/main/java/de/bps/course/nodes/VCCourseNode.java
new file mode 100644
index 0000000000000000000000000000000000000000..c4beed3ed89e7297029321eed91511827e49568b
--- /dev/null
+++ b/src/main/java/de/bps/course/nodes/VCCourseNode.java
@@ -0,0 +1,201 @@
+// <OLATCE-103>
+/**
+ *
+ * BPS Bildungsportal Sachsen GmbH<br>
+ * Bahnhofstrasse 6<br>
+ * 09111 Chemnitz<br>
+ * Germany<br>
+ *
+ * Copyright (c) 2005-2010 by BPS Bildungsportal Sachsen GmbH<br>
+ * http://www.bps-system.de<br>
+ *
+ * All rights reserved.
+ */
+package de.bps.course.nodes;
+
+import java.util.List;
+
+import org.olat.core.gui.UserRequest;
+import org.olat.core.gui.control.Controller;
+import org.olat.core.gui.control.WindowControl;
+import org.olat.core.gui.control.generic.tabbable.TabbableController;
+import org.olat.core.id.Roles;
+import org.olat.core.util.Util;
+import org.olat.core.util.ValidationStatus;
+import org.olat.course.CourseFactory;
+import org.olat.course.ICourse;
+import org.olat.course.condition.ConditionEditController;
+import org.olat.course.editor.CourseEditorEnv;
+import org.olat.course.editor.NodeEditController;
+import org.olat.course.editor.StatusDescription;
+import org.olat.course.nodes.AbstractAccessableCourseNode;
+import org.olat.course.nodes.CourseNode;
+import org.olat.course.nodes.StatusDescriptionHelper;
+import org.olat.course.nodes.TitledWrapperHelper;
+import org.olat.course.run.navigation.NodeRunConstructionResult;
+import org.olat.course.run.userview.NodeEvaluation;
+import org.olat.course.run.userview.UserCourseEnvironment;
+import org.olat.repository.RepositoryEntry;
+import org.olat.repository.RepositoryManager;
+
+import de.bps.course.nodes.vc.VCConfiguration;
+import de.bps.course.nodes.vc.VCEditController;
+import de.bps.course.nodes.vc.VCRunController;
+import de.bps.course.nodes.vc.provider.VCProvider;
+import de.bps.course.nodes.vc.provider.VCProviderFactory;
+
+/**
+ * Description:<br>
+ * date list course node.
+ *
+ * <P>
+ * Initial Date: 19.07.2010 <br>
+ *
+ * @author Jens Lindner (jlindne4@hs-mittweida.de)
+ * @author skoeber
+ */
+public class VCCourseNode extends AbstractAccessableCourseNode {
+
+ private static final String TYPE = "vc";
+
+ // configuration
+ public static final String CONF_VC_CONFIGURATION = "vc_configuration";
+ public final static String CONF_PROVIDER_ID = "vc_provider_id";
+
+ public VCCourseNode() {
+ super(TYPE);
+ }
+
+ /**
+ * To support different virtual classroom implementations it's necessary to
+ * check whether the persisted configuration suits to the actual virtual
+ * classroom implementation or not. If not a new one will be created and
+ * persisted.
+ *
+ * @param provider
+ * @return the persisted configuration or a fresh one
+ */
+ private VCConfiguration handleConfig(final VCProvider provider) {
+ getModuleConfiguration().setStringValue(CONF_PROVIDER_ID, provider.getProviderId());
+ VCConfiguration config = (VCConfiguration) getModuleConfiguration().get(CONF_VC_CONFIGURATION);
+ if (config == null || config.getProviderId() == null || !config.getProviderId().equals(provider.getProviderId())) {
+ config = provider.createNewConfiguration();
+ }
+ getModuleConfiguration().set(CONF_VC_CONFIGURATION, config);
+ return config;
+ }
+
+ @Override
+ public void updateModuleConfigDefaults(boolean isNewNode) {
+ // no update to default config necessary
+ }
+
+ @Override
+ public TabbableController createEditController(UserRequest ureq, WindowControl wControl, ICourse course,
+ UserCourseEnvironment userCourseEnv) {
+ updateModuleConfigDefaults(false);
+ CourseNode chosenNode = course.getEditorTreeModel().getCourseNode(userCourseEnv.getCourseEditorEnv().getCurrentCourseNodeId());
+ // load and check configuration
+ String providerId = getModuleConfiguration().getStringValue(CONF_PROVIDER_ID);
+ VCProvider provider = providerId == null ? VCProviderFactory.createDefaultProvider() : VCProviderFactory.createProvider(providerId);
+ VCConfiguration config = handleConfig(provider);
+ // create room if configured to do it immediately
+ if(config.isCreateMeetingImmediately()) {
+ Long key = course.getResourceableId();
+ // here, the config is empty in any case, thus there are no start and end dates
+ provider.createClassroom(key + "_" + this.getIdent(), this.getShortName(), this.getLongTitle(), null, null, config);
+ }
+ // create edit controller
+ VCEditController childTabCntrllr = new VCEditController(ureq, wControl, this, course, userCourseEnv, provider, config);
+ NodeEditController nodeEditCtr = new NodeEditController(ureq, wControl, course.getEditorTreeModel(), course, chosenNode, course.getCourseEnvironment()
+ .getCourseGroupManager(), userCourseEnv, childTabCntrllr);
+ nodeEditCtr.addControllerListener(childTabCntrllr);
+ return nodeEditCtr;
+ }
+
+ @Override
+ public NodeRunConstructionResult createNodeRunConstructionResult(UserRequest ureq, WindowControl wControl,
+ UserCourseEnvironment userCourseEnv, NodeEvaluation ne, String nodecmd) {
+ updateModuleConfigDefaults(false);
+ // check if user is moderator of the virtual classroom
+ Roles roles = ureq.getUserSession().getRoles();
+ boolean moderator = roles.isOLATAdmin();
+ Long key = userCourseEnv.getCourseEnvironment().getCourseResourceableId();
+ if (!moderator) {
+ if(roles.isInstitutionalResourceManager() | roles.isAuthor()) {
+ RepositoryManager rm = RepositoryManager.getInstance();
+ ICourse course = CourseFactory.loadCourse(key);
+ RepositoryEntry re = rm.lookupRepositoryEntry(course, false);
+ if (re != null) {
+ moderator = rm.isOwnerOfRepositoryEntry(ureq.getIdentity(), re);
+ if(!moderator) {
+ moderator = rm.isInstitutionalRessourceManagerFor(re, ureq.getIdentity());
+ }
+ }
+ }
+ }
+ // load configuration
+ final String providerId = getModuleConfiguration().getStringValue(CONF_PROVIDER_ID);
+ VCProvider provider = providerId == null ? VCProviderFactory.createDefaultProvider() : VCProviderFactory.createProvider(providerId);
+ VCConfiguration config = handleConfig(provider);
+ // create run controller
+ Controller runCtr = new VCRunController(ureq, wControl, key + "_" + this.getIdent(), this.getShortName(), this.getLongTitle(), config, provider, moderator);
+ Controller controller = TitledWrapperHelper.getWrapper(ureq, wControl, runCtr, this, "o_vc_icon");
+ return new NodeRunConstructionResult(controller);
+ }
+
+ @Override
+ public Controller createPeekViewRunController(UserRequest ureq, WindowControl wControl, UserCourseEnvironment userCourseEnv,
+ NodeEvaluation ne) {
+ return null;
+ }
+
+ @Override
+ public StatusDescription[] isConfigValid(CourseEditorEnv cev) {
+ String translatorStr = Util.getPackageName(ConditionEditController.class);
+ List<StatusDescription> statusDescs = isConfigValidWithTranslator(cev, translatorStr, getConditionExpressions());
+ return StatusDescriptionHelper.sort(statusDescs);
+ }
+
+ public RepositoryEntry getReferencedRepositoryEntry() {
+ return null;
+ }
+
+ public StatusDescription isConfigValid() {
+ if (oneClickStatusCache != null) { return oneClickStatusCache[0]; }
+ StatusDescription status = StatusDescription.NOERROR;
+
+ // load configuration
+ final String providerId = getModuleConfiguration().getStringValue(CONF_PROVIDER_ID);
+ VCProvider provider = providerId == null ? VCProviderFactory.createDefaultProvider() : VCProviderFactory.createProvider(providerId);
+ VCConfiguration config = handleConfig(provider);
+ boolean invalid = !config.isConfigValid();
+ if (invalid) {
+ String[] params = new String[] { this.getShortTitle() };
+ String shortKey = "error.config.short";
+ String longKey = "error.config.long";
+ String translationPackage = VCEditController.class.getPackage().getName();
+ status = new StatusDescription(ValidationStatus.ERROR, shortKey, longKey, params, translationPackage);
+ status.setDescriptionForUnit(getIdent());
+ status.setActivateableViewIdentifier(VCEditController.PANE_TAB_VCCONFIG);
+ }
+
+ return status;
+ }
+
+ public boolean needsReferenceToARepositoryEntry() {
+ return false;
+ }
+
+ @Override
+ public void cleanupOnDelete(ICourse course) {
+ // load configuration
+ final String providerId = getModuleConfiguration().getStringValue(CONF_PROVIDER_ID);
+ VCProvider provider = providerId == null ? VCProviderFactory.createDefaultProvider() : VCProviderFactory.createProvider(providerId);
+ VCConfiguration config = handleConfig(provider);
+ // remove meeting
+ provider.removeClassroom(course.getResourceableId() + "_" + this.getIdent(), config);
+ }
+
+}
+// </OLATCE-103>
\ No newline at end of file
diff --git a/src/main/java/de/bps/course/nodes/vc/DefaultVCConfiguration.java b/src/main/java/de/bps/course/nodes/vc/DefaultVCConfiguration.java
new file mode 100644
index 0000000000000000000000000000000000000000..4d3a5af58878b1cc9c19e14b50f7db2ed124c0e0
--- /dev/null
+++ b/src/main/java/de/bps/course/nodes/vc/DefaultVCConfiguration.java
@@ -0,0 +1,89 @@
+//<OLATCE-103>
+/**
+ *
+ * BPS Bildungsportal Sachsen GmbH<br>
+ * Bahnhofstrasse 6<br>
+ * 09111 Chemnitz<br>
+ * Germany<br>
+ *
+ * Copyright (c) 2005-2011 by BPS Bildungsportal Sachsen GmbH<br>
+ * http://www.bps-system.de<br>
+ *
+ * All rights reserved.
+ */
+package de.bps.course.nodes.vc;
+
+import java.io.Serializable;
+import java.util.List;
+
+
+/**
+ *
+ * Description:<br>
+ * Standard configuration object, each provider implementation must override this class
+ * and extend it with it's specific configuration values.
+ *
+ * <P>
+ * Initial Date: 18.01.2011 <br>
+ * @author skoeber
+ */
+public abstract class DefaultVCConfiguration implements VCConfiguration, Serializable {
+
+ public static String DEFAULT_TEMPLATE = "default";
+
+ private String providerId;
+ private String templateKey;
+ private List<MeetingDate> meetingDatas;
+ private boolean useMeetingDates;
+ private boolean createMeetingImmediately;
+
+ @Override
+ public String getProviderId() {
+ return providerId;
+ }
+
+ public void setProviderId(String providerId) {
+ this.providerId = providerId;
+ }
+
+ @Override
+ public String getTemplateKey() {
+ return templateKey;
+ }
+
+ public void setTemplateKey(String templateKey) {
+ this.templateKey = templateKey;
+ }
+
+ @Override
+ public boolean isUseMeetingDates() {
+ return useMeetingDates;
+ }
+
+ public void setUseMeetingDates(boolean useMeetingDates) {
+ this.useMeetingDates = useMeetingDates;
+ }
+
+ @Override
+ public List<MeetingDate> getMeetingDates() {
+ return meetingDatas;
+ }
+
+ public void setMeetingDatas(List<MeetingDate> meetingDatas) {
+ this.meetingDatas = meetingDatas;
+ }
+
+ public void setCreateMeetingImmediately(boolean createMeetingImmediately) {
+ this.createMeetingImmediately = createMeetingImmediately;
+ }
+
+ @Override
+ public boolean isCreateMeetingImmediately() {
+ return createMeetingImmediately;
+ }
+
+ @Override
+ public abstract boolean isConfigValid();
+
+}
+//</OLATCE-103>
\ No newline at end of file
diff --git a/src/main/java/de/bps/course/nodes/vc/MeetingDate.java b/src/main/java/de/bps/course/nodes/vc/MeetingDate.java
new file mode 100644
index 0000000000000000000000000000000000000000..7e6bce2f99fe05bd6e9cda4648f0b6f0f698719b
--- /dev/null
+++ b/src/main/java/de/bps/course/nodes/vc/MeetingDate.java
@@ -0,0 +1,77 @@
+//<OLATCE-103>
+/**
+ *
+ * BPS Bildungsportal Sachsen GmbH<br>
+ * Bahnhofstrasse 6<br>
+ * 09111 Chemnitz<br>
+ * Germany<br>
+ *
+ * Copyright (c) 2005-2010 by BPS Bildungsportal Sachsen GmbH<br>
+ * http://www.bps-system.de<br>
+ *
+ * All rights reserved.
+ */
+package de.bps.course.nodes.vc;
+
+import java.io.Serializable;
+import java.util.Date;
+
+/**
+ * Description:<br>
+ * Virtual Classroom appointment model to be used in course module configuration.
+ * Initial Date: 30.08.2010 <br>
+ *
+ * @author Jens Lindner (jlindne4@hs-mittweida.de)
+ * @author skoeber
+ */
+public class MeetingDate implements Serializable {
+
+ private String title;
+ private String description;
+ private Date start;
+ private Date end;
+
+ public MeetingDate() {
+ // nothing to do
+ }
+
+ public MeetingDate(final String title, final String description, Date start, Date end) {
+ this.title = title;
+ this.description = description;
+ this.start= start;
+ this.end = end;
+ }
+
+ public final String getTitle() {
+ return title;
+ }
+
+ public final void setTitle(final String title) {
+ this.title = title;
+ }
+
+ public final String getDescription() {
+ return description;
+ }
+
+ public final void setDescription(final String description) {
+ this.description = description;
+ }
+
+ public Date getBegin() {
+ return start;
+ }
+
+ public void setBegin(Date start) {
+ this.start = start;
+ }
+
+ public Date getEnd() {
+ return end;
+ }
+
+ public void setEnd(Date end) {
+ this.end = end;
+ }
+}
+//</OLATCE-103>
\ No newline at end of file
diff --git a/src/main/java/de/bps/course/nodes/vc/VCConfiguration.java b/src/main/java/de/bps/course/nodes/vc/VCConfiguration.java
new file mode 100644
index 0000000000000000000000000000000000000000..3953e8c94741973b7b2cc51627e59608283b7364
--- /dev/null
+++ b/src/main/java/de/bps/course/nodes/vc/VCConfiguration.java
@@ -0,0 +1,41 @@
+//<OLATCE-103>
+/**
+ *
+ * BPS Bildungsportal Sachsen GmbH<br>
+ * Bahnhofstrasse 6<br>
+ * 09111 Chemnitz<br>
+ * Germany<br>
+ *
+ * Copyright (c) 2005-2010 by BPS Bildungsportal Sachsen GmbH<br>
+ * http://www.bps-system.de<br>
+ *
+ * All rights reserved.
+ */
+package de.bps.course.nodes.vc;
+
+import java.io.Serializable;
+import java.util.List;
+
+
+/**
+ *
+ * Description:<br>
+ * Each virtual classroom implementation must persist it's configuration
+ * by using this interface. The course node is able to differentiate for
+ * which implementation the stored configuration is intended (necessary to
+ * support multiple virtual classroom implementations in one OLAT instance).
+ *
+ * <P>
+ * Initial Date: 20.12.2010 <br>
+ * @author skoeber
+ */
+public interface VCConfiguration extends Serializable {
+
+ public String getProviderId();
+ public String getTemplateKey();
+ public boolean isUseMeetingDates();
+ public List<MeetingDate> getMeetingDates();
+ public boolean isCreateMeetingImmediately();
+ public boolean isConfigValid();
+}
+//</OLATCE-103>
\ No newline at end of file
diff --git a/src/main/java/de/bps/course/nodes/vc/VCCourseNodeConfiguration.java b/src/main/java/de/bps/course/nodes/vc/VCCourseNodeConfiguration.java
new file mode 100644
index 0000000000000000000000000000000000000000..e37f9ab08ce1b346f39bf7a50cc1ff25c45b52ce
--- /dev/null
+++ b/src/main/java/de/bps/course/nodes/vc/VCCourseNodeConfiguration.java
@@ -0,0 +1,88 @@
+//<OLATCE-103>
+/**
+ *
+ * BPS Bildungsportal Sachsen GmbH<br>
+ * Bahnhofstrasse 6<br>
+ * 09111 Chemnitz<br>
+ * Germany<br>
+ *
+ * Copyright (c) 2005-2010 by BPS Bildungsportal Sachsen GmbH<br>
+ * http://www.bps-system.de<br>
+ *
+ * All rights reserved.
+ */
+package de.bps.course.nodes.vc;
+
+import java.util.List;
+import java.util.Locale;
+
+import org.olat.core.extensions.ExtensionResource;
+import org.olat.core.gui.translator.Translator;
+import org.olat.core.util.Util;
+import org.olat.course.nodes.AbstractCourseNodeConfiguration;
+import org.olat.course.nodes.CourseNode;
+import org.olat.course.nodes.CourseNodeConfiguration;
+
+import de.bps.course.nodes.VCCourseNode;
+
+/**
+ * Description:<br>
+ * Configuration for date lists - Virtual Classroom dates.
+ *
+ * <P>
+ * Initial Date: 04.07.2010 <br>
+ *
+ * @author Jens Lindner(jlindne4@hs-mittweida.de)
+ * @author skoeber
+ */
+public class VCCourseNodeConfiguration extends AbstractCourseNodeConfiguration implements CourseNodeConfiguration {
+
+ public String getAlias() {
+ return "vc";
+ }
+
+ public String getIconCSSClass() {
+ return "o_vc_icon";
+ }
+
+ public CourseNode getInstance() {
+ return new VCCourseNode();
+ }
+
+ public String getLinkCSSClass() {
+ return "o_vc_icon";
+ }
+
+ public String getLinkText(Locale locale) {
+ Translator fallback = Util.createPackageTranslator(CourseNodeConfiguration.class, locale);
+ Translator translator = Util.createPackageTranslator(this.getClass(), locale, fallback);
+ return translator.translate("title_vc");
+ }
+
+ @Override
+ public boolean isEnabled() {
+ return super.isEnabled();
+ }
+
+ public ExtensionResource getExtensionCSS() {
+ return null;
+ }
+
+ public List getExtensionResources() {
+ return null;
+ }
+
+ public String getName() {
+ return getAlias();
+ }
+
+ public void setup() {
+ // no special setup necessary
+ }
+
+ public void tearDown() {
+ // no special tear down necessary
+ }
+
+}
+//</OLATCE-103>
\ No newline at end of file
diff --git a/src/main/java/de/bps/course/nodes/vc/VCDatesTableDataModel.java b/src/main/java/de/bps/course/nodes/vc/VCDatesTableDataModel.java
new file mode 100644
index 0000000000000000000000000000000000000000..67416c96917a9a15c3a39748d0d115a33e821057
--- /dev/null
+++ b/src/main/java/de/bps/course/nodes/vc/VCDatesTableDataModel.java
@@ -0,0 +1,70 @@
+//<OLATCE-103>
+/**
+ *
+ * BPS Bildungsportal Sachsen GmbH<br>
+ * Bahnhofstrasse 6<br>
+ * 09111 Chemnitz<br>
+ * Germany<br>
+ *
+ * Copyright (c) 2005-2011 by BPS Bildungsportal Sachsen GmbH<br>
+ * http://www.bps-system.de<br>
+ *
+ * All rights reserved.
+ */
+package de.bps.course.nodes.vc;
+
+import java.util.List;
+
+import org.olat.core.gui.components.table.DefaultTableDataModel;
+
+
+/**
+ *
+ * Description:<br>
+ * Table model for run view of vc course node. Summarizes all planned dates for meetings.
+ *
+ * <P>
+ * Initial Date: 19.01.2011 <br>
+ * @author skoeber
+ */
+public class VCDatesTableDataModel extends DefaultTableDataModel {
+
+ //title, description, begin, end
+ private static final int COLUMN_COUNT = 4;
+
+ public VCDatesTableDataModel(List objects) {
+ super(objects);
+ }
+
+ @Override
+ public int getColumnCount() {
+ return COLUMN_COUNT;
+ }
+
+ @Override
+ public Object getValueAt(int row, int col) {
+ final MeetingDate model = ((MeetingDate) objects.get(row));
+
+ switch (col) {
+ case 0:
+ return model.getTitle();
+ case 1:
+ return model.getDescription();
+ case 2:
+ return model.getBegin();
+ case 3:
+ return model.getEnd();
+ default:
+ return "error";
+ }
+ }
+
+ public MeetingDate getEntryAt(int row) {
+ return (MeetingDate) objects.get(row);
+ }
+
+ public void setEntries(List newEntries) {
+ this.objects = newEntries;
+ }
+}
+//</OLATCE-103>
\ No newline at end of file
diff --git a/src/main/java/de/bps/course/nodes/vc/VCEditController.java b/src/main/java/de/bps/course/nodes/vc/VCEditController.java
new file mode 100644
index 0000000000000000000000000000000000000000..2cc0abe80c158d1dd2af43520d8b6be755d93871
--- /dev/null
+++ b/src/main/java/de/bps/course/nodes/vc/VCEditController.java
@@ -0,0 +1,261 @@
+//<OLATCE-103>
+/**
+ *
+ * BPS Bildungsportal Sachsen GmbH<br>
+ * Bahnhofstrasse 6<br>
+ * 09111 Chemnitz<br>
+ * Germany<br>
+ *
+ * Copyright (c) 2005-2011 by BPS Bildungsportal Sachsen GmbH<br>
+ * http://www.bps-system.de<br>
+ *
+ * All rights reserved.
+ */
+package de.bps.course.nodes.vc;
+
+import java.util.Date;
+import java.util.List;
+
+import org.olat.core.gui.UserRequest;
+import org.olat.core.gui.components.Component;
+import org.olat.core.gui.components.tabbedpane.TabbedPane;
+import org.olat.core.gui.components.velocity.VelocityContainer;
+import org.olat.core.gui.control.Controller;
+import org.olat.core.gui.control.ControllerEventListener;
+import org.olat.core.gui.control.Event;
+import org.olat.core.gui.control.WindowControl;
+import org.olat.core.gui.control.generic.modal.DialogBoxController;
+import org.olat.core.gui.control.generic.modal.DialogBoxUIFactory;
+import org.olat.core.gui.control.generic.tabbable.ActivateableTabbableDefaultController;
+import org.olat.course.ICourse;
+import org.olat.course.assessment.AssessmentHelper;
+import org.olat.course.condition.Condition;
+import org.olat.course.condition.ConditionEditController;
+import org.olat.course.editor.NodeEditController;
+import org.olat.course.run.userview.UserCourseEnvironment;
+import org.olat.modules.ModuleConfiguration;
+
+import de.bps.course.nodes.VCCourseNode;
+import de.bps.course.nodes.vc.provider.VCProvider;
+import de.bps.course.nodes.vc.provider.VCProviderFactory;
+
+/**
+ * Description:<br>
+ * Edit controller for dates list course nodes - Virtual Classroom dates .
+ *
+ * <P>
+ * Initial Date: 30.08.2010 <br>
+ *
+ * @author Jens Lindner (jlindne4@hs-mittweida.de)
+ * @author skoeber
+ */
+public class VCEditController extends ActivateableTabbableDefaultController implements ControllerEventListener {
+
+ private static final String PANE_TAB_ACCESSIBILITY = "pane.tab.accessibility";
+ public static final String PANE_TAB_VCCONFIG = "pane.tab.vcconfig";
+ final static String[] paneKeys = { PANE_TAB_VCCONFIG, PANE_TAB_ACCESSIBILITY };
+
+ // GUI
+ private VelocityContainer editVc;
+ private ConditionEditController accessibilityCondContr;
+ private TabbedPane tabPane;
+ private Controller configCtr;
+ private VCSelectionForm selForm;
+ private VCEditForm editForm;
+ private DialogBoxController yesNoUpdate;
+ private DialogBoxController yesNoDelete;
+
+ // runtime data
+ private VCCourseNode courseNode;
+ private VCConfiguration config;
+ private VCProvider provider;
+ private String roomId;
+
+ public VCEditController(UserRequest ureq, WindowControl wControl, VCCourseNode courseNode,
+ ICourse course, UserCourseEnvironment userCourseEnv, VCProvider provider, VCConfiguration config) {
+ super(ureq, wControl);
+ this.courseNode = courseNode;
+ this.config = config;
+ this.provider = provider;
+
+ editVc = this.createVelocityContainer("edit");
+
+ Condition accessCondition = courseNode.getPreConditionAccess();
+ accessibilityCondContr = new ConditionEditController(ureq, wControl, course.getCourseEnvironment().getCourseGroupManager(),
+ accessCondition, "accessabilityConditionForm", AssessmentHelper.getAssessableNodes(course.getEditorTreeModel(), courseNode),
+ userCourseEnv);
+ this.listenTo(accessibilityCondContr);
+
+ // show selection form when there is more than one registered virtual classroom provider
+ List<VCProvider> registeredProviders = VCProviderFactory.getProviders();
+ if(registeredProviders.size() > 1) {
+ selForm = new VCSelectionForm(ureq, wControl, provider.getProviderId());
+ listenTo(selForm);
+ editVc.put("VCSelectionForm", selForm.getInitialComponent());
+ }
+
+ editForm = new VCEditForm(ureq, wControl, provider.getTemplates(), (DefaultVCConfiguration) config);
+ listenTo(editForm);
+ editVc.put("editForm", editForm.getInitialComponent());
+
+ roomId = course.getResourceableId() + "_" + courseNode.getIdent();
+
+ configCtr = provider.createConfigController(ureq, wControl, roomId, config);
+ listenTo(configCtr);
+ editVc.put("configCtr", configCtr.getInitialComponent());
+ }
+
+ @Override
+ public String[] getPaneKeys() {
+ return paneKeys;
+ }
+
+ @Override
+ public TabbedPane getTabbedPane() {
+ return tabPane;
+ }
+
+ @Override
+ protected void doDispose() {
+ if(configCtr != null) {
+ removeAsListenerAndDispose(configCtr);
+ configCtr = null;
+ }
+ if(editForm != null) {
+ removeAsListenerAndDispose(editForm);
+ editForm = null;
+ }
+ if(selForm != null) {
+ removeAsListenerAndDispose(selForm);
+ selForm = null;
+ }
+ if(yesNoDelete != null) {
+ removeAsListenerAndDispose(yesNoDelete);
+ yesNoDelete = null;
+ }
+ if(yesNoUpdate != null) {
+ removeAsListenerAndDispose(yesNoUpdate);
+ yesNoUpdate = null;
+ }
+ }
+
+ @Override
+ protected void event(UserRequest ureq, Component source, Event event) {
+ // nothing to do
+ }
+
+ @Override
+ protected void event(UserRequest ureq, Controller source, Event event) {
+ if (source == accessibilityCondContr) {
+ if (event == Event.CHANGED_EVENT) {
+ Condition cond = accessibilityCondContr.getCondition();
+ courseNode.setPreConditionAccess(cond);
+ fireEvent(ureq, NodeEditController.NODECONFIG_CHANGED_EVENT);
+ }
+ } else if (source == configCtr | source == editForm) {
+ courseNode.getModuleConfiguration().set(VCCourseNode.CONF_VC_CONFIGURATION, config);
+ courseNode.getModuleConfiguration().setStringValue(VCCourseNode.CONF_PROVIDER_ID, config.getProviderId());
+ /*
+ if(provider.existsClassroom(roomId, config)) {
+ removeAsListenerAndDispose(yesNoUpdate);
+ yesNoUpdate = DialogBoxUIFactory.createYesNoDialog(ureq, getWindowControl(), translate("sync.meeting.title"), translate("sync.meeting.text"));
+ listenTo(yesNoUpdate);
+ yesNoUpdate.activate();
+ }
+ */
+ fireEvent(ureq, NodeEditController.NODECONFIG_CHANGED_EVENT);
+ } else if (source == selForm) {
+ /*
+ * If classroom already exists and the user changes the provider,
+ * the existing room has to be deleted for cleanup purposes. Ask
+ * the user if this is intended.
+ */
+ if(provider.existsClassroom(roomId, config)) {
+ removeAsListenerAndDispose(yesNoDelete);
+ yesNoDelete = DialogBoxUIFactory.createYesNoDialog(ureq, getWindowControl(), translate("delete.meeting.title"), translate("delete.meeting.text"));
+ listenTo(yesNoDelete);
+ yesNoDelete.activate();
+ } else {
+ reset(ureq);
+ }
+ } else if (source == yesNoDelete) {
+ if(DialogBoxUIFactory.isYesEvent(event)) {
+ provider.removeClassroom(roomId, config);
+ reset(ureq);
+ }
+ } else if(source == yesNoUpdate) {
+ if(DialogBoxUIFactory.isYesEvent(event)) {
+ Date allBegin = null, allEnd = null;
+ if(config.getMeetingDates() != null) {
+ for(MeetingDate date : config.getMeetingDates()) {
+ Date begin = date.getBegin();
+ Date end = date.getEnd();
+ allBegin = allBegin == null ? begin : begin.before(allBegin) ? begin : allBegin;
+ allEnd = allEnd == null ? end : end.after(allEnd) ? end : allEnd;
+ }
+ }
+ boolean success = provider.updateClassroom(roomId, courseNode.getShortTitle(), courseNode.getLongTitle(), allBegin, allEnd, config);
+ if(success) {
+ getWindowControl().setInfo(translate("success.update.room"));
+ } else {
+ getWindowControl().setError(translate("error.update.room"));
+ }
+ }
+ } else if(event == NodeEditController.NODECONFIG_CHANGED_EVENT) {
+ // something has changed, maybe the title or description, thus ask to update
+ if(provider.existsClassroom(roomId, config)) {
+ removeAsListenerAndDispose(yesNoUpdate);
+ yesNoUpdate = DialogBoxUIFactory.createYesNoDialog(ureq, getWindowControl(), translate("sync.meeting.title"), translate("sync.meeting.text"));
+ listenTo(yesNoUpdate);
+ yesNoUpdate.activate();
+ }
+ }
+ }
+
+ private void reset(UserRequest ureq) {
+ removeAsListenerAndDispose(editForm);
+ removeAsListenerAndDispose(configCtr);
+ // prepare new edit view
+ String providerId = selForm.getSelectedProvider();
+ provider = VCProviderFactory.createProvider(providerId);
+ config = provider.createNewConfiguration();
+ // create room if configured to do it immediately
+ if(config.isCreateMeetingImmediately()) {
+ // here, the config is empty in any case, thus there are no start and end dates
+ provider.createClassroom(roomId, courseNode.getShortName(), courseNode.getLongTitle(), null, null, config);
+ }
+ editForm = new VCEditForm(ureq, getWindowControl(), provider.getTemplates(), (DefaultVCConfiguration) config);
+ listenTo(editForm);
+ editVc.put("editForm", editForm.getInitialComponent());
+ configCtr = provider.createConfigController(ureq, getWindowControl(), roomId, config);
+ listenTo(configCtr);
+ editVc.put("configCtr", configCtr.getInitialComponent());
+ editVc.setDirty(true);
+ // save the minimal config
+ courseNode.getModuleConfiguration().set(VCCourseNode.CONF_VC_CONFIGURATION, config);
+ courseNode.getModuleConfiguration().setStringValue(VCCourseNode.CONF_PROVIDER_ID, config.getProviderId());
+
+ fireEvent(ureq, NodeEditController.NODECONFIG_CHANGED_EVENT);
+ }
+
+ public void addTabs(TabbedPane tabbedPane) {
+ tabPane = tabbedPane;
+ tabbedPane.addTab(translate(PANE_TAB_ACCESSIBILITY),
+ accessibilityCondContr.getWrappedDefaultAccessConditionVC(translate("condition.accessibility.title")));
+ tabbedPane.addTab(translate(PANE_TAB_VCCONFIG), editVc);
+
+ }
+
+ public static boolean isConfigValid(ModuleConfiguration moduleConfig) {
+ List<MeetingDate> dateList = (List<MeetingDate>) moduleConfig.get(VCCourseNode.CONF_VC_CONFIGURATION);
+ if (dateList != null) {
+ for (MeetingDate date : dateList) {
+ if (date.getTitle().isEmpty() || date.getDescription().isEmpty()) { return false; }
+
+ }
+ return true;
+ }
+ return false;
+ }
+}
+//</OLATCE-103>
\ No newline at end of file
diff --git a/src/main/java/de/bps/course/nodes/vc/VCEditForm.java b/src/main/java/de/bps/course/nodes/vc/VCEditForm.java
new file mode 100644
index 0000000000000000000000000000000000000000..54fdda35a80f57e2898c0127d8846c9802e4212e
--- /dev/null
+++ b/src/main/java/de/bps/course/nodes/vc/VCEditForm.java
@@ -0,0 +1,295 @@
+//<OLATCE-103>
+/**
+ *
+ * BPS Bildungsportal Sachsen GmbH<br>
+ * Bahnhofstrasse 6<br>
+ * 09111 Chemnitz<br>
+ * Germany<br>
+ *
+ * Copyright (c) 2005-2011 by BPS Bildungsportal Sachsen GmbH<br>
+ * http://www.bps-system.de<br>
+ *
+ * All rights reserved.
+ */
+package de.bps.course.nodes.vc;
+
+import java.text.SimpleDateFormat;
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.StringTokenizer;
+import java.util.TimeZone;
+
+import org.olat.core.gui.UserRequest;
+import org.olat.core.gui.components.form.flexible.FormItem;
+import org.olat.core.gui.components.form.flexible.FormItemContainer;
+import org.olat.core.gui.components.form.flexible.elements.DateChooser;
+import org.olat.core.gui.components.form.flexible.elements.FormLink;
+import org.olat.core.gui.components.form.flexible.elements.MultipleSelectionElement;
+import org.olat.core.gui.components.form.flexible.elements.SingleSelection;
+import org.olat.core.gui.components.form.flexible.elements.TextElement;
+import org.olat.core.gui.components.form.flexible.impl.FormBasicController;
+import org.olat.core.gui.components.form.flexible.impl.FormEvent;
+import org.olat.core.gui.components.form.flexible.impl.FormLayoutContainer;
+import org.olat.core.gui.components.form.flexible.impl.elements.FormLinkImpl;
+import org.olat.core.gui.components.form.flexible.impl.elements.FormSubmit;
+import org.olat.core.gui.components.link.Link;
+import org.olat.core.gui.control.Controller;
+import org.olat.core.gui.control.WindowControl;
+import org.olat.course.editor.NodeEditController;
+
+
+/**
+ *
+ * Description:<br>
+ * Form for standard options of the virtual classroom course node.
+ *
+ * <P>
+ * Initial Date: 18.01.2011 <br>
+ * @author skoeber
+ */
+public class VCEditForm extends FormBasicController {
+
+ // GUI
+ private FormLayoutContainer editVC;
+ private FormSubmit submit;
+ private List<TextElement> vcTitleInputList;
+ private List<TextElement> vcDescriptionInputList;
+ private List<DateChooser> vcCalenderbeginInputList;
+ private List<TextElement> vcDurationInputList;
+ private List<FormLink> vcDelButtonList;
+ private List<FormLink> vcAddButtonList;
+ private SingleSelection vcTemplate;
+ private MultipleSelectionElement multiSelectOptions;
+ private static String OPTION_DATES = "vc.access.dates";
+
+ // data
+ private DefaultVCConfiguration config;
+ private Map<String,String> templates = new HashMap<String, String>();
+ private List<MeetingDate> dateList = new ArrayList<MeetingDate>();
+
+ private int counter = 0;
+
+ public VCEditForm(UserRequest ureq, WindowControl wControl, Map<String, String> templates, DefaultVCConfiguration config) {
+ super(ureq, wControl, FormBasicController.LAYOUT_VERTICAL);
+ this.config = config;
+ this.templates.putAll(templates);
+
+ // read existing dates from config
+ if(config.getMeetingDates() != null) dateList.addAll(config.getMeetingDates());
+
+ this.vcTitleInputList = new ArrayList<TextElement>(dateList.size());
+ this.vcDescriptionInputList = new ArrayList<TextElement>(dateList.size());
+ this.vcCalenderbeginInputList = new ArrayList<DateChooser>(dateList.size());
+ this.vcDurationInputList = new ArrayList<TextElement>(dateList.size());
+ this.vcAddButtonList = new ArrayList<FormLink>(dateList.size());
+ this.vcDelButtonList = new ArrayList<FormLink>(dateList.size());
+
+ initForm(this.flc, this, ureq);
+ }
+
+ @Override
+ protected void initForm(FormItemContainer formLayout, Controller listener, UserRequest ureq) {
+ editVC = FormLayoutContainer.createCustomFormLayout("titleLayout", getTranslator(), velocity_root + "/editForm.html");
+ formLayout.add(editVC);
+
+ // template chooser
+ String[] keys = new String[templates.size() + 1];
+ keys[0] = DefaultVCConfiguration.DEFAULT_TEMPLATE;
+ String[] values = new String[templates.size() + 1];
+ values[0] = "";
+ int index = 1;
+ for(String key:templates.keySet()) {
+ keys[index] = key;
+ values[index] = templates.get(key);
+ index++;
+ }
+ boolean hasTemplates = templates.size() > 0;
+ if(hasTemplates) {
+ vcTemplate = uifactory.addDropdownSingleselect("vc.template.choose", "vc.template.choose.label", editVC, keys, values, null);
+ String templateKey = config.getTemplateKey();
+ vcTemplate.select(templateKey == null ? DefaultVCConfiguration.DEFAULT_TEMPLATE : templateKey, true);
+ }
+ editVC.contextPut("hasTemplates", hasTemplates);
+
+ // meeting options
+ boolean useDates = !dateList.isEmpty() | config.isUseMeetingDates();
+ String[] accessKeys = new String[] {OPTION_DATES};
+ String[] accessVals = new String[] {translate(OPTION_DATES)};
+ multiSelectOptions = uifactory.addCheckboxesVertical("vc.options", "vc.options.label", editVC, accessKeys, accessVals, null, 1);
+ multiSelectOptions.select(OPTION_DATES, useDates);
+ multiSelectOptions.addActionListener(this, FormEvent.ONCHANGE);
+
+ // create gui elements for all meetings
+ editVC.contextPut("useDates", useDates);
+ if(useDates) addDates();
+
+ editVC.contextPut("dateList", dateList);
+ editVC.contextPut("vcTitleInputList", vcTitleInputList);
+ editVC.contextPut("vcDescriptionInputList", vcDescriptionInputList);
+ editVC.contextPut("vcCalenderbeginInputList", vcCalenderbeginInputList);
+ editVC.contextPut("vcDurationInputList", vcDurationInputList);
+ editVC.contextPut("vcAddButtonList", vcAddButtonList);
+ editVC.contextPut("vcDelButtonList", vcDelButtonList);
+
+ submit = new FormSubmit("subm", "submit");
+
+ formLayout.add(submit);
+ }
+
+ private void addDates() {
+ if (dateList.isEmpty()) {
+ MeetingDate meetingData = new MeetingDate();
+ meetingData.setBegin(new Date());
+ meetingData.setEnd(new Date(meetingData.getBegin().getTime() + 1000*60*60));
+ dateList.add(meetingData);
+ }
+ for (int i = 0; i < dateList.size(); i++) {
+ MeetingDate date = dateList.get(i);
+ addRow(i, date);
+ }
+ }
+
+ private void removeDates() {
+ for (int i = 0; i < dateList.size(); i++) {
+ removeRow(i);
+ }
+ }
+
+ @Override
+ protected void doDispose() {
+ // nothing to dispose
+ }
+
+ @Override
+ protected void formOK(UserRequest ureq) {
+ // read data from form elements
+ for (int i = 0; i < dateList.size(); i++) {
+ MeetingDate date = dateList.get(i);
+ String dateValue = vcTitleInputList.get(i).getValue();
+ date.setTitle(dateValue);
+
+ StringTokenizer strTok = new StringTokenizer(vcDurationInputList.get(i).getValue(), ":", false);
+ long dur = 1000 * 60 * 60 * Long.parseLong(strTok.nextToken()) + 1000 * 60 * Long.parseLong(strTok.nextToken());
+
+ date.setBegin(vcCalenderbeginInputList.get(i).getDate());
+ date.setEnd(new Date(date.getBegin().getTime() + dur));
+ date.setDescription(vcDescriptionInputList.get(i).getValue());
+ }
+ boolean useDates = multiSelectOptions.getSelectedKeys().contains(OPTION_DATES);
+ config.setUseMeetingDates(useDates);
+ if(useDates) config.setMeetingDatas(dateList);
+ if(!templates.isEmpty() && vcTemplate.isOneSelected()) config.setTemplateKey(vcTemplate.getSelectedKey());
+ fireEvent(ureq, NodeEditController.NODECONFIG_CHANGED_EVENT);
+ }
+
+ @Override
+ protected void formInnerEvent(UserRequest ureq, FormItem source, FormEvent event) {
+ if (source.getComponent() instanceof Link) {
+ if (vcAddButtonList.contains(source)) {
+ Long row = new Long(vcAddButtonList.indexOf(source));
+ int index = row.intValue() + 1;
+ MeetingDate meetingData = new MeetingDate();
+ meetingData.setBegin(new Date());
+ meetingData.setEnd(new Date(meetingData.getBegin().getTime() + 1000*60*60));
+ dateList.add(index, meetingData);
+ addRow(index, meetingData);
+ } else if (vcDelButtonList.contains(source)) {
+ // special case: only one line existent
+ if (dateList.size() == 1) {
+ // clear this line
+ vcTitleInputList.get(0).setValue("");
+ vcDescriptionInputList.get(0).setValue("");
+ vcCalenderbeginInputList.get(0).setDate(new Date());
+ vcDurationInputList.get(0).setValue("01:00");
+ } else {
+ int row = vcDelButtonList.indexOf(source);
+ removeRow(row);
+ }
+ }
+ } else if(source == multiSelectOptions) {
+ boolean useDates = multiSelectOptions.getSelectedKeys().contains(OPTION_DATES);
+ if(useDates) addDates();
+ else removeDates();
+ editVC.contextRemove("useDates");
+ editVC.contextPut("useDates", useDates);
+ editVC.setDirty(true);
+ }
+ super.formInnerEvent(ureq, source, event);
+ }
+
+ private void addRow(int index, final MeetingDate date) {
+ // title
+ TextElement vcTitle = uifactory.addTextElement("title" + counter, null, -1, date.getTitle(), editVC);
+ vcTitle.setDisplaySize(30);
+ vcTitle.setMandatory(true);
+ vcTitle.setNotEmptyCheck("vc.table.title.empty");
+ vcTitleInputList.add(index, vcTitle);
+
+ // description
+ TextElement vcDescription = uifactory.addTextElement("description" + counter, null, -1, date.getDescription(), editVC);
+ vcDescription.setDisplaySize(20);
+ vcDescription.setNotEmptyCheck("vc.table.description.empty");
+ vcDescription.setMandatory(true);
+ vcDescriptionInputList.add(index, vcDescription);
+
+ // begin
+ DateChooser vcScheduleDate = uifactory.addDateChooser("begin" + counter, "vc.table.begin", "", editVC);
+ vcScheduleDate.setNotEmptyCheck("vc.table.begin.empty");
+ vcScheduleDate.setValidDateCheck("vc.table.begin.error");
+ vcScheduleDate.setMandatory(true);
+ vcScheduleDate.setDisplaySize(20);
+ vcScheduleDate.setDateChooserTimeEnabled(true);
+ vcScheduleDate.setDate(date.getBegin());
+ vcCalenderbeginInputList.add(index, vcScheduleDate);
+
+ // add date duration
+ SimpleDateFormat sdDuration = new SimpleDateFormat("HH:mm");
+ TimeZone tz = TimeZone.getTimeZone("Etc/GMT+0");
+ sdDuration.setTimeZone(tz);
+
+ TextElement vcDuration = uifactory.addTextElement("duration" + counter, "vc.table.duration", 5, String.valueOf(0), editVC);
+ vcDuration.setDisplaySize(5);
+ vcDuration.setValue(sdDuration.format(new Date(date.getEnd().getTime() - date.getBegin().getTime())));
+ vcDuration.setRegexMatchCheck("\\d{1,2}:\\d\\d", "form.error.format");
+ vcDuration.setExampleKey("vc.table.duration.example", null);
+ vcDuration.setNotEmptyCheck("vc.table.duration.empty");
+ vcDuration.setErrorKey("vc.table.duration.error", null);
+ vcDuration.setMandatory(true);
+ vcDuration.showExample(true);
+ vcDuration.showError(false);
+ this.vcDurationInputList.add(index, vcDuration);
+
+ // add row button
+ FormLink addButton = new FormLinkImpl("add" + counter, "add" + counter, "vc.table.add", Link.BUTTON_SMALL);
+ editVC.add(addButton);
+ vcAddButtonList.add(index, addButton);
+
+ // remove row button
+ FormLink delButton = new FormLinkImpl("delete" + counter, "delete" + counter, "vc.table.delete", Link.BUTTON_SMALL);
+ editVC.add(delButton);
+ vcDelButtonList.add(index, delButton);
+
+ // increase the counter to enable unique component names
+ counter++;
+ }
+
+ private void removeRow(int row) {
+ // remove date from model list
+ if(dateList.get(row) != null) dateList.remove(row);
+
+ editVC.remove(vcTitleInputList.remove(row));
+ editVC.remove(vcDescriptionInputList.remove(row));
+ editVC.remove(vcDurationInputList.remove(row));
+ editVC.remove(vcCalenderbeginInputList.remove(row));
+ editVC.remove(vcAddButtonList.remove(row));
+ editVC.remove(vcDelButtonList.remove(row));
+
+ // decrease the counter for unique component names
+ counter--;
+ }
+
+}
+//</OLATCE-103>
\ No newline at end of file
diff --git a/src/main/java/de/bps/course/nodes/vc/VCModul.java b/src/main/java/de/bps/course/nodes/vc/VCModul.java
new file mode 100644
index 0000000000000000000000000000000000000000..4a2081fcd25aa14380b73e720f0d5e216e736151
--- /dev/null
+++ b/src/main/java/de/bps/course/nodes/vc/VCModul.java
@@ -0,0 +1,77 @@
+// <OLATCE-103>
+/**
+ *
+ * BPS Bildungsportal Sachsen GmbH<br>
+ * Bahnhofstrasse 6<br>
+ * 09111 Chemnitz<br>
+ * Germany<br>
+ *
+ * Copyright (c) 2005-2010 by BPS Bildungsportal Sachsen GmbH<br>
+ * http://www.bps-system.de<br>
+ *
+ * All rights reserved.
+ */
+package de.bps.course.nodes.vc;
+
+import org.olat.core.logging.OLog;
+import org.olat.core.logging.Tracing;
+import org.olat.core.logging.activity.LogModule;
+
+/**
+ * Description:<br>
+ * Virtual classroom configuration, setup by spring
+ *
+ * <P>
+ * Initial Date: 28.08.2010 <br>
+ *
+ * @author Jens Lindner (jlindne4@hs-mittweida.de)
+ * @author skoeber
+ */
+public class VCModul {
+
+ static final OLog log = Tracing.createLoggerFor(LogModule.class);
+
+ private String baseUrl, adminLogin, adminPassword, connectID, version;
+
+ public String getBaseUrl() {
+ return baseUrl;
+ }
+
+ public void setBaseUrl(String baseUrl) {
+ this.baseUrl = baseUrl;
+ }
+
+ public String getAdminLogin() {
+ return adminLogin;
+ }
+
+ public void setAdminLogin(String adminLogin) {
+ this.adminLogin = adminLogin;
+ }
+
+ public String getAdminPassword() {
+ return adminPassword;
+ }
+
+ public void setAdminPassword(String adminPassword) {
+ this.adminPassword = adminPassword;
+ }
+
+ public String getConnectID() {
+ return connectID;
+ }
+
+ public void setConnectID(String connectID) {
+ this.connectID = connectID;
+ }
+
+ public String getVersion() {
+ return version;
+ }
+
+ public void setVersion(String version) {
+ this.version = version;
+ }
+
+}
+// </OLATCE-103>
\ No newline at end of file
diff --git a/src/main/java/de/bps/course/nodes/vc/VCRunController.java b/src/main/java/de/bps/course/nodes/vc/VCRunController.java
new file mode 100644
index 0000000000000000000000000000000000000000..b8a2244d4b860996b8ad775e023e9a0c46816257
--- /dev/null
+++ b/src/main/java/de/bps/course/nodes/vc/VCRunController.java
@@ -0,0 +1,125 @@
+//<OLATCE-103>
+/**
+ *
+ * BPS Bildungsportal Sachsen GmbH<br>
+ * Bahnhofstrasse 6<br>
+ * 09111 Chemnitz<br>
+ * Germany<br>
+ *
+ * Copyright (c) 2005-2011 by BPS Bildungsportal Sachsen GmbH<br>
+ * http://www.bps-system.de<br>
+ *
+ * All rights reserved.
+ */
+package de.bps.course.nodes.vc;
+
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.List;
+
+import org.olat.core.gui.UserRequest;
+import org.olat.core.gui.components.Component;
+import org.olat.core.gui.components.table.DefaultColumnDescriptor;
+import org.olat.core.gui.components.table.TableController;
+import org.olat.core.gui.components.table.TableGuiConfiguration;
+import org.olat.core.gui.components.velocity.VelocityContainer;
+import org.olat.core.gui.control.Controller;
+import org.olat.core.gui.control.Event;
+import org.olat.core.gui.control.WindowControl;
+import org.olat.core.gui.control.controller.BasicController;
+
+import de.bps.course.nodes.vc.provider.VCProvider;
+
+/**
+ *
+ * Description:<br>
+ * Run view for virtual classroom course node
+ *
+ * <P>
+ * Initial Date: 18.01.2011 <br>
+ * @author skoeber
+ */
+public class VCRunController extends BasicController {
+
+ //objects for run view
+ private VelocityContainer runVC;
+ private Controller displayCtr;
+ private TableController tableCtr;
+
+ // data
+ private VCProvider provider;
+ private VCConfiguration config;
+ private VCDatesTableDataModel tableData;
+ private List<MeetingDate> dateList = new ArrayList<MeetingDate>();
+ private MeetingDate meeting;
+
+ public VCRunController(UserRequest ureq, WindowControl wControl, String roomId, String name, String description, VCConfiguration config, VCProvider provider, boolean isModerator) {
+ super(ureq, wControl);
+ this.provider = provider;
+ this.config = config;
+
+ if(this.config.getMeetingDates() != null) dateList.addAll(this.config.getMeetingDates());
+
+ // select actual meeting
+ if(config.isUseMeetingDates()) {
+ Date now = new Date((new Date()).getTime() + 15*60*1000); // allow to start meetings about 15 minutes before begin
+ for(MeetingDate date : dateList) {
+ Date begin = date.getBegin();
+ Date end = date.getEnd();
+ if(now.after(begin) & now.before(end)) {
+ meeting = date;
+ }
+ }
+ }
+
+ tableData = new VCDatesTableDataModel(dateList);
+
+ TableGuiConfiguration tableConfig = new TableGuiConfiguration();
+ tableConfig.setTableEmptyMessage("<b>"+translate("vc.table.empty")+"</b>");
+ tableConfig.setColumnMovingOffered(true);
+ tableConfig.setSortingEnabled(true);
+ tableCtr = new TableController(tableConfig, ureq, wControl, getTranslator());
+ tableCtr.addColumnDescriptor(new DefaultColumnDescriptor("vc.table.title", 0, null, ureq.getLocale()));
+ tableCtr.addColumnDescriptor(new DefaultColumnDescriptor("vc.table.description", 1, null, ureq.getLocale()));
+ tableCtr.addColumnDescriptor(new DefaultColumnDescriptor("vc.table.begin", 2, null, ureq.getLocale()));
+ tableCtr.addColumnDescriptor(new DefaultColumnDescriptor("vc.table.end", 3, null, ureq.getLocale()));
+ tableCtr.setTableDataModel(tableData);
+ tableCtr.setSortColumn(2, true);// timeframe
+ listenTo(tableCtr);
+
+ runVC = createVelocityContainer("run");
+ runVC.put("datesTable", tableCtr.getInitialComponent());
+
+ runVC.contextPut("isModerator", isModerator);
+ boolean isUseDates = config.isUseMeetingDates();
+ runVC.contextPut("useDates", isUseDates);
+ boolean isMeeting = !isUseDates | meeting != null;
+ runVC.contextPut("isMeeting", isMeeting);
+ boolean show = isModerator | (isUseDates & isMeeting) | !isUseDates;
+ runVC.contextPut("show", show);
+
+ displayCtr = this.provider.createDisplayController(ureq, wControl, roomId, name, description, isModerator, config);
+ runVC.put("displayCtr", displayCtr.getInitialComponent());
+
+ putInitialPanel(runVC);
+ }
+
+ @Override
+ protected void event(UserRequest ureq, Component source, Event event) {
+ // nothing to do
+ }
+
+ @Override
+ protected void doDispose() {
+ if(tableCtr != null) {
+ removeAsListenerAndDispose(tableCtr);
+ tableCtr = null;
+ }
+ if(displayCtr != null) {
+ removeAsListenerAndDispose(displayCtr);
+ displayCtr = null;
+ }
+ }
+
+}
+//</OLATCE-103>
diff --git a/src/main/java/de/bps/course/nodes/vc/VCSelectionForm.java b/src/main/java/de/bps/course/nodes/vc/VCSelectionForm.java
new file mode 100644
index 0000000000000000000000000000000000000000..40410483ab180cfe1f6f333654f6de492daa5f09
--- /dev/null
+++ b/src/main/java/de/bps/course/nodes/vc/VCSelectionForm.java
@@ -0,0 +1,88 @@
+//<OLATCE-103>
+/**
+ *
+ * BPS Bildungsportal Sachsen GmbH<br>
+ * Bahnhofstrasse 6<br>
+ * 09111 Chemnitz<br>
+ * Germany<br>
+ *
+ * Copyright (c) 2005-2011 by BPS Bildungsportal Sachsen GmbH<br>
+ * http://www.bps-system.de<br>
+ *
+ * All rights reserved.
+ */
+package de.bps.course.nodes.vc;
+
+import org.olat.core.gui.UserRequest;
+import org.olat.core.gui.components.form.flexible.FormItem;
+import org.olat.core.gui.components.form.flexible.FormItemContainer;
+import org.olat.core.gui.components.form.flexible.elements.SingleSelection;
+import org.olat.core.gui.components.form.flexible.impl.FormBasicController;
+import org.olat.core.gui.components.form.flexible.impl.FormEvent;
+import org.olat.core.gui.control.Controller;
+import org.olat.core.gui.control.Event;
+import org.olat.core.gui.control.WindowControl;
+
+import de.bps.course.nodes.vc.provider.VCProvider;
+import de.bps.course.nodes.vc.provider.VCProviderFactory;
+
+/**
+ *
+ * Description:<br>
+ * Support selection of a virtual classroom, if there are multiple ones registered.
+ *
+ * <P>
+ * Initial Date: 07.01.2011 <br>
+ * @author skoeber
+ */
+public class VCSelectionForm extends FormBasicController {
+
+ private SingleSelection selVC;
+ private String selectedProvider;
+
+ public VCSelectionForm(UserRequest ureq, WindowControl wControl, String selectedProvider) {
+ super(ureq, wControl);
+ this.selectedProvider = selectedProvider;
+ initForm(flc, this, ureq);
+ }
+
+ @Override
+ protected void initForm(FormItemContainer formLayout, Controller listener, UserRequest ureq) {
+ int num = VCProviderFactory.getProviders().size();
+ String[] keys = new String[num];
+ String[] vals = new String[num];
+ int i = 0;
+ for(VCProvider provider : VCProviderFactory.getProviders()) {
+ keys[i] = provider.getProviderId();
+ vals[i] = provider.getDisplayName();
+ i++;
+ }
+
+ selVC = uifactory.addDropdownSingleselect("config.select.vc", flc, keys, vals, null);
+ selVC.select(selectedProvider, true);
+ selVC.addActionListener(this, FormEvent.ONCHANGE);
+ }
+
+ @Override
+ protected void formInnerEvent(UserRequest ureq, FormItem source, FormEvent event) {
+ if(source == selVC) {
+ fireEvent(ureq, Event.CHANGED_EVENT);
+ }
+ }
+
+ public String getSelectedProvider() {
+ return selVC.getSelectedKey();
+ }
+
+ @Override
+ protected void formOK(UserRequest ureq) {
+ // nothing to do
+ }
+
+ @Override
+ protected void doDispose() {
+ // nothing to dispose
+ }
+
+}
+//<OLATCE-103>
\ No newline at end of file
diff --git a/src/main/java/de/bps/course/nodes/vc/_chelp/ced-vc-config.html b/src/main/java/de/bps/course/nodes/vc/_chelp/ced-vc-config.html
new file mode 100644
index 0000000000000000000000000000000000000000..adc858afa765afe8c30f8223b5377bf518a9eb0d
--- /dev/null
+++ b/src/main/java/de/bps/course/nodes/vc/_chelp/ced-vc-config.html
@@ -0,0 +1,5 @@
+<!-- <OLATCE-103> -->
+<p>$r.translate("chelp.vc1")</p>
+<p>$r.translate("chelp.vc2")</p>
+<p>$r.translate("chelp.vc3")</p>
+<!-- </OLATCE-103> -->
\ No newline at end of file
diff --git a/src/main/java/de/bps/course/nodes/vc/_content/edit.html b/src/main/java/de/bps/course/nodes/vc/_content/edit.html
new file mode 100644
index 0000000000000000000000000000000000000000..13aac3e5fa5173d19a36d17d5f53fc5823338495
--- /dev/null
+++ b/src/main/java/de/bps/course/nodes/vc/_content/edit.html
@@ -0,0 +1,14 @@
+<!-- <OLATCE-103> -->
+<fieldset>
+ <legend>$r.translate("config.header")</legend>
+ $r.contextHelpWithWrapper("de.bps.course.nodes.vc","ced-vc-config.html","chelp.hover.vc.config")
+ #if($r.available("VCSelectionForm"))
+ $r.render("VCSelectionForm")
+ #end
+ $r.render("editForm")
+</fieldset>
+<fieldset>
+ <legend>$r.translate("config.header.extended")</legend>
+ $r.render("configCtr")
+</fieldset>
+<!-- </OLATCE-103> -->
\ No newline at end of file
diff --git a/src/main/java/de/bps/course/nodes/vc/_content/editForm.html b/src/main/java/de/bps/course/nodes/vc/_content/editForm.html
new file mode 100644
index 0000000000000000000000000000000000000000..9e9932a8bfc74ca14a84817f0a9c42be84e6dad0
--- /dev/null
+++ b/src/main/java/de/bps/course/nodes/vc/_content/editForm.html
@@ -0,0 +1,53 @@
+<!-- <OLATCE-103> -->
+#if($hasTemplates)
+ <strong>$r.translate("vc.template.choose.intro")</strong>
+ $r.render("vc.template.choose")
+#else
+ <p>$r.translate("vc.template.empty")</p>
+#end
+<br/>
+<strong>$r.translate("vc.options.intro")</strong>
+$r.render("vc.options")
+<br/>
+#if($useDates)
+ <strong>$r.translate("vc.meetings.intro")</strong>
+ <table>
+ <tr>
+ <td>$r.translate("vc.table.title")</td>
+ <td>$r.translate("vc.table.description")</td>
+ <td>$r.translate("vc.table.begin")</td>
+ <td colspan="3">$r.translate("vc.table.duration")</td>
+ </tr>
+
+ #foreach($date in $dateList)
+ #set( $iter = $velocityCount - 1)
+ #set( $title = $vcTitleInputList.get($iter).getName() )
+ #set( $titleErr = $title + "_ERROR" )
+ #set( $descr = $vcDescriptionInputList.get($iter).getName() )
+ #set( $descrErr = $descr + "_ERROR" )
+ #set( $begin = $vcCalenderbeginInputList.get($iter).getName() )
+ #set( $beginErr = $begin + "_ERROR" )
+ #set( $duration = $vcDurationInputList.get($iter).getName() )
+ #set( $durationErr = $duration + "_ERROR" )
+ <tr>
+ <td><div class="b_form_error">#if($f.hasError($title))$r.render($titleErr)#end</div></td>
+ <td><div class="b_form_error">#if($f.hasError($descr))$r.render($descrErr)#end</div></td>
+ <td><div class="b_form_error">#if($f.hasError($begin))$r.render($beginErr)#end</div></td>
+ <td><div class="b_form_error">#if($f.hasError($duration))$r.render($durationErr)#end</div></td>
+ <td></td>
+ <td></td>
+ </tr>
+ <tr>
+ <td>$r.render($title)</td>
+ <td>$r.render($descr)</td>
+ <td>$r.render($begin)</td>
+ <td>$r.render($duration)</td>
+ <td style="white-space: nowrap;">
+ $r.render($vcAddButtonList.get($iter).getName())
+ $r.render($vcDelButtonList.get($iter).getName())
+ </td>
+ </tr>
+ #end
+ </table>
+#end
+<!-- </OLATCE-103> -->
\ No newline at end of file
diff --git a/src/main/java/de/bps/course/nodes/vc/_content/run.html b/src/main/java/de/bps/course/nodes/vc/_content/run.html
new file mode 100644
index 0000000000000000000000000000000000000000..2cb55c0f24f73db979c586f5c256f4511a4799df
--- /dev/null
+++ b/src/main/java/de/bps/course/nodes/vc/_content/run.html
@@ -0,0 +1,22 @@
+<!-- <OLATCE-103> -->
+#if($useDates)
+ <p>$r.translate("vc.table.intro")</p>
+ $r.render("datesTable")
+ <br/>
+#end
+
+#if($isModerator)
+ #if(!$isMeeting)
+ <p>$r.translate("no.meeting.moderator")</p>
+ #end
+#else
+ #if(!$show)
+ <p>$r.translate("no.meeting.learner")</p>
+ #end
+#end
+
+#if($show)
+ $r.render("displayCtr")
+#end
+
+<!-- </OLATCE-103> -->
\ No newline at end of file
diff --git a/src/main/java/de/bps/course/nodes/vc/_i18n/LocalStrings_de.properties b/src/main/java/de/bps/course/nodes/vc/_i18n/LocalStrings_de.properties
new file mode 100644
index 0000000000000000000000000000000000000000..a3faa4c8fe77cd984a189df783e4f33d611553e9
--- /dev/null
+++ b/src/main/java/de/bps/course/nodes/vc/_i18n/LocalStrings_de.properties
@@ -0,0 +1,54 @@
+#<OLATCE-103>
+pane.tab.accessibility=Zugang
+pane.tab.vcconfig=Konfiguration
+condition.accessibility.title=Zugang
+title_vc=Virtuelles Klassenzimmer
+config.header=Konfiguration des virtuellen Klassenzimmers
+config.header.extended=Erweiterte Konfiguration
+config.select.vc=System f\u00fcr virtuellen Klassenraum
+error.config.short=Konfiguration von "{0}" fehlerhaft
+error.config.long=Die Konfiguration des Kursbausteins "{0}" ist fehlerhaft oder unvollst\u00e4ndig.
+
+error.update.room=Das virtuelle Klassenzimmer konnte nicht mit den aktuellen Einstellungen synchronisiert werden. Bitte wenden Sie sich an Ihren Betreuer oder Ihre Systemadministratoren.
+
+delete.meeting.title=Virtuelles Klassenzimmers l\u00f6schen
+delete.meeting.text=Sie haben ein anderes System f\u00fcr das virtuelle Klassenzimmer ausgew\u00e4hlt. Das bestehende Virtuelle Klassenzimmer wird bei dieser \u00c4nderung gel\u00f6scht. Wollen Sie das System wirklich wechseln?
+
+no.meeting.learner=Derzeit findet kein Meeting statt, dem Sie beitreten k\u00f6nnten.
+no.meeting.moderator=Derzeit findet kein Meeting statt. Teilnehmer k\u00f6nnen das virtuelle Klassenzimmer 15 Minuten vor einem geplanten Meeting betreten.
+
+sync.meeting.title=Virtuelles Klassenzimmer synchronisieren
+sync.meeting.text=Sie haben die Einstellungen f\u00fcr diese virtuelle Klassenzimmer ge\u00e4ndert, nachdem dieses er\u00f6ffnet wurde. Die \u00c4nderungen werden erst wirksam, wenn Sie das virtuelle Klassenzimmer mit den neuen Einstellungen synchronisieren. Die Einstellungen k\u00f6nnen auch jederzeit direkt im Kurs synchronisiert werden. M\u00f6chten Sie die Einstellungen jetzt synchronisieren?
+success.update.room=Das virtuelle Klassenzimmer wurde erfolgreich synchronisiert. Bitte vergessen Sie nicht, die \u00c4nderungen zu publizieren.
+
+vc.access.dates=Virtuelles Klassenzimmer soll nur zu bestimmten Terminen betreten werden k\u00f6nnen
+vc.meetings.intro=Termine f\u00fcr Meetings
+vc.table.add=+
+vc.table.begin=Start
+vc.table.begin.empty=Datumsangabe fehlt
+vc.table.begin.error=Fehlerhafte Eingabe
+vc.table.description=Beschreibung
+vc.table.description.empty=Beschreibung fehlt
+vc.table.delete=-
+vc.table.duration=Dauer
+vc.table.duration.empty=Dauer fehlt
+vc.table.duration.error=Falsches Format
+vc.table.duration.example=hh\:mm
+vc.table.empty=Derzeit sind keine Meetings geplant.
+vc.table.end=Ende
+vc.table.intro=Hier finden Sie eine Liste aller geplanten Meetings:
+vc.table.title=Titel
+vc.table.title.empty=Titel fehlt
+vc.template.choose.intro=Vorlage f\u00fcr virtuelles Klassenzimmer
+vc.template.choose.label=Vorlage
+vc.template.empty=Es stehen keine Templates zur Verf\u00fcgung
+vc.options=Zutrittsberechtigung
+vc.options.intro=Zutrittsberechtigung
+vc.options.label=Zutrittsberechtigung
+
+chelp.ced-vc-config.title=Virtuelles Klassenzimmer konfigurieren
+chelp.hover.vc.config=Hilfe zur Konfiguration des Virtuellen Klassenzimmers
+chelp.vc1=Richten Sie ein virtuelles Klassenzimmer zur Online-Kommunikation (Pr\u00e4sentationen, Diskussionen, Whiteboard, Desktop-Sharing uvm.) mit Ihren Kurs-Teilnehmern ein. Jedem Kursbaustein wird genau ein virtuelles Klassenzimmer zugeordnet. W\u00e4hlen Sie Vorkonfigurationen f\u00fcr diesen Raum und definieren Sie ggf., zu welchen Terminen der Raum f\u00fcr Nutzer betretbar ist. Um Ressourcen zu sparen, wird ein Raum nicht automatisch mit Erstellen des Kursbausteins er\u00f6ffnet, sondern muss je nach Konfiguration (siehe <i>Zutrittsberechtigung</i>) vor dem ersten Betreten durch einen Moderator oder Teilnehmer <i>er\u00f6ffnet</i> werden.
+chelp.vc2=<b>Vorlage f\u00fcr virtuelles Klassenzimmer:</b> Die jeweiligen Vorlagen bringen unterschiedliche Vorkonfigurationen f\u00fcr den Raum mit sich.
+chelp.vc3=<b>Termine f\u00fcr Meetings:</b> Definieren Sie einen oder mehrere Termine, zu denen der Raum von Teilnehmern betreten werden kann.
+#</OLATCE-103>
\ No newline at end of file
diff --git a/src/main/java/de/bps/course/nodes/vc/_i18n/LocalStrings_en.properties b/src/main/java/de/bps/course/nodes/vc/_i18n/LocalStrings_en.properties
new file mode 100644
index 0000000000000000000000000000000000000000..ac66b5cc024ab5c2c9a892b1be9191e2ee8ee38a
--- /dev/null
+++ b/src/main/java/de/bps/course/nodes/vc/_i18n/LocalStrings_en.properties
@@ -0,0 +1,54 @@
+#<OLATCE-103 OLATCE-619>
+pane.tab.accessibility=Access
+pane.tab.vcconfig=Configuration
+condition.accessibility.title=Access
+title_vc=Virtual classroom
+config.header=Configuration of the virtual classroom
+config.header.extended=Extended configuration
+config.select.vc=System for virtual classroom
+error.config.short=Configuration of "{0}" contains errors
+error.config.long=The configuration of the course node "{0}" contains errors or is incomplete.
+
+error.update.room=Sorry! An error occured while synchronizing the virtual class room with the actual configuration. Please, inform your tutor or system administrator.
+
+delete.meeting.title=Delete virtual classroom
+delete.meeting.text=You have changed the system for your virtual classroom. The existing classroom will thus be deleted. Do you really want to delete the classroom?
+
+no.meeting.learner=Currently, there are no meetings planned.
+no.meeting.moderator=Currently, there are no meetings planned. Participants may enter the virtual classroom 15 minutes prior to meeting start.
+
+sync.meeting.title=Synchronize virtual classroom
+sync.meeting.text=You have changed the configuration of the virtual classroom after it had been started. The changes will be taken into account only after having synchronized the virtual class room with the new configuration. You can synchronize the configuration at any time directly from the course run. Do you want to synchronize now?
+success.update.room=The virtual classroom has been synchronized successfully. Do not forget to publish the current changes.
+
+vc.access.dates=Virtual classroom shall only be available at defined dates
+vc.meetings.intro=Planned dates for meetings
+vc.table.add=+
+vc.table.begin=Begin
+vc.table.begin.empty=Missing date
+vc.table.begin.error=Wrong format
+vc.table.description=Description
+vc.table.description.empty=Missing description
+vc.table.delete=-
+vc.table.duration=Duration
+vc.table.duration.empty=Missing duration
+vc.table.duration.error=Wrong format
+vc.table.duration.example=hh\:mm
+vc.table.empty=There are no meetings planned, yet.
+vc.table.end=End
+vc.table.intro=List of currently planned meetings:
+vc.table.title=Title
+vc.table.title.empty=Missing title
+vc.template.choose.intro=Template for virtual classroom
+vc.template.choose.label=Template
+vc.template.empty=No templates available
+vc.options=Access authorisation
+vc.options.intro=Access authorisation
+vc.options.label=Access authorisation
+
+chelp.ced-vc-config.title=Configure virtual classroom
+chelp.hover.vc.config=Help about configuration of the virtual classroom
+chelp.vc1=Create a virtual classroom for online communication (presentations, discussions, whiteboard, desktop-sharing etc.) with your course participants. Every course element is linked to exactly one virtual classroom. Choose pre-configurations and define dates for meetings. The classroom will not be automatically opened when creating the course element, but refers to its configuration and has to be opened by the moderator or participant .
+chelp.vc2=<b>Template for virtual classroom:</b> The given templates result in different pre-configurations for the classroom.
+chelp.vc3=<b>Dates for meetings:</b> Define a random number of dates when the classroom shall be opened for meetings and can be entered by participants.
+#</OLATCE-103 OLATCE-619>
\ No newline at end of file
diff --git a/src/main/java/de/bps/course/nodes/vc/_spring/buildingblockContext.xml b/src/main/java/de/bps/course/nodes/vc/_spring/buildingblockContext.xml
new file mode 100644
index 0000000000000000000000000000000000000000..3dc11d6eb8da55870aa4fc727c07adcf28ce5fd4
--- /dev/null
+++ b/src/main/java/de/bps/course/nodes/vc/_spring/buildingblockContext.xml
@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<beans xmlns="http://www.springframework.org/schema/beans"
+ xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+ xmlns:context="http://www.springframework.org/schema/context"
+ xsi:schemaLocation="
+ http://www.springframework.org/schema/beans
+ http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
+ http://www.springframework.org/schema/context
+ http://www.springframework.org/schema/context/spring-context-3.0.xsd">
+
+ <context:property-placeholder location="classpath:serviceconfig/olat.properties, classpath:olat.local.properties" />
+
+ <bean id="vc" class="de.bps.course.nodes.vc.VCCourseNodeConfiguration" scope="prototype">
+ <property name="enabled" value="${course.node.vc.enabled}" />
+ <property name="order" value="300" />
+ </bean>
+
+</beans>
\ No newline at end of file
diff --git a/src/main/java/de/bps/course/nodes/vc/_spring/vcContext.xml b/src/main/java/de/bps/course/nodes/vc/_spring/vcContext.xml
new file mode 100644
index 0000000000000000000000000000000000000000..1e870af095aac697ad3e62b4aeb0fe624fc55797
--- /dev/null
+++ b/src/main/java/de/bps/course/nodes/vc/_spring/vcContext.xml
@@ -0,0 +1,89 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<beans xmlns="http://www.springframework.org/schema/beans"
+ xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+ xmlns:context="http://www.springframework.org/schema/context"
+ xsi:schemaLocation="
+ http://www.springframework.org/schema/beans
+ http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
+ http://www.springframework.org/schema/context
+ http://www.springframework.org/schema/context/spring-context-3.0.xsd">
+
+<context:property-placeholder location="classpath:serviceconfig/olat.properties, classpath:olat.local.properties" />
+<context:annotation-config />
+
+<!-- ####################################### -->
+<!-- # VIRTUAL CLASSROOM SERVICE PROVIDERS # -->
+<!-- ####################################### -->
+
+ <!-- Activation of the providers -->
+ <bean id="vcProviderFactory" class="de.bps.course.nodes.vc.provider.VCProviderFactory" scope="singleton">
+ <property name="registeredProviders">
+ <list value-type="de.bps.course.nodes.vc.provider.VCProvider">
+ <ref bean="adobeProvider" />
+ <ref bean="wimbaProvider" />
+ </list>
+ </property>
+ </bean>
+
+ <!-- Definition of the providers -->
+ <bean id="wimbaProvider" class="de.bps.course.nodes.vc.provider.wimba.WimbaClassroomProvider">
+ <property name="enabled" value="${vc.winba.enabled}" />
+ <property name="providerId" value="wimba" />
+ <property name="displayName" value="Wimba Classroom" />
+ <property name="protocol" value="${vc.winba.protocol}" />
+ <property name="port" value="${vc.winba.port}" />
+ <property name="baseUrl" value="${vc.winba.baseurl}" />
+ <property name="adminLogin" value="${vc.winba.adminlogin}" />
+ <property name="adminPassword" value="${vc.winba.adminpassword}" />
+ <!-- Options -->
+ <property name="defaultConfig">
+ <ref bean="wimbaDefaultConfig" />
+ </property>
+ </bean>
+
+ <bean id="adobeProvider" class="de.bps.course.nodes.vc.provider.adobe.AdobeConnectProvider">
+ <property name="enabled" value="${vc.adobe.enabled}" />
+ <property name="providerId" value="adobe" />
+ <property name="displayName" value="Adobe Connect" />
+ <property name="protocol" value="${vc.adobe.protocol}" />
+ <property name="port" value="${vc.adobe.port}" />
+ <property name="baseUrl" value="${vc.adobe.baseurl}" />
+ <property name="adminLogin" value="${vc.adobe.adminlogin}" />
+ <property name="adminPassword" value="${vc.adobe.adminpassword}" />
+ <property name="accountId" value="${vc.adobe.accountid}" />
+ <property name="templates"><!-- optional -->
+ <map key-type="java.lang.String" value-type="java.lang.String">
+ <entry value="Standardmeetingvorlage" key="4711" />
+ </map>
+ </property>
+ <property name="showOptions" value="${vc.adobe.showoptions}" />
+ <!-- type of user accounts, allowed values are: guest, user -->
+ <property name="userType" value="${vc.adobe.usertype}" />
+ <!-- Options -->
+ <property name="defaultConfig">
+ <ref bean="adobeDefaultConfig" />
+ </property>
+ </bean>
+
+<!-- ################################## -->
+<!-- # VIRTUAL CLASSROOM SERVICE JOBS # -->
+<!-- ################################## -->
+ <bean id="adobeCleanupJob" class="org.springframework.scheduling.quartz.CronTriggerBean">
+ <property name="jobDetail">
+ <bean class="org.springframework.scheduling.quartz.JobDetailBean">
+ <property name="jobClass" value="de.bps.course.nodes.vc.provider.adobe.AdobeConnectCleanupJob" />
+ <property name="jobDataAsMap">
+ <map>
+ <entry key="providerId" value="adobe" />
+ <entry key="daysToKeep" value="1" />
+ <entry key="cleanupMeetings" value="true" />
+ <entry key="cleanupModerators" value="false" />
+ </map>
+ </property>
+ </bean>
+ </property>
+ <property name="cronExpression" value="0 0 2 * * ?"/><!-- 2am, daily -->
+ <property name="startDelay" value="45000" />
+ </bean>
+
+</beans>
\ No newline at end of file
diff --git a/src/main/java/de/bps/course/nodes/vc/provider/VCProvider.java b/src/main/java/de/bps/course/nodes/vc/provider/VCProvider.java
new file mode 100644
index 0000000000000000000000000000000000000000..e540693c1ade1833b4c84a5be206638b106eb592
--- /dev/null
+++ b/src/main/java/de/bps/course/nodes/vc/provider/VCProvider.java
@@ -0,0 +1,191 @@
+//<OLATCE-103>
+/**
+ *
+ * BPS Bildungsportal Sachsen GmbH<br>
+ * Bahnhofstrasse 6<br>
+ * 09111 Chemnitz<br>
+ * Germany<br>
+ *
+ * Copyright (c) 2005-2010 by BPS Bildungsportal Sachsen GmbH<br>
+ * http://www.bps-system.de<br>
+ *
+ * All rights reserved.
+ */
+package de.bps.course.nodes.vc.provider;
+
+import java.net.URL;
+import java.util.Date;
+import java.util.Map;
+
+import org.olat.core.configuration.ConfigOnOff;
+import org.olat.core.gui.UserRequest;
+import org.olat.core.gui.control.Controller;
+import org.olat.core.gui.control.WindowControl;
+import org.olat.core.id.Identity;
+
+import de.bps.course.nodes.vc.VCConfiguration;
+
+/**
+ *
+ * Description:<br>
+ * Interface defines the API a virtual classroom provider has to provide. It is designed
+ * to have an own instance for every single user.
+ *
+ * <P>
+ * Initial Date: 09.12.2010 <br>
+ * @author skoeber
+ */
+public interface VCProvider extends ConfigOnOff {
+
+ /**
+ * @return new independent instance of the provider
+ */
+ public VCProvider newInstance();
+
+ /**
+ * @return provider id as defined in the configuration
+ */
+ public String getProviderId();
+
+ /**
+ * @return display name of the provider
+ */
+ public String getDisplayName();
+
+ /**
+ * @return mapping of key and displayname for available templates or empty map, but never <code>null</code>
+ */
+ public Map<String, String> getTemplates();
+
+ /**
+ * @return <code>true</code> if virtual classroom is available at present, <code>false</code> otherwise
+ */
+ public boolean isProviderAvailable();
+
+ /**
+ * Create a new virtual classroom to be used e.g. in a course node
+ * @param roomId (maybe prefixed automatically)
+ * @param name (optional name for meeting)
+ * @param description (optional description for meeting)
+ * @param begin (usage dependent on target platform, can be NULL)
+ * @param end (usage dependent on target platform, can be NULL)
+ * @param templateId
+ * @return success
+ */
+ public boolean createClassroom(String roomId, String name, String description, Date begin, Date end, VCConfiguration config);
+
+ /**
+ * Update an existing virtual classroom
+ * @param roomId of the existing classroom
+ * @param name the new name
+ * @param description the new description
+ * @param begin the new begin
+ * @param end the new end
+ * @param config the new configuration
+ * @return success
+ */
+ public boolean updateClassroom(String roomId, String name, String description, Date begin, Date end, VCConfiguration config);
+
+ /**
+ * Delete an existing virtual classroom
+ * @param roomId
+ * @param config
+ * @return success
+ */
+ public boolean removeClassroom(String roomId, VCConfiguration config);
+
+ /**
+ * Create user specific access url for the virtual classroom. Maybe the user
+ * must authenticated before.
+ * @param roomId
+ * @param identity
+ * @param config
+ * @return url
+ */
+ public URL createClassroomUrl(String roomId, Identity identity, VCConfiguration config);
+
+ /**
+ * Create guest access url for the virtual classroom. Dependent on the
+ * implementation the url can be user specific (e.g. to pre-set the username)
+ * @param roomId
+ * @param identity
+ * @param config
+ * @return url
+ */
+ public URL createClassroomGuestUrl(String roomId, Identity identity, VCConfiguration config);
+
+ /**
+ * Check whether the virtual classroom exists or not.
+ * @param roomId
+ * @param config
+ * @return <code>true</code> if the classroom exists, <code>false</code> otherwise
+ */
+ public boolean existsClassroom(String roomId, VCConfiguration config);
+
+ /**
+ * Login the user. Dependent on the implemenation the password can be <code>null</code>.
+ * If this is the case, the implementation can try to login automatically generated
+ * users with a default password or a password that's build up by a rule.
+ * @param identity
+ * @param password
+ * @return success
+ */
+ public boolean login(Identity identity, String password);
+
+ /**
+ * Create a new user. The user has moderator rights. If the user already exists,
+ * nothing is to do.
+ * @param identity
+ * @param roomId
+ * @return success
+ */
+ public boolean createModerator(Identity identity, String roomId);
+
+ /**
+ * Create a new user. The user has no specific rights. If the user already exists,
+ * nothing is to do.
+ * @param identity
+ * @param roomId
+ * @return success
+ */
+ public boolean createUser(Identity identity, String roomId);
+
+ /**
+ * Create a new guest. Dependent on the implementation the user must not be persistent.
+ * @param identity
+ * @param roomId
+ * @return success
+ */
+ public boolean createGuest(Identity identity, String roomId);
+
+ /**
+ * Create controller for using the virtual classroom.
+ * @param ureq
+ * @param wControl
+ * @param roomId
+ * @param name
+ * @param description
+ * @param isModerator
+ * @param config
+ * @return the controller to be embedded
+ */
+ public Controller createDisplayController(UserRequest ureq, WindowControl wControl, String roomId, String name, String description, boolean isModerator, VCConfiguration config);
+
+ /**
+ * Create controller for creation and configuration of the virtual classroom.
+ * @param ureq
+ * @param wControl
+ * @param roomId
+ * @param config
+ * @return the controller to be embedded
+ */
+ public Controller createConfigController(UserRequest ureq, WindowControl wControl, String roomId, VCConfiguration config);
+
+ /**
+ * Create a new default configuration. This configuration must reflect all
+ * necessary settings to ensure that the virtual classroom will work.
+ * @return new configuration
+ */
+ public VCConfiguration createNewConfiguration();
+}
+//</OLATCE-103>
\ No newline at end of file
diff --git a/src/main/java/de/bps/course/nodes/vc/provider/VCProviderFactory.java b/src/main/java/de/bps/course/nodes/vc/provider/VCProviderFactory.java
new file mode 100644
index 0000000000000000000000000000000000000000..6984869bf37f5b52f8faefb4016ad7d2b4de3740
--- /dev/null
+++ b/src/main/java/de/bps/course/nodes/vc/provider/VCProviderFactory.java
@@ -0,0 +1,81 @@
+//<OLATCE-103>
+/**
+ *
+ * BPS Bildungsportal Sachsen GmbH<br>
+ * Bahnhofstrasse 6<br>
+ * 09111 Chemnitz<br>
+ * Germany<br>
+ *
+ * Copyright (c) 2005-2010 by BPS Bildungsportal Sachsen GmbH<br>
+ * http://www.bps-system.de<br>
+ *
+ * All rights reserved.
+ */
+package de.bps.course.nodes.vc.provider;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ *
+ * Description:<br>
+ * Factory to create an instance of a registered virtual classroom provider. Note that
+ * the providers are designed to be used as own instances for every single user.
+ *
+ * <P>
+ * Initial Date: 09.12.2010 <br>
+ * @author skoeber
+ */
+public class VCProviderFactory {
+
+ public static String VC_PROVIDER = "vcProvider";
+
+ private final static Map<String, VCProvider> _registeredProviders = new HashMap<String, VCProvider>();
+
+ public static VCProvider createProvider(String providerId) {
+ return _registeredProviders.get(providerId).newInstance();
+ }
+
+ public static VCProvider createDefaultProvider() {
+ if(_registeredProviders == null || _registeredProviders.isEmpty()) {
+ return null;
+ }
+ String providerId = _registeredProviders.keySet().iterator().next();
+ return createProvider(providerId);
+ }
+
+ public static boolean existsProvider(String providerId) {
+ return _registeredProviders.containsKey(providerId);
+ }
+
+ public static void registerProvider(VCProvider provider) {
+ _registeredProviders.put(provider.getProviderId(), provider);
+ }
+
+ public static void setRegisteredProviders(List<VCProvider> providers) {
+ for(VCProvider provider : providers) {
+ registerProvider(provider);
+ }
+ }
+
+ public static List<VCProvider> getProviders() {
+ List<VCProvider> providers = new ArrayList<VCProvider>();
+ for(VCProvider provider:_registeredProviders.values()) {
+ if(provider.isEnabled()) {
+ providers.add(provider);
+ }
+ }
+ return providers;
+ }
+
+ /** used by spring */
+ public List<VCProvider> getRegisteredProviders() {
+ List<VCProvider> providers = new ArrayList<VCProvider>();
+ providers.addAll(_registeredProviders.values());
+ return providers;
+ }
+
+}
+//</OLATCE-103>
\ No newline at end of file
diff --git a/src/main/java/de/bps/course/nodes/vc/provider/adobe/AdobeConfigController.java b/src/main/java/de/bps/course/nodes/vc/provider/adobe/AdobeConfigController.java
new file mode 100644
index 0000000000000000000000000000000000000000..258ada4fa91abfd8e0543d8e6015ca7ce1f0ab71
--- /dev/null
+++ b/src/main/java/de/bps/course/nodes/vc/provider/adobe/AdobeConfigController.java
@@ -0,0 +1,71 @@
+// <OLATCE-103>
+/**
+ *
+ * BPS Bildungsportal Sachsen GmbH<br>
+ * Bahnhofstrasse 6<br>
+ * 09111 Chemnitz<br>
+ * Germany<br>
+ *
+ * Copyright (c) 2005-2010 by BPS Bildungsportal Sachsen GmbH<br>
+ * http://www.bps-system.de<br>
+ *
+ * All rights reserved.
+ */
+package de.bps.course.nodes.vc.provider.adobe;
+
+import org.olat.core.gui.UserRequest;
+import org.olat.core.gui.components.Component;
+import org.olat.core.gui.components.velocity.VelocityContainer;
+import org.olat.core.gui.control.Controller;
+import org.olat.core.gui.control.Event;
+import org.olat.core.gui.control.WindowControl;
+import org.olat.core.gui.control.controller.BasicController;
+
+/**
+ *
+ * Description:<br>
+ * Config controller for Adobe Connect implementation
+ *
+ * <P>
+ * Initial Date: 05.01.2011 <br>
+ * @author skoeber
+ */
+public class AdobeConfigController extends BasicController {
+
+ private VelocityContainer editVC;
+ private AdobeEditForm editForm;
+
+ protected AdobeConfigController(UserRequest ureq, WindowControl wControl, String roomId, AdobeConnectProvider adobe, AdobeConnectConfiguration config) {
+ super(ureq, wControl);
+
+ this.editForm = new AdobeEditForm(ureq, wControl, adobe.isShowOptions(), config);
+ listenTo(editForm);
+
+ editVC = createVelocityContainer("edit");
+ editVC.put("editForm", editForm.getInitialComponent());
+
+ putInitialPanel(editVC);
+ }
+
+ @Override
+ protected void event(UserRequest ureq, Component source, Event event) {
+ // nothing to do
+ }
+
+ @Override
+ protected void event(UserRequest ureq, Controller source, Event event) {
+ if(source == editForm) {
+ fireEvent(ureq, event);
+ }
+ }
+
+ @Override
+ protected void doDispose() {
+ if (editForm != null) {
+ removeAsListenerAndDispose(editForm);
+ editForm = null;
+ }
+ }
+
+}
+// </OLATCE-103>
\ No newline at end of file
diff --git a/src/main/java/de/bps/course/nodes/vc/provider/adobe/AdobeConnectCleanupJob.java b/src/main/java/de/bps/course/nodes/vc/provider/adobe/AdobeConnectCleanupJob.java
new file mode 100644
index 0000000000000000000000000000000000000000..48488a05f5a9328bb31a298e14fda550d1a8a80e
--- /dev/null
+++ b/src/main/java/de/bps/course/nodes/vc/provider/adobe/AdobeConnectCleanupJob.java
@@ -0,0 +1,169 @@
+//<OLATCE-103>
+/**
+ *
+ * BPS Bildungsportal Sachsen GmbH<br>
+ * Bahnhofstrasse 6<br>
+ * 09111 Chemnitz<br>
+ * Germany<br>
+ *
+ * Copyright (c) 2005-2011 by BPS Bildungsportal Sachsen GmbH<br>
+ * http://www.bps-system.de<br>
+ *
+ * All rights reserved.
+ */
+package de.bps.course.nodes.vc.provider.adobe;
+
+import java.util.Date;
+import java.util.List;
+
+import org.olat.core.logging.OLog;
+import org.olat.core.logging.Tracing;
+import org.olat.course.CourseFactory;
+import org.olat.course.ICourse;
+import org.olat.course.nodes.CourseNode;
+import org.quartz.JobExecutionContext;
+import org.quartz.JobExecutionException;
+import org.springframework.scheduling.quartz.QuartzJobBean;
+
+import de.bps.course.nodes.VCCourseNode;
+import de.bps.course.nodes.vc.MeetingDate;
+import de.bps.course.nodes.vc.provider.VCProviderFactory;
+
+/**
+ *
+ * Description:<br>
+ * Cleanup unused Adobe Connect ressources:<br/>
+ * - unused meetings<br/>
+ * - temporary guest users
+ *
+ * <P>
+ * Initial Date: 04.01.2011 <br>
+ * @author skoeber
+ */
+public class AdobeConnectCleanupJob extends QuartzJobBean {
+
+ private OLog logger = Tracing.createLoggerFor(AdobeConnectCleanupJob.class);
+
+ private String providerId;
+ private boolean cleanupMeetings, cleanupModerators;
+ private int daysToKeep;
+
+ @Override
+ protected void executeInternal(JobExecutionContext context) throws JobExecutionException {
+ AdobeConnectProvider adobe = null;
+
+ boolean success = VCProviderFactory.existsProvider(providerId);
+ if(!success) return;//same as dummy job
+
+ try {
+ adobe = (AdobeConnectProvider) VCProviderFactory.createProvider(providerId);
+ } catch(ClassCastException e) {
+ throw new JobExecutionException("Invalid configuration: defined a virtual classroom cleanup job and provider implementation doesn't fit");
+ }
+
+ success = adobe.isProviderAvailable() && adobe.isEnabled();
+ if(!success) {
+ logger.debug("Tried to cleanup Adobe Connect meetings but it's actually not available");
+ return;
+ }
+
+ /*
+ * the concrete jobs
+ */
+ // cleanup unused meetings
+ if(cleanupMeetings) {
+ logger.info("Start cleaning unused Adobe Connect meetings");
+ cleanupMeetings(adobe, daysToKeep);
+ }
+ // cleanup unused moderator guest accounts
+ if(cleanupModerators) {
+ logger.info("Start cleaning unused Adobe Connect moderator guest accounts");
+ cleanupModerators(adobe);
+ }
+ }
+
+ /**
+ * @param adobe
+ */
+ protected void cleanupMeetings(AdobeConnectProvider adobe, int daysToKeep) {
+ boolean success = false;
+
+ Date lowerLimit = new Date((new Date()).getTime() - (daysToKeep * 24*60*60*1000));
+
+ // search all virtual classrooms with the used prefix
+ List<String> roomIds = adobe.findClassrooms(AdobeConnectProvider.PREFIX);
+ for(String roomId : roomIds) {
+ // format is olat-courseId-nodeId, e.g. olat-82823405537032-82823405537043
+ // load course and node
+ String courseId = roomId.split("-")[1];
+ String nodeId = roomId.split("-")[2];
+ ICourse course = CourseFactory.loadCourse(Long.parseLong(courseId));
+ CourseNode vcNode = course.getRunStructure().getNode(nodeId);
+ if(!(vcNode instanceof VCCourseNode)) {
+ logger.warn("Tried to cleanup Adobe Connect meeting for a non Adobe Connect course node: " + roomId);
+ continue;
+ }
+ AdobeConnectConfiguration config = (AdobeConnectConfiguration) vcNode.getModuleConfiguration().get(VCCourseNode.CONF_VC_CONFIGURATION);
+ if(config == null) {
+ // invalid configuration, do nothing and continue
+ continue;
+ }
+
+ boolean keep = false;
+ for(MeetingDate date : config.getMeetingDates()) {
+ if(keep) continue;
+ Date end = date.getEnd();
+ keep = lowerLimit.before(end);
+ }
+
+ // no planned date in the future, we can delete
+ // build the correct roomId
+ String toDelete = courseId + "-" + nodeId;
+ if(!keep) success = adobe.removeClassroom(toDelete, config);
+
+ if(!success) {
+ logger.warn("Error when cleaning up Adobe Connect meeting \"" + roomId + "\"");
+ continue;
+ }
+ }
+ }
+
+ protected void cleanupModerators(AdobeConnectProvider adobe) {
+// boolean success = false;
+// TODO implement
+ }
+
+ public String getProviderId() {
+ return providerId;
+ }
+
+ public void setProviderId(String providerId) {
+ this.providerId = providerId;
+ }
+
+ public int getDaysToKeep() {
+ return daysToKeep;
+ }
+
+ public void setDaysToKeep(int daysToKeep) {
+ this.daysToKeep = daysToKeep;
+ }
+
+ public void setCleanupMeetings(boolean cleanupMeetings) {
+ this.cleanupMeetings = cleanupMeetings;
+ }
+
+ public boolean isCleanupMeetings() {
+ return cleanupMeetings;
+ }
+
+ public void setCleanupModerators(boolean cleanupModerators) {
+ this.cleanupModerators = cleanupModerators;
+ }
+
+ public boolean isCleanupModerators() {
+ return cleanupModerators;
+ }
+
+}
+//</OLATCE-103>
\ No newline at end of file
diff --git a/src/main/java/de/bps/course/nodes/vc/provider/adobe/AdobeConnectConfiguration.java b/src/main/java/de/bps/course/nodes/vc/provider/adobe/AdobeConnectConfiguration.java
new file mode 100644
index 0000000000000000000000000000000000000000..ecccfed3f489cd55a3445a45af73e0b1760e9b9d
--- /dev/null
+++ b/src/main/java/de/bps/course/nodes/vc/provider/adobe/AdobeConnectConfiguration.java
@@ -0,0 +1,57 @@
+//<OLATCE-103>
+/**
+ *
+ * BPS Bildungsportal Sachsen GmbH<br>
+ * Bahnhofstrasse 6<br>
+ * 09111 Chemnitz<br>
+ * Germany<br>
+ *
+ * Copyright (c) 2005-2010 by BPS Bildungsportal Sachsen GmbH<br>
+ * http://www.bps-system.de<br>
+ *
+ * All rights reserved.
+ */
+package de.bps.course.nodes.vc.provider.adobe;
+
+import java.io.Serializable;
+
+import de.bps.course.nodes.vc.DefaultVCConfiguration;
+
+/**
+ *
+ * Description:<br>
+ * Configuration object for Adobe Connect
+ *
+ * <P>
+ * Initial Date: 20.12.2010 <br>
+ * @author skoeber
+ */
+public class AdobeConnectConfiguration extends DefaultVCConfiguration implements Serializable {
+
+ private boolean guestAccessAllowed;
+ private boolean guestStartMeetingAllowed;
+
+ public boolean isGuestAccessAllowed() {
+ return guestAccessAllowed;
+ }
+ public void setGuestAccessAllowed(boolean guestAccessAllowed) {
+ this.guestAccessAllowed = guestAccessAllowed;
+ }
+ public boolean isGuestStartMeetingAllowed() {
+ return guestStartMeetingAllowed;
+ }
+ public void setGuestStartMeetingAllowed(boolean guestStartMeetingAllowed) {
+ this.guestStartMeetingAllowed = guestStartMeetingAllowed;
+ }
+
+ @Override
+ public boolean isConfigValid() {
+ boolean valid = true;
+ if(isUseMeetingDates()) {
+ valid = getMeetingDates() != null && !getMeetingDates().isEmpty();
+ }
+ return valid;
+ }
+
+}
+//</OLATCE-103>
diff --git a/src/main/java/de/bps/course/nodes/vc/provider/adobe/AdobeConnectProvider.java b/src/main/java/de/bps/course/nodes/vc/provider/adobe/AdobeConnectProvider.java
new file mode 100644
index 0000000000000000000000000000000000000000..89b6ba1c8e5c150dce43d11d71f3b3e4c4d9776b
--- /dev/null
+++ b/src/main/java/de/bps/course/nodes/vc/provider/adobe/AdobeConnectProvider.java
@@ -0,0 +1,773 @@
+//<OLATCE-103>
+/**
+ *
+ * BPS Bildungsportal Sachsen GmbH<br>
+ * Bahnhofstrasse 6<br>
+ * 09111 Chemnitz<br>
+ * Germany<br>
+ *
+ * Copyright (c) 2005-2010 by BPS Bildungsportal Sachsen GmbH<br>
+ * http://www.bps-system.de<br>
+ *
+ * All rights reserved.
+ */
+package de.bps.course.nodes.vc.provider.adobe;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.StringReader;
+import java.net.MalformedURLException;
+import java.net.URI;
+import java.net.URL;
+import java.net.URLConnection;
+import java.text.SimpleDateFormat;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import javax.ws.rs.core.UriBuilder;
+import javax.xml.namespace.QName;
+import javax.xml.parsers.DocumentBuilder;
+import javax.xml.parsers.DocumentBuilderFactory;
+import javax.xml.parsers.ParserConfigurationException;
+import javax.xml.xpath.XPath;
+import javax.xml.xpath.XPathConstants;
+import javax.xml.xpath.XPathExpression;
+import javax.xml.xpath.XPathExpressionException;
+import javax.xml.xpath.XPathFactory;
+
+import org.apache.commons.lang.NotImplementedException;
+import org.olat.core.gui.UserRequest;
+import org.olat.core.gui.control.Controller;
+import org.olat.core.gui.control.WindowControl;
+import org.olat.core.helpers.Settings;
+import org.olat.core.id.Identity;
+import org.olat.core.id.UserConstants;
+import org.olat.core.logging.AssertException;
+import org.olat.core.logging.LogDelegator;
+import org.olat.core.util.Encoder;
+import org.w3c.dom.Document;
+import org.w3c.dom.Node;
+import org.w3c.dom.NodeList;
+import org.xml.sax.InputSource;
+import org.xml.sax.SAXException;
+
+import de.bps.course.nodes.vc.VCConfiguration;
+import de.bps.course.nodes.vc.provider.VCProvider;
+
+/**
+ *
+ * Description:<br>
+ * Virtual classroom provider for Adobe Connect.
+ *
+ * <P>
+ * Initial Date: 09.12.2010 <br>
+ * @author skoeber
+ */
+public class AdobeConnectProvider extends LogDelegator implements VCProvider {
+
+ private static final String CONTENT_TYPE = "application/x-www-form-urlencoded";
+ private static final String COOKIE = "BREEZESESSION=";
+ protected static final String PREFIX = "olat-";
+ private static final String DATE_FORMAT = "yyyy-MM-dd'T'HH:mm";
+
+ protected static String DEFAULT_TEMPLATE = "default";
+
+ // configuration
+ private static AdobeConnectConfiguration defaultConfig;
+ private boolean enabled;
+ private String providerId;
+ private String displayName;
+ private String protocol;
+ private int port;
+ private String baseUrl;
+ private String adminLogin;
+ private String adminPassword;
+ private String accountId;
+ private Map<String, String> templates;
+ private boolean guestAccessAllowedDefault;
+ private boolean guestStartMeetingAllowedDefault;
+ private boolean useMeetingDatesDefault;
+ private boolean showOptions;
+ private String userType;
+
+ // runtime data
+ private String cookie;
+
+ /**
+ * Constructor for internal use to create new instance
+ * @param providerId
+ * @param protocol
+ * @param port
+ * @param baseUrl
+ * @param adminLogin
+ * @param adminPassword
+ */
+ private AdobeConnectProvider(String providerId, String displayName, String protocol, int port, String baseUrl, String adminLogin, String adminPassword,
+ String accountId, Map<String, String> templates, boolean guestAccessAllowedDefault, boolean guestStartMeetingAllowedDefault,
+ boolean showOptions, String userType) {
+ setProviderId(providerId);
+ setDisplayName(displayName);
+ setProtocol(protocol);
+ setPort(port);
+ setBaseUrl(baseUrl);
+ setAdminLogin(adminLogin);
+ setAdminPassword(adminPassword);
+ setAccountId(accountId);
+ setTemplates(templates);
+ setGuestAccessAllowedDefault(guestAccessAllowedDefault);
+ setGuestStartMeetingAllowedDefault(guestStartMeetingAllowedDefault);
+ setShowOptions(showOptions);
+ setUserType(userType);
+ }
+
+ /**
+ * Public constructor, mostly used by spring<br/>
+ * <b>Important</b> when using: set configuration manually!
+ */
+ public AdobeConnectProvider() {
+ //
+ }
+
+ @Override
+ public boolean createClassroom(String roomId, String name, String description, Date begin, Date end, VCConfiguration config) {
+ if(existsClassroom(roomId, config)) return true;
+
+ if(!loginAdmin()) throw new AssertException("Cannot login to Adobe Connect. Please check module configuration and Adobe Connect connectivity.");
+
+ // begin and end can be NULL, see interface description
+ if(begin == null) begin = new Date();
+ if(end == null) end = new Date(begin.getTime() + 365*24*60*60*1000); // preset one year
+
+ // formatter for begin and end
+ SimpleDateFormat sd = new SimpleDateFormat(DATE_FORMAT);
+
+ // find my-meetings
+ Map<String, String> parameters = new HashMap<String, String>();
+ parameters.put("action", "sco-shortcuts");
+ Document responseDoc = getResponseDocument(sendRequest(parameters));
+ if(!evaluateOk(responseDoc)) return false;
+
+ String folderScoId = null;
+ // use my-meetings folder
+ String result = evaluate(responseDoc, "//sco[@type=\"my-meetings\"]");
+ if(result != null && !result.isEmpty()) {
+ folderScoId = evaluate(responseDoc, "//sco[@type=\"my-meetings\"]/attribute::sco-id");
+ }
+ // my-meetings folder not found, fallback to meetings
+ if(folderScoId == null) {
+ result = evaluate(responseDoc, "//sco[@type=\"meetings\"]");
+ if(result != null && !result.isEmpty()) {
+ folderScoId = evaluate(responseDoc, "//sco[@type=\"meetings\"]/attribute::sco-id");
+ }
+ }
+ // meetings folder not found, error case
+ if(folderScoId == null) return false;
+ // folder found where to insert the new meeting
+ // create new meeting
+ parameters = new HashMap<String, String>();
+ parameters.put("action", "sco-update");
+ parameters.put("type", "meeting");
+ parameters.put("name", PREFIX + roomId);
+ parameters.put("folder-id", folderScoId);
+ parameters.put("date-begin", sd.format(begin));
+ parameters.put("date-end", sd.format(end));
+ parameters.put("url-path", PREFIX + roomId);
+ String templateId = ((AdobeConnectConfiguration)config).getTemplateKey();
+ if(templateId != null && !templateId.equals(DEFAULT_TEMPLATE))
+ parameters.put("source-sco-id", templateId);
+ responseDoc = getResponseDocument(sendRequest(parameters));
+ if(!evaluateOk(responseDoc)) return false;
+
+ // adjust permissions
+ String meetingScoId = evaluate(responseDoc, "//sco/attribute::sco-id");
+ parameters.clear();
+ parameters.put("action", "permissions-update");
+ parameters.put("acl-id", meetingScoId);
+ parameters.put("principal-id", "public-access");
+ if(((AdobeConnectConfiguration)config).isGuestAccessAllowed())
+ parameters.put("permission-id", "view-hidden");
+ else
+ parameters.put("permission-id", "remove");
+ responseDoc = getResponseDocument(sendRequest(parameters));
+ if(!evaluateOk(responseDoc)) return false;
+
+ logout();
+ return true;
+ }
+
+ @Override
+ public boolean updateClassroom(String roomId, String name, String description, Date begin, Date end, VCConfiguration config) {
+ if(!existsClassroom(roomId, config)) return false;
+ if(!loginAdmin()) throw new AssertException("Cannot login to Adobe Connect. Please check module configuration and that Adobe Connect is available.");
+
+ String scoId = getScoIdFor(roomId);
+ if(scoId == null) return false;
+
+ // formatter for begin and end
+ SimpleDateFormat sd = new SimpleDateFormat(DATE_FORMAT);
+
+ Map<String, String> parameters = new HashMap<String, String>();
+ // update meeting configuration
+ parameters.put("action", "sco-update");
+ parameters.put("sco-id", scoId);
+ if(begin != null)
+ parameters.put("date-begin", sd.format(begin));
+ if(end != null)
+ parameters.put("date-end", sd.format(end));
+ String templateId = ((AdobeConnectConfiguration)config).getTemplateKey();
+ if(templateId != null && !templateId.equals(DEFAULT_TEMPLATE))
+ parameters.put("source-sco-id", templateId);
+ Document responseDoc = getResponseDocument(sendRequest(parameters));
+ if(!evaluateOk(responseDoc)) return false;
+
+ // adjust permissions
+ parameters.clear();
+ parameters.put("action", "permissions-update");
+ parameters.put("acl-id", scoId);
+ parameters.put("principal-id", "public-access");
+ if(((AdobeConnectConfiguration)config).isGuestAccessAllowed())
+ parameters.put("permission-id", "view-hidden");
+ else
+ parameters.put("permission-id", "remove");
+ responseDoc = getResponseDocument(sendRequest(parameters));
+ if(!evaluateOk(responseDoc)) return false;
+
+ logout();
+ return true;
+ }
+
+ @Override
+ public boolean removeClassroom(String roomId, VCConfiguration config) {
+ if(!existsClassroom(roomId, config)) return true;
+ if(!loginAdmin()) throw new AssertException("Cannot login to Adobe Connect. Please check module configuration and that Adobe Connect is available.");
+
+ String scoId = getScoIdFor(roomId);
+ Map<String, String> parameters = new HashMap<String, String>();
+ parameters.put("action", "sco-delete");
+ parameters.put("sco-id", scoId);
+ Document responseDoc = getResponseDocument(sendRequest(parameters));
+ if(!evaluateOk(responseDoc)) return false;
+
+ logout();
+ return true;
+ }
+
+ private String getScoIdFor(String roomId) {
+ Map<String, String> parameters = new HashMap<String, String>();
+ parameters.put("action", "sco-search-by-field");
+ parameters.put("query", PREFIX + roomId);
+ parameters.put("filter-type", "meeting");
+ Document responseDoc = getResponseDocument(sendRequest(parameters));
+ if(!evaluateOk(responseDoc)) return null;
+
+ Object result = evaluate(responseDoc, "//sco/url-path[text()='/" + PREFIX + roomId + "/']", XPathConstants.NODESET);
+ if(result == null) return null;
+ NodeList nodes = (NodeList) result;
+ if(nodes.getLength() == 1) {
+ String scoId = evaluate(responseDoc, "//sco[1]/attribute::sco-id");
+ return scoId;
+ }
+ else if(nodes.getLength() > 1)
+ throw new AssertException("More than one Adobe Connect room found for one course node!");
+ else
+ return null;
+ }
+
+ @Override
+ public URL createClassroomUrl(String roomId, Identity identity, VCConfiguration config) {
+ URL url = null;
+ URI uri = UriBuilder.fromUri(protocol + "://" + baseUrl).port(port)
+ .path(PREFIX + roomId).queryParam("session", cookie).build();
+ try {
+ url = uri.toURL();
+ } catch (MalformedURLException e) {
+ logWarn("Cannot create access URL to Adobe Connect meeting for id \"" + PREFIX + roomId + "\" and user \"" + identity.getName() + "\"", e);
+ }
+ return url;
+ }
+
+ @Override
+ public URL createClassroomGuestUrl(String roomId, Identity identity, VCConfiguration config) {
+ URL url = null;
+ URI uri = UriBuilder.fromUri(protocol + "://" + baseUrl).port(port)
+ .path(PREFIX + roomId).queryParam("guestName", identity.getName()).build();
+ try {
+ url = uri.toURL();
+ } catch (MalformedURLException e) {
+ logWarn("Cannot create access URL to Adobe Connect meeting for id \"" + PREFIX + roomId + "\" and user \"" + identity.getName() + "\"", e);
+ }
+ return url;
+ }
+
+ @Override
+ public boolean existsClassroom(String roomId, VCConfiguration config) {
+ if(!loginAdmin()) return false;
+ Map<String, String> parameters = new HashMap<String, String>();
+ parameters.put("action", "sco-search-by-field");
+ parameters.put("query", PREFIX + roomId);
+ parameters.put("filter-type", "meeting");
+ Document responseDoc = getResponseDocument(sendRequest(parameters));
+ if(!evaluateOk(responseDoc)) return false;
+
+ Object result = evaluate(responseDoc, "//sco/url-path[text()='/" + PREFIX + roomId + "/']", XPathConstants.NODESET);
+ logout();
+ if(result == null) return false;
+ NodeList nodes = (NodeList) result;
+ if(nodes.getLength() == 1)
+ return true;
+ else if(nodes.getLength() > 1)
+ throw new AssertException("More than one Adobe Connect room found for one course node!");
+ else
+ return false;
+ }
+
+ protected List<String> findClassrooms(String name) {
+ List<String> results = new ArrayList<String>();
+ if(!loginAdmin()) return results;
+ Map<String, String> parameters = new HashMap<String, String>();
+ parameters.put("action", "sco-search-by-field");
+ parameters.put("field", "name");
+ parameters.put("query", name);
+ parameters.put("filter-type", "meeting");
+ Document responseDoc = getResponseDocument(sendRequest(parameters));
+ if(!evaluateOk(responseDoc)) {
+ logError("Invalid response when searching for classrooms with the name \"" + name + "\"", null);
+ return results;
+ }
+
+ Object result = evaluate(responseDoc, "descendant-or-self::sco-search-by-field-info/child::sco/child::name", XPathConstants.NODESET);
+ logout();
+ if(result == null) if(isLogDebugEnabled()) logDebug("Search for Adobe Connect classrooms with name \"" + name + "\" with no results");
+ NodeList nodes = (NodeList) result;
+ for(int i=0; i<nodes.getLength(); i++) {
+ Node node = nodes.item(i);
+ String roomId = node.getFirstChild().getNodeValue();
+ results.add(roomId);
+ }
+
+ return results;
+ }
+
+ @Override
+ public boolean createModerator(Identity identity, String roomId) {
+ if(!loginAdmin()) return false;
+ Map<String, String> parameters = new HashMap<String, String>();
+ // create user
+ parameters.put("action", "principal-update");
+ parameters.put("first-name", identity.getUser().getProperty(UserConstants.FIRSTNAME, null));
+ parameters.put("last-name", identity.getUser().getProperty(UserConstants.LASTNAME, null));
+ parameters.put("login", PREFIX + identity.getName());
+ parameters.put("password", Encoder.encrypt(identity.getName() + "@" + Settings.getApplicationName()));
+ parameters.put("type", userType);
+ parameters.put("has-children", "false");
+ Document responseDoc = getResponseDocument(sendRequest(parameters));
+
+ if(!evaluateOk(responseDoc)) {
+ boolean exists = false;
+ String error = evaluate(responseDoc, "/results/status[1]/attribute::code");
+ if(error.equals("invalid")) {
+ error = evaluate(responseDoc, "/results[1]/status[1]/invalid/attribute::subcode");
+ exists = error.equals("duplicate");
+ }
+ if(!exists) return false;
+ }
+
+ // search the user
+ String principalId = getPrincipalIdFor(identity);
+ if(principalId == null) return false; // error case
+
+ // create permissions for the meeting
+ String scoId = getScoIdFor(roomId);
+ if(scoId == null) return false;
+ parameters.clear();
+ parameters.put("action", "permissions-update");
+ parameters.put("acl-id", scoId);
+ parameters.put("principal-id", principalId);
+ parameters.put("permission-id", "host");
+ String response = sendRequest(parameters);
+ responseDoc = getResponseDocument(response);
+ logout();
+
+ return evaluateOk(responseDoc);
+ }
+
+ @Override
+ public boolean createUser(Identity identity, String roomId) {
+ throw new NotImplementedException("method createUser not yet implemented");
+ }
+
+ @Override
+ public boolean createGuest(Identity identity, String roomId) {
+ throw new NotImplementedException("method createGuest not yet implemented");
+ }
+
+ @Override
+ public String getProviderId() {
+ return providerId;
+ }
+
+ @Override
+ public String getDisplayName() {
+ return displayName;
+ }
+
+ @Override
+ public VCProvider newInstance() {
+ AdobeConnectProvider newInstance = new AdobeConnectProvider(providerId, displayName, protocol, port, baseUrl, adminLogin, adminPassword, accountId, templates,
+ guestAccessAllowedDefault, guestStartMeetingAllowedDefault, showOptions, userType);
+ return newInstance;
+ }
+
+ @Override
+ public Controller createDisplayController(UserRequest ureq, WindowControl wControl, String roomId, String name, String description, boolean isModerator, VCConfiguration config) {
+ AdobeDisplayController displayCtr = new AdobeDisplayController(ureq, wControl, roomId, name, description, isModerator, (AdobeConnectConfiguration) config, this);
+ return displayCtr;
+ }
+
+ @Override
+ public Controller createConfigController(UserRequest ureq, WindowControl wControl, String roomId, VCConfiguration config) {
+ AdobeConfigController configCtr = new AdobeConfigController(ureq, wControl, roomId, this, (AdobeConnectConfiguration) config);
+ return configCtr;
+ }
+
+ @Override
+ public boolean login(Identity identity, String password) {
+ if(cookie == null) createCookie();
+ Map<String,String> parameters = new HashMap<String, String>();
+ parameters.put("action", "login");
+ if(accountId != null) parameters.put("account-id", accountId);
+ parameters.put("login", PREFIX + identity.getName());
+ parameters.put("password", Encoder.encrypt(identity.getName() + "@" + Settings.getApplicationName()));
+ Document responseDoc = getResponseDocument(sendRequest(parameters));
+
+ return evaluateOk(responseDoc);
+ }
+
+ private boolean loginAdmin() {
+ if(cookie == null) createCookie();
+ Map<String,String> parameters = new HashMap<String, String>();
+ parameters.put("action", "login");
+ if(accountId != null) parameters.put("account-id", accountId);
+ parameters.put("login", adminLogin);
+ parameters.put("password", adminPassword);
+ Document responseDoc = getResponseDocument(sendRequest(parameters));
+
+ return evaluateOk(responseDoc);
+ }
+
+ private boolean logout() {
+ if(cookie == null) return true;
+ Map<String,String> parameters = new HashMap<String, String>();
+ parameters.put("action", "logout");
+ Document responseDoc = getResponseDocument(sendRequest(parameters));
+ cookie = null;
+
+ return evaluateOk(responseDoc);
+ }
+
+ private boolean createCookie() {
+ Map<String, String> parameters = new HashMap<String, String>();
+ parameters.put("action", "common-info");
+ String response = sendRequest(parameters);
+
+ Document responseDoc = getResponseDocument(response);
+ boolean success = evaluateOk(responseDoc);
+ if (success) {
+ // get cookie
+ String result = evaluate(responseDoc, "/results/common[1]/cookie[1]/text()");
+ cookie = result;
+ }
+ return success;
+ }
+
+ private String getPrincipalIdFor(Identity identity) {
+ Map<String, String> parameters = new HashMap<String, String>();
+ parameters.put("action", "principal-list");
+ parameters.put("filter-type", userType);
+ parameters.put("filter-type", "user");
+ parameters.put("filter-login", PREFIX + identity.getName());
+ String response = sendRequest(parameters);
+
+ Document responseDoc = getResponseDocument(response);
+ boolean success = evaluateOk(responseDoc);
+ if(!success) return null;
+ // get principalId
+ NodeList nodes = (NodeList) evaluate(responseDoc, "//principal", XPathConstants.NODESET);
+ if(nodes == null) return null; // error case
+ if(nodes.getLength() == 1) {
+ String principalId = evaluate(responseDoc, "//principal[1]/attribute::principal-id");
+ return principalId;
+ } else if(nodes.getLength() > 1) {
+ throw new AssertException("Multiple Adobe Connect users with the same login name found: " + identity.getName());
+ } else return null;
+ }
+
+ private Document getResponseDocument(String response) {
+ DocumentBuilderFactory domFactory = DocumentBuilderFactory.newInstance();
+ domFactory.setNamespaceAware(true); // never forget this!
+ DocumentBuilder builder;
+ Document doc = null;
+ try {
+ builder = domFactory.newDocumentBuilder();
+ InputSource is = new InputSource(new StringReader(response));
+ doc = builder.parse(is);
+ } catch (ParserConfigurationException e) {
+ if(isLogDebugEnabled()) logDebug("Error while creating DOM parser.");
+ } catch (SAXException e) {
+ if(isLogDebugEnabled()) logDebug("Error while parsing result XML document.");
+ } catch (IOException e) {
+ if(isLogDebugEnabled()) logDebug("Error while reading response.");
+ }
+ return doc;
+ }
+
+ private boolean evaluateOk(Document responseDoc) {
+ String result = evaluate(responseDoc, "/results/status[1]/attribute::code");
+ if(result == null || result.isEmpty())
+ return false;
+ return result.equals("ok");
+ }
+
+ private String evaluate(Document responseDoc, String expression) {
+ Object result = evaluate(responseDoc, expression, XPathConstants.STRING);
+ if(result == null || !(result instanceof String))
+ return new String();
+ return (String)result;
+ }
+
+ private Object evaluate(Document responseDoc, String expression, QName type) {
+ if(responseDoc == null) return null;
+ XPathFactory factory = XPathFactory.newInstance();
+ XPath xpath = factory.newXPath();
+ XPathExpression expr;
+ Object result;
+ try {
+ expr = xpath.compile(expression);
+ result = expr.evaluate(responseDoc, type);
+ } catch (XPathExpressionException e) {
+ result = null;
+ }
+
+ return result;
+ }
+
+ private String sendRequest(Map<String, String> parameters) {
+ URL url = createRequestUrl(parameters);
+ URLConnection urlConn;
+
+ try {
+ urlConn = url.openConnection();
+ // setup url connection
+ urlConn.setDoOutput(true);
+ urlConn.setUseCaches(false);
+ // add content type
+ urlConn.setRequestProperty("Content-Type", CONTENT_TYPE);
+ // add cookie information
+ if(cookie != null) urlConn.setRequestProperty("Cookie", COOKIE + cookie);
+
+ // send request
+ urlConn.connect();
+
+ // read response
+ BufferedReader input = new BufferedReader(new InputStreamReader(urlConn.getInputStream()));
+ StringBuilder response= new StringBuilder();
+ String line;
+ while( (line = input.readLine()) != null ) response.append(line);
+ input.close();
+
+ if(isLogDebugEnabled()) {
+ logDebug("Requested URL: " + url);
+ logDebug("Response: " + response);
+ }
+
+ return response.toString();
+ } catch (IOException e) {
+ logError("Sending request to Adobe Connect failed. Request: " + url.toString(), e);
+ return "";
+ }
+ }
+
+ private URL createRequestUrl(Map<String, String> parameters) {
+ UriBuilder ubu = UriBuilder.fromUri(protocol + "://" + baseUrl).port(port).path("api").path("xml");
+
+ for(String key : parameters.keySet()) {
+ ubu.queryParam(key, parameters.get(key));
+ }
+
+ URL url = null;
+ try {
+ url = ubu.build().toURL();
+ } catch (Exception e) {
+ logWarn("Error while creating URL for Adobe Connect request.", e);
+ // try to build the URL in a naiv way below
+ }
+ if(url == null) {
+ // error case, try the naiv way
+ try {
+ StringBuilder sb = new StringBuilder(protocol + "://" + baseUrl + ":" + port + "/api/xml");
+ if(!parameters.isEmpty()) sb.append("?");
+ for(String key : parameters.keySet()) {
+ sb.append(key + "=" + parameters.get(key) + "&");
+ }
+ sb.replace(sb.length(), sb.length(), "");
+ url = new URL(sb.toString());
+ } catch (MalformedURLException e) {
+ logError("Error while creating URL for Adobe Connect request. Please check the configuration!", e);
+ }
+ }
+
+ return url;
+ }
+
+ @Override
+ public boolean isProviderAvailable() {
+ Map<String, String> parameters = new HashMap<String, String>();
+ parameters.put("action", "common-info");
+ Document responseDoc = getResponseDocument(sendRequest(parameters));
+
+ return evaluateOk(responseDoc);
+ }
+
+ @Override
+ public VCConfiguration createNewConfiguration() {
+ AdobeConnectConfiguration config = new AdobeConnectConfiguration();
+ config.setProviderId(providerId);
+ config.setGuestAccessAllowed(defaultConfig.isGuestAccessAllowed());
+ config.setGuestStartMeetingAllowed(defaultConfig.isGuestStartMeetingAllowed());
+ config.setUseMeetingDates(defaultConfig.isUseMeetingDates());
+ return config;
+ }
+
+ @Override
+ public Map<String, String> getTemplates() {
+ if(templates == null) templates = Collections.emptyMap();
+ return templates;
+ }
+
+ ////////////////////////////
+ // setters used by spring //
+ ////////////////////////////
+ public void setEnabled(boolean enabled) {
+ this.enabled = enabled;
+ }
+
+ public void setProviderId(String providerId) {
+ this.providerId = providerId;
+ }
+
+ public void setDisplayName(String displayName) {
+ this.displayName = displayName;
+ }
+
+ public void setProtocol(String protocol) {
+ this.protocol = protocol;
+ }
+
+ public void setPort(int port) {
+ this.port = port;
+ }
+
+ public void setBaseUrl(String baseUrl) {
+ this.baseUrl = baseUrl;
+ }
+
+ public void setAdminLogin(String adminLogin) {
+ this.adminLogin = adminLogin;
+ }
+
+ public void setAdminPassword(String adminPassword) {
+ this.adminPassword = adminPassword;
+ }
+
+ public void setAccountId(String accountId) {
+ this.accountId = accountId;
+ }
+
+ public void setTemplates(Map<String,String> templates) {
+ this.templates = templates;
+ }
+
+ public void setGuestAccessAllowedDefault(boolean guestAccessAllowedDefault) {
+ this.guestAccessAllowedDefault = guestAccessAllowedDefault;
+ }
+
+ public void setGuestStartMeetingAllowedDefault(boolean guestStartMeetingAllowedDefault) {
+ this.guestStartMeetingAllowedDefault = guestStartMeetingAllowedDefault;
+ }
+
+ public void setUseMeetingDatesDefault(boolean useMeetingDatesDefault) {
+ this.useMeetingDatesDefault = useMeetingDatesDefault;
+ }
+
+ public void setShowOptions(boolean showOptions) {
+ this.showOptions = showOptions;
+ }
+
+ public void setUserType(String userType) {
+ this.userType = userType;
+ }
+
+ public void setDefaultConfig(AdobeConnectConfiguration config) {
+ defaultConfig = config;
+ defaultConfig.setProviderId(providerId);
+ }
+
+ /////////////////////////////
+ // getters used internally //
+ /////////////////////////////
+ @Override
+ public boolean isEnabled() {
+ return enabled;
+ }
+
+ protected String getProtocol() {
+ return protocol;
+ }
+
+ protected int getPort() {
+ return port;
+ }
+
+ protected String getBaseUrl() {
+ return baseUrl;
+ }
+
+ protected String getAdminLogin() {
+ return adminLogin;
+ }
+
+ protected String getAdminPassword() {
+ return adminPassword;
+ }
+
+ protected String getAccountId() {
+ return accountId;
+ }
+
+ protected boolean isGuestAccessAllowedDefault() {
+ return guestAccessAllowedDefault;
+ }
+
+ protected boolean isGuestStartMeetingAllowedDefault() {
+ return guestStartMeetingAllowedDefault;
+ }
+
+ protected boolean isUseMeetingDatesDefault() {
+ return useMeetingDatesDefault;
+ }
+
+ protected boolean isShowOptions() {
+ return showOptions;
+ }
+
+ protected String getUserType() {
+ return userType;
+ }
+
+}
+//</OLATCE-103>
\ No newline at end of file
diff --git a/src/main/java/de/bps/course/nodes/vc/provider/adobe/AdobeDisplayController.java b/src/main/java/de/bps/course/nodes/vc/provider/adobe/AdobeDisplayController.java
new file mode 100644
index 0000000000000000000000000000000000000000..95d76fd43b47226b2cb4afe01a9c39572f2fa05e
--- /dev/null
+++ b/src/main/java/de/bps/course/nodes/vc/provider/adobe/AdobeDisplayController.java
@@ -0,0 +1,218 @@
+//<OLATCE-103>
+/**
+ *
+ * BPS Bildungsportal Sachsen GmbH<br>
+ * Bahnhofstrasse 6<br>
+ * 09111 Chemnitz<br>
+ * Germany<br>
+ *
+ * Copyright (c) 2005-2010 by BPS Bildungsportal Sachsen GmbH<br>
+ * http://www.bps-system.de<br>
+ *
+ * All rights reserved.
+ */
+package de.bps.course.nodes.vc.provider.adobe;
+
+import java.net.URL;
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.List;
+
+import org.olat.core.gui.UserRequest;
+import org.olat.core.gui.components.Component;
+import org.olat.core.gui.components.link.Link;
+import org.olat.core.gui.components.link.LinkFactory;
+import org.olat.core.gui.components.velocity.VelocityContainer;
+import org.olat.core.gui.control.Event;
+import org.olat.core.gui.control.WindowControl;
+import org.olat.core.gui.control.controller.BasicController;
+import org.olat.core.gui.media.RedirectMediaResource;
+
+import de.bps.course.nodes.vc.MeetingDate;
+import de.bps.course.nodes.vc.provider.VCProvider;
+
+/**
+ *
+ * Description:<br>
+ * Display controller for Adobe Connect implementation, mostly used as
+ * run controller in the course node.
+ *
+ * <P>
+ * Initial Date: 16.12.2010 <br>
+ * @author skoeber
+ */
+public class AdobeDisplayController extends BasicController {
+
+ private static String COMMAND_START_MEETING = "cmd.start.meeting";
+ private static String COMMAND_START_JOIN_MEETING = "cmd.start.join.meeting";
+ private static String COMMAND_JOIN_MODERATOR = "cmd.join.moderator";
+ private static String COMMAND_JOIN_LEARNER = "cmd.join.learner";
+ private static String COMMAND_REMOVE_MEETING = "cmd.remove.meeting";
+ private static String COMMAND_SYNC_MEETING = "cmd.sync.meeting";
+
+ // objects for run view
+ private VelocityContainer runVC;
+ private String roomId;
+ private Link startModerator, startJoinLearner, joinModerator, joinLearner;
+ private Link removeMeeting, updateMeeting;
+
+ // data
+ private List<MeetingDate> dateList = new ArrayList<MeetingDate>();
+ private AdobeConnectConfiguration config;
+ private MeetingDate meeting;
+ private Date allBegin, allEnd;
+
+ private VCProvider adobe;
+
+ public AdobeDisplayController(UserRequest ureq, WindowControl wControl, String roomId, String name, String description, boolean isModerator, AdobeConnectConfiguration config, VCProvider provider) {
+ super(ureq, wControl);
+ this.roomId = roomId;
+ this.adobe = provider;
+ this.config = config;
+
+ // The dates Table to the Course odes
+ if(config.getMeetingDates() != null) dateList.addAll(config.getMeetingDates());
+
+ // select actual meeting
+ if(config.isUseMeetingDates()) {
+ Date now = new Date((new Date()).getTime() + 15*60*1000); // allow to start meetings about 15 minutes before begin
+ for(MeetingDate date : dateList) {
+ Date begin = date.getBegin();
+ Date end = date.getEnd();
+ if(now.after(begin) & now.before(end)) {
+ meeting = date;
+ }
+ allBegin = allBegin == null ? begin : begin.before(allBegin) ? begin : allBegin;
+ allEnd = allEnd == null ? end : end.after(allEnd) ? end : allEnd;
+ }
+ } else {
+ allBegin = new Date();
+ allEnd = new Date(allBegin.getTime() + 365*24*60*60*1000); // preset one year
+ meeting = new MeetingDate();
+ meeting.setBegin(allBegin);
+ meeting.setEnd(allEnd);
+ meeting.setTitle(name);
+ meeting.setDescription(description);
+ }
+
+ runVC = createVelocityContainer("run");
+
+ startModerator = LinkFactory.createButton(COMMAND_START_MEETING, runVC, this);
+ startJoinLearner = LinkFactory.createButton(COMMAND_START_JOIN_MEETING, runVC, this);
+ joinLearner = LinkFactory.createButton(COMMAND_JOIN_LEARNER, runVC, this);
+ joinModerator = LinkFactory.createButton(COMMAND_JOIN_MODERATOR, runVC, this);
+ removeMeeting = LinkFactory.createButton(COMMAND_REMOVE_MEETING, runVC, this);
+ updateMeeting = LinkFactory.createButton(COMMAND_SYNC_MEETING, runVC, this);
+ // set target to be able to open new browser window on event
+ startJoinLearner.setTarget("_blank");
+ joinLearner.setTarget("_blank");
+ joinModerator.setTarget("_blank");
+ // render the right button
+ boolean isUseDates = config.isUseMeetingDates();
+ boolean isMeeting = !isUseDates | meeting != null;
+ boolean exists = adobe.existsClassroom(roomId, config);
+ boolean guestCanStart = config.isGuestStartMeetingAllowed();
+ runVC.contextPut("isModerator", isModerator);
+ runVC.contextPut("exists", exists);
+ runVC.contextPut("guestCanStart", guestCanStart);
+ runVC.contextPut("useDates", isUseDates);
+ joinLearner.setEnabled(isMeeting & exists);
+
+ putInitialPanel(runVC);
+ }
+
+ @Override
+ protected void event(UserRequest ureq, Component source, Event event) {
+ if(source == startModerator) {
+ /*
+ * create new meeting room and prepare to join it
+ */
+ boolean success = adobe.createClassroom(roomId, null, null, allBegin, allEnd, config);
+ if(success) {
+ runVC.contextPut("exists", true);
+ runVC.setDirty(true);
+ } else {
+ getWindowControl().setError(translate("error.create.room"));
+ }
+ } else if(source == startJoinLearner) {
+ /*
+ * create new meeting room and join immediately as guest
+ */
+ boolean success = adobe.createClassroom(roomId, null, null, allBegin, allEnd, config);
+ if(success) {
+ runVC.contextPut("exists", true);
+ runVC.setDirty(true);
+ // join meeting as guest
+ URL url = adobe.createClassroomGuestUrl(roomId, ureq.getIdentity(), config);
+ RedirectMediaResource rmr = new RedirectMediaResource(url.toString());
+ ureq.getDispatchResult().setResultingMediaResource(rmr);
+ return;
+ } else {
+ getWindowControl().setError(translate("error.create.room"));
+ }
+ } else if(source == joinLearner) {
+ /*
+ * easiest case: simply generate link to join meeting as guest
+ */
+ URL url = adobe.createClassroomGuestUrl(roomId, ureq.getIdentity(), config);
+ RedirectMediaResource rmr = new RedirectMediaResource(url.toString());
+ ureq.getDispatchResult().setResultingMediaResource(rmr);
+ return;
+ } else if(source == joinModerator) {
+ /*
+ * join meeting as moderator, first prepare user to have appropriate rights
+ */
+ boolean success = adobe.existsClassroom(roomId, config);
+ // update rights for user to moderate meeting
+ if(success) {
+ success = adobe.createModerator(ureq.getIdentity(), roomId);
+ } else {
+ // room not found, should not appear
+ getWindowControl().setError(translate("error.no.room"));
+ return;
+ }
+ // login the user as moderator
+ if(success) {
+ success = adobe.login(ureq.getIdentity(), null);
+ } else {
+ // could not create moderator or update the rights
+ getWindowControl().setError(translate("error.update.rights"));
+ return;
+ }
+ // redirect to the meeting
+ if(success) {
+ URL url = adobe.createClassroomUrl(roomId, ureq.getIdentity(), config);
+ RedirectMediaResource rmr = new RedirectMediaResource(url.toString());
+ ureq.getDispatchResult().setResultingMediaResource(rmr);
+ } else {
+ // login failed
+ getWindowControl().setError(translate("error.no.login"));
+ return;
+ }
+ return;
+ } else if(source == removeMeeting) {
+ boolean success = adobe.removeClassroom(roomId, config);
+ if(success) {
+ runVC.contextPut("exists", false);
+ runVC.setDirty(true);
+ } else {
+ // removing failed
+ getWindowControl().setError(translate("error.remove.room"));
+ }
+ } else if(source == updateMeeting) {
+ boolean success = adobe.updateClassroom(roomId, null, null, allBegin, allEnd, config);
+ if(success) {
+ getWindowControl().setInfo(translate("success.update.room"));
+ } else {
+ // update failed
+ getWindowControl().setError(translate("error.update.room"));
+ }
+ }
+ }
+
+ @Override
+ protected void doDispose() {
+ // nothing to dispose
+ }
+}
+//</OLATCE-103>
\ No newline at end of file
diff --git a/src/main/java/de/bps/course/nodes/vc/provider/adobe/AdobeEditForm.java b/src/main/java/de/bps/course/nodes/vc/provider/adobe/AdobeEditForm.java
new file mode 100644
index 0000000000000000000000000000000000000000..bb382203f07e238ee8bfabe1c1fb23cd5b411e98
--- /dev/null
+++ b/src/main/java/de/bps/course/nodes/vc/provider/adobe/AdobeEditForm.java
@@ -0,0 +1,92 @@
+//<OLATCE-103>
+/**
+ *
+ * BPS Bildungsportal Sachsen GmbH<br>
+ * Bahnhofstrasse 6<br>
+ * 09111 Chemnitz<br>
+ * Germany<br>
+ *
+ * Copyright (c) 2005-2010 by BPS Bildungsportal Sachsen GmbH<br>
+ * http://www.bps-system.de<br>
+ *
+ * All rights reserved.
+ */
+package de.bps.course.nodes.vc.provider.adobe;
+
+import org.olat.core.gui.UserRequest;
+import org.olat.core.gui.components.form.flexible.FormItemContainer;
+import org.olat.core.gui.components.form.flexible.elements.MultipleSelectionElement;
+import org.olat.core.gui.components.form.flexible.impl.FormBasicController;
+import org.olat.core.gui.components.form.flexible.impl.FormEvent;
+import org.olat.core.gui.components.form.flexible.impl.elements.FormSubmit;
+import org.olat.core.gui.control.Controller;
+import org.olat.core.gui.control.WindowControl;
+import org.olat.course.editor.NodeEditController;
+
+/**
+ * Description:<br>
+ * Edit form for Adobe Connect specific options.
+ *
+ * <P>
+ * Initial Date: 30.08.2010 <br>
+ *
+ * @author jens Lindner (jlindne4@hs-mittweida.de)
+ * @author skoeber
+ */
+public class AdobeEditForm extends FormBasicController {
+
+ // GUI
+ private FormSubmit submit;
+ private MultipleSelectionElement multiSelectOptions;
+ private static String OPTION_START_MEETING = "vc.access.start";
+ private static String OPTION_OPEN_MEETING = "vc.access.open";
+ private boolean showOptions;
+
+ // data
+ private AdobeConnectConfiguration config;
+
+ public AdobeEditForm(UserRequest ureq, WindowControl wControl, boolean showOptions, AdobeConnectConfiguration config) {
+ super(ureq, wControl, FormBasicController.LAYOUT_VERTICAL);
+ this.config = config;
+ this.showOptions = showOptions;
+
+ initForm(this.flc, this, ureq);
+ }
+
+ @Override
+ protected void initForm(FormItemContainer formLayout, Controller listener, UserRequest ureq) {
+
+ // meeting options
+ String[] accessKeys = new String[] {OPTION_OPEN_MEETING, OPTION_START_MEETING};
+ String[] accessVals = new String[] {translate(OPTION_OPEN_MEETING), translate(OPTION_START_MEETING)};
+ multiSelectOptions = uifactory.addCheckboxesVertical("vc.access", "vc.access.label", formLayout, accessKeys, accessVals, null, 1);
+ multiSelectOptions.select(OPTION_START_MEETING, !config.isGuestStartMeetingAllowed());
+ multiSelectOptions.select(OPTION_OPEN_MEETING, !config.isGuestAccessAllowed());
+ multiSelectOptions.setVisible(showOptions);
+ multiSelectOptions.addActionListener(this, FormEvent.ONCHANGE);
+ multiSelectOptions.showLabel(false);
+
+ submit = new FormSubmit("subm", "submit");
+ formLayout.add(submit);
+ }
+
+ @Override
+ protected void doDispose() {
+ // nothing to dispose
+ }
+
+ @Override
+ protected void formOK(UserRequest ureq) {
+ // read data from form elements
+ if(showOptions) {
+ config.setGuestAccessAllowed(!multiSelectOptions.getSelectedKeys().contains(OPTION_OPEN_MEETING));
+ config.setGuestStartMeetingAllowed(!multiSelectOptions.getSelectedKeys().contains(OPTION_START_MEETING));
+ }
+ fireEvent(ureq, NodeEditController.NODECONFIG_CHANGED_EVENT);
+ }
+
+ protected AdobeConnectConfiguration getConfig() {
+ return config;
+ }
+}
+//</OLATCE-103>
diff --git a/src/main/java/de/bps/course/nodes/vc/provider/adobe/AdobeEditTableDataModel.java b/src/main/java/de/bps/course/nodes/vc/provider/adobe/AdobeEditTableDataModel.java
new file mode 100644
index 0000000000000000000000000000000000000000..613003998a7c32ff69d46e6ffebecf4a3a68dfc7
--- /dev/null
+++ b/src/main/java/de/bps/course/nodes/vc/provider/adobe/AdobeEditTableDataModel.java
@@ -0,0 +1,71 @@
+// <OLATCE-103>
+/**
+ *
+ * BPS Bildungsportal Sachsen GmbH<br>
+ * Bahnhofstrasse 6<br>
+ * 09111 Chemnitz<br>
+ * Germany<br>
+ *
+ * Copyright (c) 2005-2010 by BPS Bildungsportal Sachsen GmbH<br>
+ * http://www.bps-system.de<br>
+ *
+ * All rights reserved.
+ */
+package de.bps.course.nodes.vc.provider.adobe;
+
+import java.text.SimpleDateFormat;
+import java.util.Date;
+import java.util.List;
+
+import org.olat.core.gui.components.table.DefaultTableDataModel;
+
+import de.bps.course.nodes.vc.MeetingDate;
+
+/**
+ * Description:<br>
+ * Data model for editing dates lists - Virtual Classroom dates.
+ *
+ * <P>
+ * Initial Date: 14.07.2010 <br>
+ *
+ * @author Jens Lindner (jlindne4@hs-mittweida.de)
+ * @author skoeber
+ */
+public class AdobeEditTableDataModel extends DefaultTableDataModel {
+
+ private static int COLUMN_COUNT = 4;
+
+ public AdobeEditTableDataModel(final List<MeetingDate> objects) {
+ super(objects);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public int getColumnCount() {
+ return COLUMN_COUNT;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public Object getValueAt(int row, int col) {
+ final MeetingDate model = ((MeetingDate) objects.get(row));
+ switch (col) {
+ case 0:
+ return model.getTitle();
+ case 1:
+ return model.getDescription();
+ case 2:
+ return model.getBegin();
+ case 3:
+ SimpleDateFormat sd = new SimpleDateFormat("dd.MM.yyyy HH:mm");
+ return sd.format(model.getEnd());
+ default:
+ return "error";
+ }
+ }
+}
+// </OLATCE-103>
\ No newline at end of file
diff --git a/src/main/java/de/bps/course/nodes/vc/provider/adobe/_chelp/ced-vc-config.html b/src/main/java/de/bps/course/nodes/vc/provider/adobe/_chelp/ced-vc-config.html
new file mode 100644
index 0000000000000000000000000000000000000000..0abcd75c4c18f7a56414edc9645449b22c4ae344
--- /dev/null
+++ b/src/main/java/de/bps/course/nodes/vc/provider/adobe/_chelp/ced-vc-config.html
@@ -0,0 +1,4 @@
+<!-- <OLATCE-103> -->
+<p>$r.translate("chelp.vc1")</p>
+<p>$r.translate("chelp.vc2")</p>
+<!-- </OLATCE-103> -->
\ No newline at end of file
diff --git a/src/main/java/de/bps/course/nodes/vc/provider/adobe/_content/edit.html b/src/main/java/de/bps/course/nodes/vc/provider/adobe/_content/edit.html
new file mode 100644
index 0000000000000000000000000000000000000000..ebfa3e68eb8380a42206fb29f8f93ba9729020a9
--- /dev/null
+++ b/src/main/java/de/bps/course/nodes/vc/provider/adobe/_content/edit.html
@@ -0,0 +1,5 @@
+<!-- <OLATCE-103> -->
+$r.contextHelpWithWrapper("de.bps.course.nodes.vc.provider.adobe","ced-vc-config.html","chelp.hover.vc.config")
+
+$r.render("editForm")
+<!-- </OLATCE-103> -->
\ No newline at end of file
diff --git a/src/main/java/de/bps/course/nodes/vc/provider/adobe/_content/run.html b/src/main/java/de/bps/course/nodes/vc/provider/adobe/_content/run.html
new file mode 100644
index 0000000000000000000000000000000000000000..60f4d3d1f544df76d41131e2b7b175f99b486847
--- /dev/null
+++ b/src/main/java/de/bps/course/nodes/vc/provider/adobe/_content/run.html
@@ -0,0 +1,28 @@
+<!-- <OLATCE-103> -->
+#if($isModerator)
+ #if($exists)
+ <p>$r.translate("cmd.join.moderator.intro")</p>
+ $r.render("cmd.join.moderator")
+ <div class="b_info">
+ <p><strong>$r.translate("title.options")</strong></p>
+ $r.render("cmd.remove.meeting")
+ $r.render("cmd.sync.meeting")
+ </div>
+ #else
+ <p>$r.translate("cmd.start.meeting.intro")</p>
+ $r.render("cmd.start.meeting")
+ #end
+#else
+ #if($exists)
+ <p>$r.translate("cmd.join.learner.intro")</p>
+ $r.render("cmd.join.learner")
+ #else
+ #if($guestCanStart)
+ <p>$r.translate("cmd.join.learner.intro")</p>
+ $r.render("cmd.start.join.meeting")
+ #else
+ <p>$r.translate("cmd.join.learner.wait")</p>
+ #end
+ #end
+#end
+<!-- </OLATCE-103> -->
\ No newline at end of file
diff --git a/src/main/java/de/bps/course/nodes/vc/provider/adobe/_i18n/LocalStrings_de.properties b/src/main/java/de/bps/course/nodes/vc/provider/adobe/_i18n/LocalStrings_de.properties
new file mode 100644
index 0000000000000000000000000000000000000000..a9618db8c8773574e70148e3c39c5af2446d721c
--- /dev/null
+++ b/src/main/java/de/bps/course/nodes/vc/provider/adobe/_i18n/LocalStrings_de.properties
@@ -0,0 +1,34 @@
+#<OLATCE-103>
+vc.access.label=Zutrittsberechtigung
+vc.access.start=Nur Moderatoren d\u00fcrfen diesen Raum er\u00f6ffnen
+vc.access.open=Moderator muss im Raum online sein, um Zutritt f\u00fcr Teilnehmer zu best\u00e4tigen
+vc.access.dates=Virtuelles Klassenzimmer soll nur zu bestimmten Terminen betreten werden k\u00f6nnen
+
+cmd.start.meeting=Virtuelles Klassenzimmer er\u00f6ffnen
+cmd.start.meeting.intro=Das virtuelle Klassenzimmer wurde noch nicht er\u00f6ffnet. Teilnehmer k\u00f6nnen den Raum f\u00fcr ein geplantes Meeting ggf. nicht betreten.
+cmd.start.join.meeting=Virtuelles Klassenzimmer betreten
+cmd.join.moderator=Virtuelles Klassenzimmer moderieren
+cmd.join.moderator.intro=Das virtuelle Klassenzimmer wurde er\u00f6ffnet. Sie k\u00f6nnen den Raum nun betreten und moderieren. Teilnehmer k\u00f6nnen das virtuelle Klassenzimmer ohne Zustimmung eines Moderators ggf. nicht betreten.
+cmd.join.learner=Virtuelles Klassenzimmer betreten
+cmd.join.learner.intro=Das virtuelle Klassenzimmer kann betreten werden.
+cmd.join.learner.wait=Das virtuelle Klassenzimmer wurde noch nicht er\u00f6ffnet.
+cmd.remove.meeting=Meeting schlie\u00dfen
+cmd.sync.meeting=Meeting synchronisieren
+title.options=Weiterf¸hrende Informationen und Optionen f¸r Autoren
+
+error.no.room=Das virtuelle Klassenzimmer konnte nicht geladen werden. Bitte wenden Sie sich an Ihren Betreuer oder Ihre Systemadministratoren.
+error.no.login=Die Anmeldung war nicht erfolgreich. Bitte wenden Sie sich an Ihren Betreuer oder Ihre Systemadministratoren.
+error.create.room=Das virtuelle Klassenzimmer konnte nicht erzeugt werden. Bitte wenden Sie sich an Ihren Betreuer oder Ihre Systemadministratoren.
+error.remove.room=Das virtuelle Klassenzimmer konnte nicht entfernt werden. Bitte wenden Sie sich an Ihren Betreuer oder Ihre Systemadministratoren.
+error.update.room=Das virtuelle Klassenzimmer konnte nicht mit den aktuellen Einstellungen synchronisiert werden. Bitte wenden Sie sich an Ihren Betreuer oder Ihre Systemadministratoren.
+error.update.rights=Ihnen konnten nicht die notwendigen Rechte f\u00fcr diesen Raum zugewiesen werden. Bitte wenden Sie sich an Ihren Betreuer oder Ihre Systemadministratoren.
+
+sync.meeting.title=Virtuelles Klassenzimmer synchronisieren
+sync.meeting.text=Sie haben die Einstellungen f\u00fcr diese virtuelle Klassenzimmer ge\u00e4ndert, nachdem dieses er\u00f6ffnet wurde. Die \u00c4nderungen werden erst wirksam, wenn Sie das virtuelle Klassenzimmer mit den neuen Einstellungen synchronisieren. Die Einstellungen k\u00f6nnen auch jederzeit direkt im Kurs synchronisiert werden. M\u00f6chten Sie die Einstellungen jetzt synchronisieren?
+success.update.room=Das virtuelle Klassenzimmer wurde erfolgreich mit den aktuellen Einstellungen synchronisiert.
+
+chelp.ced-vc-config.title=Virtuelles Klassenzimmer konfigurieren (Adobe Connect)
+chelp.hover.vc.config=Hilfe zur Konfiguration des Virtuellen Klassenzimmers
+chelp.vc1=Legen Sie spezielle Optionen f¸r Ihr virtuelles Klassenzimmer in Adobe Connect fest.
+chelp.vc2=<b>Zutrittsberechtigung:</b> Legen Sie fest, ob der Zugang zu einem Raum f\u00fcr Teilnehmer erst durch einen Moderator best\u00e4tigt werden muss bzw. ob Teilnehmer selbst\u00e4ndig den Raum er\u00f6ffnen und betreten d\u00fcrfen.
+#</OLATCE-103>
\ No newline at end of file
diff --git a/src/main/java/de/bps/course/nodes/vc/provider/adobe/_i18n/LocalStrings_en.properties b/src/main/java/de/bps/course/nodes/vc/provider/adobe/_i18n/LocalStrings_en.properties
new file mode 100644
index 0000000000000000000000000000000000000000..85916426086dedb367ed59a76883b3f2db826e91
--- /dev/null
+++ b/src/main/java/de/bps/course/nodes/vc/provider/adobe/_i18n/LocalStrings_en.properties
@@ -0,0 +1,34 @@
+#<OLATCE-103 OLATCE-619>
+vc.access.label=Access authorisation
+vc.access.start=Only moderators are allowed to open this virtual classroom
+vc.access.open=Moderator must be in classroom to grant access to users
+vc.access.dates=Virtual classroom shall only be available at defined dates
+
+cmd.start.meeting=Open virtual classroom
+cmd.start.meeting.intro=The virtual classroom has not been opened, yet. Participants are not able to enter the classroom for a meeting.
+cmd.start.join.meeting=Enter virtual classroom
+cmd.join.moderator=Moderate virtual classroom
+cmd.join.moderator.intro=The virtual classroom has been opened. You may now enter the classroom and moderate the meeting. Participants are not able to join the meeting until the moderator grant them access.
+cmd.join.learner=Enter virtual classroom
+cmd.join.learner.intro=You can join the virtual classroom.
+cmd.join.learner.wait=The virtual classroom has not been opened, yet.
+cmd.remove.meeting=Close meeting
+cmd.sync.meeting=Syncronize meeting
+title.options=Additional information and options for authors
+
+error.no.room=Sorry! An error occured while loading the virtual classroom. Please inform your tutor or system administrator.
+error.no.login=Login was not successfull. Please, contact your tutor or system administrator for any further information.
+error.create.room=Sorry! An error occured while creating the virtual classroom. Please inform your tutor or system administrator.
+error.remove.room=Sorry! An error occured while removing the virtual class room. Please inform your tutor or system administrator.
+error.update.room=Sorry! An error occured while synchronizing the virtual class room with the actual configuration. Please inform your tutor or system administrator.
+error.update.rights=Sorry! An error occured while granting access to the virtual classroom. Please inform your tutor or system administrator.
+
+sync.meeting.title=Synchronize virtual classroom
+sync.meeting.text=You have changed the configuration of the virtual classroom after it had been started. The changes will be taken into account only after having synchronized the virtual class room with the new configuration. You can synchronize the configuration at any time directly from the course run. Do you want to synchronize now?
+success.update.room=Successfully synchronized the virtual classroom with the current configuration.
+
+chelp.ced-vc-config.title=Configure virtual classroom (Adobe Connect)
+chelp.hover.vc.config=Help about configuration of the virtual classroom
+chelp.vc1=Choose special options for your virtual classroom in Adobe Connect.
+chelp.vc2=<b>Access authorisation:</b> Choose whether a has to be in the classroom to grant access to other users or if users may open and enter a classroom on their own.
+#</OLATCE-103 OLATCE-619>
\ No newline at end of file
diff --git a/src/main/java/de/bps/course/nodes/vc/provider/adobe/_spring/adobeContext.xml b/src/main/java/de/bps/course/nodes/vc/provider/adobe/_spring/adobeContext.xml
new file mode 100644
index 0000000000000000000000000000000000000000..214277857e6eb6a7de06ea2c0a2b23786475b60b
--- /dev/null
+++ b/src/main/java/de/bps/course/nodes/vc/provider/adobe/_spring/adobeContext.xml
@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<beans xmlns="http://www.springframework.org/schema/beans"
+ xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+ xmlns:context="http://www.springframework.org/schema/context"
+ xsi:schemaLocation="
+ http://www.springframework.org/schema/beans
+ http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
+ http://www.springframework.org/schema/context
+ http://www.springframework.org/schema/context/spring-context-3.0.xsd">
+
+ <bean id="adobeDefaultConfig" class="de.bps.course.nodes.vc.provider.adobe.AdobeConnectConfiguration">
+ <!-- general -->
+ <property name="createMeetingImmediately" value="false" />
+ <!-- Adobe Connect specific -->
+ <property name="guestAccessAllowed" value="true" />
+ <property name="guestStartMeetingAllowed" value="true" />
+ <property name="useMeetingDates" value="false" />
+ </bean>
+
+</beans>
\ No newline at end of file
diff --git a/src/main/java/de/bps/course/nodes/vc/provider/wimba/StatusCode.java b/src/main/java/de/bps/course/nodes/vc/provider/wimba/StatusCode.java
new file mode 100644
index 0000000000000000000000000000000000000000..5993c40124b53c0a94e18c92e541126de9fb84be
--- /dev/null
+++ b/src/main/java/de/bps/course/nodes/vc/provider/wimba/StatusCode.java
@@ -0,0 +1,67 @@
+//<OLATCE-103>
+/**
+ *
+ * BPS Bildungsportal Sachsen GmbH<br>
+ * Bahnhofstrasse 6<br>
+ * 09111 Chemnitz<br>
+ * Germany<br>
+ *
+ * Copyright (c) 2005-2011 by BPS Bildungsportal Sachsen GmbH<br>
+ * http://www.bps-system.de<br>
+ *
+ * All rights reserved.
+ */
+package de.bps.course.nodes.vc.provider.wimba;
+
+/**
+ *
+ * Description:<br>
+ * API return codes, see Wimba Classroom 6.0 API Guide, page 5
+ *
+ * <P>
+ * Initial Date: 07.01.2011 <br>
+ * @author skoeber
+ */
+public enum StatusCode {
+
+ /** 100 OK */ OK(100),
+ /** 200 Database access error (database unavailable) */ DB_ACCESS_ERROR(200),
+ /** 201 Permission denied */ DENIED(201),
+ /** 204 Not authenticated, invalid authentication */ NO_AUTH(204),
+ /** 300 Database constraint error */ DB_CONSTRAINT_ERROR(300),
+ /** 301 Target already exists */ ALREADY_EXISTS(301),
+ /** 302 Target not found */ NOT_FOUND(302),
+ /** 400 Miscellaneous */ MISC(400),
+ /** 401 Not implemented */ NOT_IMPLEMENTED(401),
+ /** 402 Malformed query */ MALFORMED_QUERY(402),
+ /** 404 API HTTP server error */ SERVER_ERROR(404),
+ /** Undefined */ UNDEFINED(666);
+
+ private int code;
+
+ private StatusCode(int code) {
+ this.code = code;
+ }
+
+ public int getCode() {
+ return code;
+ }
+
+ public static StatusCode getStatus(int code) {
+ switch (code) {
+ case 100: return OK;
+ case 200: return DB_ACCESS_ERROR;
+ case 201: return DENIED;
+ case 204: return NO_AUTH;
+ case 300: return DB_CONSTRAINT_ERROR;
+ case 301: return ALREADY_EXISTS;
+ case 302: return NOT_FOUND;
+ case 400: return MISC;
+ case 401: return NOT_IMPLEMENTED;
+ case 402: return MALFORMED_QUERY;
+ case 404: return SERVER_ERROR;
+ default: return UNDEFINED;
+ }
+ }
+}
+//</OLATCE-103>
\ No newline at end of file
diff --git a/src/main/java/de/bps/course/nodes/vc/provider/wimba/WimbaClassroomConfiguration.java b/src/main/java/de/bps/course/nodes/vc/provider/wimba/WimbaClassroomConfiguration.java
new file mode 100644
index 0000000000000000000000000000000000000000..6f8f1076d37f9184dee0c1984b1a16f6f1a5a859
--- /dev/null
+++ b/src/main/java/de/bps/course/nodes/vc/provider/wimba/WimbaClassroomConfiguration.java
@@ -0,0 +1,183 @@
+//<OLATCE-103>
+/**
+ *
+ * BPS Bildungsportal Sachsen GmbH<br>
+ * Bahnhofstrasse 6<br>
+ * 09111 Chemnitz<br>
+ * Germany<br>
+ *
+ * Copyright (c) 2005-2011 by BPS Bildungsportal Sachsen GmbH<br>
+ * http://www.bps-system.de<br>
+ *
+ * All rights reserved.
+ */
+package de.bps.course.nodes.vc.provider.wimba;
+
+import java.io.Serializable;
+
+import de.bps.course.nodes.vc.DefaultVCConfiguration;
+
+/**
+ *
+ * Description:<br>
+ * Configuration object for Wimba Classroom
+ *
+ * <P>
+ * Initial Date: 06.01.2011 <br>
+ * @author skoeber
+ */
+public class WimbaClassroomConfiguration extends DefaultVCConfiguration implements Serializable {
+
+ /** presentation tools are available only to instructors or to both students and instructors */
+ private boolean toolsToStudentsEnabled;
+ /** allow students to speak by default */
+ private boolean studentsSpeakAllowed;
+ /** allow students to show their video by default */
+ private boolean studentsVideoAllowed;
+ /** enable students to use text chat */
+ private boolean studentsChatAllowed;
+ /** enable private text chat among student */
+ private boolean studentsPrivateChatAllowed;
+ /** enable user status indicators */
+ private boolean userStatusIndicatorsEnabled;
+ /** enable user status updates appear in chat */
+ private boolean userStatusUpdateInChatEnabled;
+ /** enable students to use the eBoard by default */
+ private boolean studentEBoardEnabled;
+ /** enable breakout rooms */
+ private boolean breakoutRoomsEnabled;
+ /** enable archiving */
+ private boolean archivingEnabled;
+ /** automatically open new archives */
+ private boolean autoOpenNewArchives;
+ /** enable appshare */
+ private boolean appshareEnabled;
+ /** enable on-the-fly PowerPoint import */
+ private boolean powerPointImportEnabled;
+ /** enable guest access */
+ private boolean guestAccessAllowed;
+
+ /* be compatible with old configuration versions */
+ @SuppressWarnings("unused") private transient boolean chatEnabled;
+ @SuppressWarnings("unused") private transient boolean privateChatEnabled;
+
+ public boolean isToolsToStudentsEnabled() {
+ return toolsToStudentsEnabled;
+ }
+
+ public boolean isStudentsSpeakAllowed() {
+ return studentsSpeakAllowed;
+ }
+
+ public boolean isStudentsVideoAllowed() {
+ return studentsVideoAllowed;
+ }
+
+ public boolean isUserStatusIndicatorsEnabled() {
+ return userStatusIndicatorsEnabled;
+ }
+
+ public boolean isUserStatusUpdateInChatEnabled() {
+ return userStatusUpdateInChatEnabled;
+ }
+
+ public boolean isStudentEBoardEnabled() {
+ return studentEBoardEnabled;
+ }
+
+ public boolean isBreakoutRoomsEnabled() {
+ return breakoutRoomsEnabled;
+ }
+
+ public boolean isArchivingEnabled() {
+ return archivingEnabled;
+ }
+
+ public boolean isAutoOpenNewArchives() {
+ return autoOpenNewArchives;
+ }
+
+ public boolean isAppshareEnabled() {
+ return appshareEnabled;
+ }
+
+ public boolean isPowerPointImportEnabled() {
+ return powerPointImportEnabled;
+ }
+
+ public boolean isGuestAccessAllowed() {
+ return guestAccessAllowed;
+ }
+
+ public void setToolsToStudentsEnabled(boolean toolsToStudentsEnabled) {
+ this.toolsToStudentsEnabled = toolsToStudentsEnabled;
+ }
+
+ public void setStudentsSpeakAllowed(boolean studentsSpeakAllowed) {
+ this.studentsSpeakAllowed = studentsSpeakAllowed;
+ }
+
+ public void setStudentsVideoAllowed(boolean studentsVideoAllowed) {
+ this.studentsVideoAllowed = studentsVideoAllowed;
+ }
+
+ public void setUserStatusIndicatorsEnabled(boolean userStatusIndicatorsEnabled) {
+ this.userStatusIndicatorsEnabled = userStatusIndicatorsEnabled;
+ }
+
+ public void setUserStatusUpdateInChatEnabled(boolean userStatusUpdateInChatEnabled) {
+ this.userStatusUpdateInChatEnabled = userStatusUpdateInChatEnabled;
+ }
+
+ public void setStudentEBoardEnabled(boolean studentEBoardEnabled) {
+ this.studentEBoardEnabled = studentEBoardEnabled;
+ }
+
+ public void setBreakoutRoomsEnabled(boolean breakoutRoomsEnabled) {
+ this.breakoutRoomsEnabled = breakoutRoomsEnabled;
+ }
+
+ public void setArchivingEnabled(boolean archivingEnabled) {
+ this.archivingEnabled = archivingEnabled;
+ }
+
+ public void setAutoOpenNewArchives(boolean autoOpenNewArchives) {
+ this.autoOpenNewArchives = autoOpenNewArchives;
+ }
+
+ public void setAppshareEnabled(boolean appshareEnabled) {
+ this.appshareEnabled = appshareEnabled;
+ }
+
+ public void setPowerPointImportEnabled(boolean powerPointImportEnabled) {
+ this.powerPointImportEnabled = powerPointImportEnabled;
+ }
+
+ public void setGuestAccessAllowed(boolean guestAccessAllowed) {
+ this.guestAccessAllowed = guestAccessAllowed;
+ }
+
+ public void setStudentsChatAllowed(boolean studentsChatAllowed) {
+ this.studentsChatAllowed = studentsChatAllowed;
+ }
+
+ public boolean isStudentsChatAllowed() {
+ return studentsChatAllowed;
+ }
+
+ public void setStudentsPrivateChatAllowed(boolean studentsPrivateChatAllowed) {
+ this.studentsPrivateChatAllowed = studentsPrivateChatAllowed;
+ }
+
+ public boolean isStudentsPrivateChatAllowed() {
+ return studentsPrivateChatAllowed;
+ }
+
+ @Override
+ public boolean isConfigValid() {
+ // TODO implement logic
+ return true;
+ }
+
+}
+//</OLATCE-103>
\ No newline at end of file
diff --git a/src/main/java/de/bps/course/nodes/vc/provider/wimba/WimbaClassroomProvider.java b/src/main/java/de/bps/course/nodes/vc/provider/wimba/WimbaClassroomProvider.java
new file mode 100644
index 0000000000000000000000000000000000000000..6654131dcb51ace1e62c4a0a7e38653063529d6b
--- /dev/null
+++ b/src/main/java/de/bps/course/nodes/vc/provider/wimba/WimbaClassroomProvider.java
@@ -0,0 +1,812 @@
+//<OLATCE-103>
+/**
+ *
+ * BPS Bildungsportal Sachsen GmbH<br>
+ * Bahnhofstrasse 6<br>
+ * 09111 Chemnitz<br>
+ * Germany<br>
+ *
+ * Copyright (c) 2005-2011 by BPS Bildungsportal Sachsen GmbH<br>
+ * http://www.bps-system.de<br>
+ *
+ * All rights reserved.
+ */
+package de.bps.course.nodes.vc.provider.wimba;
+
+import java.io.BufferedReader;
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.LineNumberReader;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.io.StringReader;
+import java.net.HttpURLConnection;
+import java.net.MalformedURLException;
+import java.net.URI;
+import java.net.URL;
+import java.util.Collections;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import javax.ws.rs.core.UriBuilder;
+
+import org.apache.commons.lang.NotImplementedException;
+import org.olat.core.gui.UserRequest;
+import org.olat.core.gui.control.Controller;
+import org.olat.core.gui.control.WindowControl;
+import org.olat.core.helpers.Settings;
+import org.olat.core.id.Identity;
+import org.olat.core.id.UserConstants;
+import org.olat.core.logging.AssertException;
+import org.olat.core.logging.LogDelegator;
+import org.olat.core.util.Encoder;
+
+import de.bps.course.nodes.vc.VCConfiguration;
+import de.bps.course.nodes.vc.provider.VCProvider;
+
+/**
+ *
+ * Description:<br>
+ * Virtual classroom provider implementation for Wimba Classroom
+ *
+ * <P>
+ * Initial Date: 06.01.2011 <br>
+ * @author skoeber
+ */
+public class WimbaClassroomProvider extends LogDelegator implements VCProvider {
+
+ /** Return type of responses, see Wimba Classroom 6.0 API Guide, page 5 */
+ private static final String CONTENT_TYPE = "text/html";
+ /** Session cookie, see Wimba Classroom 6.0 API Guide, page 6 */
+ private static final String COOKIE = "AuthCookieHandler_Horizon=";
+ /** Session token for remote login, see Wimba Classroom 6.0 API Guide, page 56 */
+ private static final String TOKEN = "authToken";
+ /** Delimiter for data in record format, see Wimba Classroom 6.0 API Guide, page 5 */
+ private static final String DELIM = "=END RECORD";
+ protected static final String PREFIX = "olat_";
+
+ // targets for service URLs
+ protected static String TARGET_OPEN_MANAGEROOM = "cmd.open.manageroom";
+ protected static String TARGET_OPEN_POLLRESULTS = "cmd.open.pollresults";
+ protected static String TARGET_OPEN_TRACKING = "cmd.open.tracking";
+ protected static String TARGET_OPEN_ROOMSETTINGS = "cmd.open.roomsettings";
+ protected static String TARGET_OPEN_MEDIASETTINGS = "cmd.open.mediasettings";
+ protected static String TARGET_OPEN_WIZARD = "cmd.open.wizard";
+
+ private static String ENDPOINT_WIZARD = "/wizard/wizard.html.pl?wizardconf=wizard.conf";
+
+ // configuration
+ private static WimbaClassroomConfiguration defaultConfig;
+ private boolean enabled;
+ private String providerId;
+ private String displayName;
+ private String protocol;
+ private int port;
+ private String baseUrl;
+ private String adminLogin;
+ private String adminPassword;
+
+ // runtime data
+ private String cookie;
+ private String token;
+
+ private WimbaClassroomProvider(String providerId, String displayName, String protocol, int port, String baseUrl, String adminLogin, String adminPassword) {
+ setProviderId(providerId);
+ setDisplayName(displayName);
+ setProtocol(protocol);
+ setPort(port);
+ setBaseUrl(baseUrl);
+ setAdminLogin(adminLogin);
+ setAdminPassword(adminPassword);
+ }
+
+ /**
+ * Public constructor, mostly used by spring<br/>
+ * <b>Important</b> when using: set configuration manually!
+ */
+ public WimbaClassroomProvider() {
+ //
+ }
+
+ @Override
+ public VCProvider newInstance() {
+ return new WimbaClassroomProvider(providerId, displayName, protocol, port, baseUrl, adminLogin, adminPassword);
+ }
+
+ @Override
+ public String getProviderId() {
+ return providerId;
+ }
+
+ @Override
+ public String getDisplayName() {
+ return displayName;
+ }
+
+ @Override
+ public boolean isEnabled() {
+ return enabled;
+ }
+
+ @Override
+ public boolean isProviderAvailable() {
+ if(!loginAdmin()) return false;
+
+ Map<String, String> parameters = new HashMap<String, String>();
+ parameters.put("function", "statusServer");
+ String raw = sendRequest(parameters);
+ WimbaResponse response = getResponseDocument(raw);
+ boolean success = evaluateOk(response);
+
+ return success;
+ }
+
+ @Override
+ public boolean createClassroom(String roomId, String name, String description, Date begin, Date end, VCConfiguration config) {
+ if(existsClassroom(roomId, config)) return true;
+ boolean success = handleClassroomRequest("createClass", roomId, name, description, begin, end, config);
+ // set preview mode because this setting has no effect on creation
+ if(success) {
+ success = setPreviewMode(roomId, false, false);
+ updateRights("Guest", roomId, "Student", false);
+ }
+ return success;
+ }
+
+ @Override
+ public boolean updateClassroom(String roomId, String name, String description, Date begin, Date end, VCConfiguration config) {
+ if(!existsClassroom(roomId, config)) {
+ logWarn("Tried to update Wimba Classroom meeting, that not exists!", null);
+ return false;
+ }
+ return handleClassroomRequest("modifyClass", roomId, name, description, begin, end, config);
+ }
+
+ private boolean handleClassroomRequest(String function, String roomId, String name, String description, Date begin, Date end, VCConfiguration config) {
+ WimbaClassroomConfiguration wc = (WimbaClassroomConfiguration) config;
+
+ Map<String, String> parameters = new HashMap<String, String>();
+ parameters.put("function", function);
+ parameters.put("target", PREFIX + roomId);
+ parameters.put("userlimit", "-1");
+ /** name is limited to maximum of 50 characters, see Wimba Classroom 6.0 API Guide, page 15 */
+ if(name != null && name.length() > 50) name = name.substring(0, 49);
+ parameters.put("longname", name);
+ /** name is limited to maximum of 50 characters, see Wimba Classroom 6.0 API Guide, page 15 */
+ if(description != null && description.length() > 50) description = description.substring(0, 49);
+ parameters.put("can_liveshare", param(wc.isAppshareEnabled()));
+ parameters.put("can_archive", param(wc.isArchivingEnabled()));
+ parameters.put("auto_open_new__archives", param(wc.isAutoOpenNewArchives()));
+ parameters.put("bor_enabled", param(wc.isBreakoutRoomsEnabled()));
+ parameters.put("can_ppt_import", param(wc.isPowerPointImportEnabled()));
+ parameters.put("student_wb_enabled", param(wc.isStudentEBoardEnabled()));
+ parameters.put("hms_two_way_enabled", param(wc.isStudentsSpeakAllowed()));
+ parameters.put("media_format", "hms");
+ parameters.put("media_type", wc.isStudentsVideoAllowed() ? "two-way-video" : "simulcast-only");
+ parameters.put("hms_simulcast_restricted", param(!wc.isToolsToStudentsEnabled()));
+ parameters.put("userstatus_enabled", param(wc.isUserStatusIndicatorsEnabled()));
+ parameters.put("send_userstatus_updates", param(wc.isUserStatusUpdateInChatEnabled()));
+ parameters.put("chatenable", param(wc.isStudentsChatAllowed()));
+ parameters.put("privatechatenable", param(wc.isStudentsPrivateChatAllowed()));
+ parameters.put("archive", param(false));
+ String raw = sendRequest(parameters);
+ WimbaResponse response = getResponseDocument(raw);
+
+ boolean success = evaluateOk(response);
+ if(!success) handleError(response.getStatus(), null);
+
+ if(wc.isGuestAccessAllowed()) {
+ updateRights("Guest", roomId, "Student", false);
+ } else if(function.equals("modifyClass")) {
+ // only delete guest access if this is an already existing meeting
+ updateRights("Guest", roomId, "Student", true);
+ }
+
+ return success;
+ }
+
+ @Override
+ public boolean removeClassroom(String roomId, VCConfiguration config) {
+ if(!existsClassroom(roomId, config)) return true;
+
+ if(!loginAdmin()) throw new AssertException("Cannot login to Wimba Classroom. Please check module configuration and Wimba Classroom connectivity");
+
+ // first delete recordings
+ Map<String, String> mapRecordings = listRecordings(roomId);
+ for(String key : mapRecordings.keySet()) {
+ removeClassroomRecording(key, config);
+ }
+
+ Map<String, String> parameters = new HashMap<String, String>();
+ parameters.put("function", "deleteClass");
+ parameters.put("target", PREFIX + roomId);
+ String raw = sendRequest(parameters);
+ WimbaResponse response = getResponseDocument(raw);
+
+ boolean success = evaluateOk(response);
+ if(!success) handleError(response.getStatus(), null);
+
+ return success;
+ }
+
+ @Override
+ public URL createClassroomUrl(String roomId, Identity identity, VCConfiguration config) {
+ URL url = null;
+ URI uri = UriBuilder.fromUri(protocol + "://" + baseUrl).port(port)
+ .path("check_wizard.pl").queryParam("channel", PREFIX + roomId).queryParam("hzA", token).build();
+ try {
+ url = uri.toURL();
+ } catch (MalformedURLException e) {
+ logWarn("Cannot create access URL to Wimba Classroom meeting for id \"" + PREFIX + roomId + "\" and user \"" + identity.getName() + "\"", e);
+ }
+
+ return url;
+ }
+
+ @Override
+ public URL createClassroomGuestUrl(String roomId, Identity identity, VCConfiguration config) {
+ URL url = null;
+ URI uri = UriBuilder.fromUri(protocol + "://" + baseUrl).port(port)
+ .path("launcher.cgi").queryParam("room",PREFIX + roomId).build();
+ try {
+ url = uri.toURL();
+ } catch (MalformedURLException e) {
+ logWarn("Cannot create guest access URL to Wimba Classroom meeting for id \"" + PREFIX + roomId, e);
+ }
+
+ return url;
+ }
+
+ @Override
+ public boolean existsClassroom(String roomId, VCConfiguration config) {
+ if(!loginAdmin()) return false;
+
+ Map<String, String> parameters = new HashMap<String, String>();
+ parameters.put("function", "listClass");
+ parameters.put("filter00", "class_id");
+ parameters.put("filter00value", PREFIX + roomId);
+ String raw = sendRequest(parameters);
+ WimbaResponse response = getResponseDocument(raw);
+
+ boolean success = evaluateOk(response);
+ if(success) success = response.hasRecords() && response.numRecords() == 1;
+
+ return success;
+ }
+
+ @Override
+ public boolean login(Identity identity, String password) {
+ if(!loginAdmin()) return false;
+
+ Map<String, String> parameters = new HashMap<String, String>();
+ parameters.put("function", "getAuthToken");
+ parameters.put("target", PREFIX + identity.getName());
+ parameters.put("nickname", identity.getName());
+ String raw = sendRequest(parameters);
+ WimbaResponse response = getResponseDocument(raw);
+ boolean success = evaluateOk(response);
+
+ if(success & response.hasRecords()) {
+ String responseToken = response.findRecord(TOKEN);
+ if(responseToken != null) {
+ token = responseToken;
+ } else {
+ success = false;
+ }
+ }
+
+ return success;
+ }
+
+ private boolean loginAdmin() {
+ Map<String, String> parameters = new HashMap<String, String>();
+ parameters.put("function", "NoOp");
+ parameters.put("AuthType", "AuthCookieHandler");
+ parameters.put("AuthName", "Horizon");
+ parameters.put("credential_0", adminLogin);
+ parameters.put("credential_1", adminPassword);
+ String raw = sendRequest(parameters);
+ WimbaResponse response = getResponseDocument(raw);
+ boolean success = evaluateOk(response);
+
+ if(!success) {
+ logError("Cannot login to Wimba Classroom. Please check module configuration and Wimba Classroom connectivity", null);
+ }
+
+ return success;
+ }
+
+ @Override
+ public boolean createModerator(Identity identity, String roomId) {
+ if(!loginAdmin()) throw new AssertException("Cannot login to Wimba Classroom. Please check module configuration and Wimba Classroom connectivity");
+
+ boolean success = false;
+ boolean exists = existsLogin(identity);
+
+ // create login if necessary
+ if(!exists) success = createLogin(identity);
+ // update access rights
+ if(exists | success) success = updateRights(identity.getName(), roomId, "Instructor", false);
+
+ return success;
+ }
+
+ @Override
+ public boolean createUser(Identity identity, String roomId) {
+ if(!loginAdmin()) throw new AssertException("Cannot login to Wimba Classroom. Please check module configuration and Wimba Classroom connectivity");
+
+ boolean success = false;
+ boolean exists = existsLogin(identity);
+
+ // create login if necessary
+ if(!exists) success = createLogin(identity);
+ // update access rights
+ if(exists | success) success = updateRights(identity.getName(), roomId, "Student", false);
+
+ return success;
+ }
+
+ private boolean updateRights(String username, String roomId, String role, boolean delete) {
+ Map<String, String> parameters = new HashMap<String, String>();
+ parameters.put("function", delete ? "deleteRole" : "createRole");
+ parameters.put("target", PREFIX + roomId);
+ parameters.put("user_id", username.equals("Guest") ? "Guest" : PREFIX + username);
+ parameters.put("role_id", role);
+ String raw = sendRequest(parameters);
+ WimbaResponse response = getResponseDocument(raw);
+ boolean success = evaluateOk(response);
+
+ return success;
+ }
+
+ private boolean createLogin(Identity identity) {
+ Map<String, String> parameters = new HashMap<String, String>();
+ parameters.put("function", "createUser");
+ parameters.put("target", PREFIX + identity.getName());
+ parameters.put("password_type", "P");// specified password, see Wimba Classroom 6.0 API Guide, page 8
+ parameters.put("password", Encoder.encrypt(identity.getName() + "@" + Settings.getApplicationName()));
+ parameters.put("first_name", identity.getUser().getProperty(UserConstants.FIRSTNAME, null));
+ parameters.put("last_name", identity.getUser().getProperty(UserConstants.LASTNAME, null));
+ String raw = sendRequest(parameters);
+ WimbaResponse response = getResponseDocument(raw);
+ boolean success = evaluateOk(response);
+
+ return success;
+ }
+
+ private boolean existsLogin(Identity identity) {
+ Map<String, String> parameters = new HashMap<String, String>();
+ parameters.put("function", "listUser");
+ parameters.put("attribute", "user_id");
+ parameters.put("filter01", "user_id");
+ parameters.put("filter01value", PREFIX + identity.getName());
+ String raw = sendRequest(parameters);
+ WimbaResponse response = getResponseDocument(raw);
+ boolean success = evaluateOk(response);
+ boolean exists = false;
+ if(success) exists = response.numRecords() == 1;
+
+ return exists;
+ }
+
+ @Override
+ public boolean createGuest(Identity identity, String roomId) {
+ throw new NotImplementedException("method createGuest not yet implemented");
+ }
+
+ @Override
+ public Controller createDisplayController(UserRequest ureq, WindowControl wControl, String roomId, String name, String description, boolean isModerator,
+ VCConfiguration config) {
+ WimbaDisplayController displayCtr = new WimbaDisplayController(ureq, wControl, roomId, name, description, isModerator, (WimbaClassroomConfiguration) config, this);
+ return displayCtr;
+ }
+
+ @Override
+ public Controller createConfigController(UserRequest ureq, WindowControl wControl, String roomId, VCConfiguration config) {
+ WimbaConfigController configCtr = new WimbaConfigController(ureq, wControl, roomId, this, (WimbaClassroomConfiguration) config);
+ return configCtr;
+ }
+
+ public boolean isPreviewMode(String roomId, boolean isRecording) {
+ if(!loginAdmin()) throw new AssertException("Cannot login to Wimba Classroom. Please check module configuration and Wimba Classroom connectivity");
+
+ boolean mode = false;
+
+ Map<String, String> parameters = new HashMap<String, String>();
+ parameters.put("function", "listClass");
+ parameters.put("attribute", "preview");
+ parameters.put("filter00", "class_id");
+ parameters.put("filter00value", isRecording ? roomId : PREFIX + roomId);
+ String raw = sendRequest(parameters);
+ WimbaResponse response = getResponseDocument(raw);
+ boolean success = evaluateOk(response);
+
+ if(success & response.hasRecords()) {
+ String modeStr = response.getRecords().get(0).get("preview");
+ if(modeStr == null || modeStr.equals("0")) mode = false;
+ else if(modeStr.equals("1")) mode = true;
+ }
+
+ return mode;
+ }
+
+ public boolean setPreviewMode(String roomId, boolean enabled, boolean isRecording) {
+ if(!loginAdmin()) throw new AssertException("Cannot login to Wimba Classroom. Please check module configuration and Wimba Classroom connectivity");
+
+ Map<String, String> parameters = new HashMap<String, String>();
+ parameters.put("function", "modifyClass");
+ parameters.put("target", isRecording ? roomId : PREFIX + roomId);
+ parameters.put("preview", param(enabled));
+ String raw = sendRequest(parameters);
+ WimbaResponse response = getResponseDocument(raw);
+
+ boolean success = evaluateOk(response);
+ if(!success) handleError(response.getStatus(), null);
+
+ return success;
+ }
+
+ /**
+ *
+ * @param roomId
+ * @return map with recordingId and name
+ */
+ public Map<String, String> listRecordings(String roomId) {
+ Map<String, String> mapKeyName = new HashMap<String, String>();
+
+ Map<String, String> parameters = new HashMap<String, String>();
+ parameters.put("function", "listClass");
+ parameters.put("attribute", "longname");
+ parameters.put("filter00", "archive_of");
+ parameters.put("filter00value", PREFIX + roomId);
+ String raw = sendRequest(parameters);
+ WimbaResponse response = getResponseDocument(raw);
+ boolean success = evaluateOk(response);
+
+ if(success & response.hasRecords()) {
+ List<Map<String, String>> records = response.getRecords();
+ for(Map<String, String> record : records) {
+ mapKeyName.put(record.get("class_id"), record.get("longname"));
+ }
+ }
+
+ return mapKeyName;
+ }
+
+ public URL createClassroomRecordingUrl(String recordingId, Identity identity, VCConfiguration config) {
+ URL url = null;
+ /* Notice: This is a very special and wimba specific case, the recordingId must not prefixed! */
+ URI uri = UriBuilder.fromUri(protocol + "://" + baseUrl).port(port)
+ .path("check_wizard.pl").queryParam("channel", recordingId).queryParam("hzA", token).build();
+ try {
+ url = uri.toURL();
+ } catch (MalformedURLException e) {
+ logWarn("Cannot create access URL to Wimba Classroom meeting for id \"" + recordingId + "\" and user \"" + identity.getName() + "\"", e);
+ }
+
+ return url;
+ }
+
+ public boolean removeClassroomRecording(String recordingId, VCConfiguration config) {
+ if(!loginAdmin()) throw new AssertException("Cannot login to Wimba Classroom. Please check module configuration and Wimba Classroom connectivity");
+
+ Map<String, String> parameters = new HashMap<String, String>();
+ parameters.put("function", "deleteClass");
+ parameters.put("target", recordingId);
+ String raw = sendRequest(parameters);
+ WimbaResponse response = getResponseDocument(raw);
+
+ boolean success = evaluateOk(response);
+ if(!success) handleError(response.getStatus(), null);
+
+ return success;
+ }
+
+ @Override
+ public VCConfiguration createNewConfiguration() {
+ // do a deep copy
+ Object deepCopy = null;
+ try {
+ ByteArrayOutputStream byteOutput = new ByteArrayOutputStream();
+ ObjectOutputStream objectOutput;
+ objectOutput = new ObjectOutputStream(byteOutput);
+ objectOutput.writeObject(defaultConfig);
+ ByteArrayInputStream byteInput = new ByteArrayInputStream(byteOutput.toByteArray());
+ ObjectInputStream objectInput = new ObjectInputStream(byteInput);
+ deepCopy = objectInput.readObject();
+ } catch (Exception e) {
+ logError("Creation of default Wimba Classroom configuration failed.", e);
+ }
+ WimbaClassroomConfiguration newConfig = (WimbaClassroomConfiguration) deepCopy;
+
+ return newConfig;
+ }
+
+ /**
+ * Creates Wimba Classroom specific direct access URLs for several services
+ * @param target
+ * @param roomId
+ * @return
+ */
+ protected String createServiceUrl(String target, String roomId) {
+ StringBuilder sb = new StringBuilder();
+ sb.append(getProtocol()).append("://").append(getBaseUrl()).append(":").append(getPort());
+ String classId = PREFIX + roomId;
+ String hzA = "&hzA=" + token;
+ if(target.equals(TARGET_OPEN_WIZARD)) {
+ sb.append(ENDPOINT_WIZARD);
+ } else if(target.equals(TARGET_OPEN_MANAGEROOM)) {
+ sb.append("/admin/api/class/carousels?class_id=");
+ sb.append(classId);
+ sb.append(hzA);
+ } else if(target.equals(TARGET_OPEN_POLLRESULTS)) {
+ sb.append("/admin/api/class/results?class_id=");
+ sb.append(classId);
+ sb.append(hzA);
+ } else if(target.equals(TARGET_OPEN_TRACKING)) {
+ sb.append("/admin/api/server/tracking?mode=detailed&popup=1&channel=");
+ sb.append(classId);
+ sb.append(hzA);
+ } else if(target.equals(TARGET_OPEN_ROOMSETTINGS)) {
+ sb.append("/admin/api/class/properties.pl?class_id=");
+ sb.append(classId);
+ sb.append(hzA);
+ } else if(target.equals(TARGET_OPEN_MEDIASETTINGS)) {
+ sb.append("/admin/api/class/media.pl?class_id=");
+ sb.append(classId);
+ sb.append(hzA);
+ }
+ sb.append("&no_sidebar=1");
+
+ return sb.toString();
+ }
+
+ /////////////////////////////
+ // internal helper methods //
+ /////////////////////////////
+
+ private boolean evaluateOk(WimbaResponse response) {
+ return response.getStatus().equals(StatusCode.OK);
+ }
+
+ private WimbaResponse getResponseDocument(String rawResponse) {
+ StringReader input = new StringReader(rawResponse);
+ LineNumberReader reader = new LineNumberReader(input);
+
+ WimbaResponse response = new WimbaResponse();
+ String line;
+ Map<String, String> record = new HashMap<String, String>();
+ try {
+ // start with status code in first line
+ line = reader.readLine();
+ response.setStatus(getStatusCode(line));
+ // read the records following
+ while( (line=reader.readLine()) != null ) {
+ if(line.equals(DELIM)) {
+ // end of record
+ response.addRecord(record);
+ record = new HashMap<String, String>();
+ } else {
+ // regular part of a record
+ String[] elem = line.split("=", 2);
+ record.put(elem[0], elem[1]);
+ }
+ }
+ } catch (IOException e) {
+ logError("The Wimba Classroom response could not parsed. Raw response: " + rawResponse, e);
+ }
+
+ return response;
+ }
+
+ /**
+ * @param line
+ */
+ private int getStatusCode(String line) {
+ int code = StatusCode.UNDEFINED.getCode();
+ String extracted = line.split(" ", 2)[0];
+ if(extracted != null && !extracted.isEmpty()) {
+ try {
+ code = Integer.parseInt(extracted);
+ } catch(NumberFormatException e) {
+ // nothing to do since code is pre-set
+ }
+ }
+ return code;
+ }
+
+ private String sendRequest(Map<String, String> parameters) {
+ URL url = createRequestUrl(parameters);
+ HttpURLConnection urlConn;
+
+ try {
+ urlConn = (HttpURLConnection) url.openConnection();
+ // setup url connection
+ urlConn.setDoOutput(true);
+ urlConn.setUseCaches(false);
+ urlConn.setInstanceFollowRedirects(false);
+ // add content type
+ urlConn.setRequestProperty("Content-Type", CONTENT_TYPE);
+ // add cookie information
+ if(cookie != null) urlConn.setRequestProperty("Cookie", cookie);
+
+ // send request
+ urlConn.connect();
+
+ // detect redirect
+ int code = urlConn.getResponseCode();
+ boolean moved = code == HttpURLConnection.HTTP_MOVED_PERM | code == HttpURLConnection.HTTP_MOVED_TEMP;
+ if(moved) {
+ String location = urlConn.getHeaderField("Location");
+ List<String> headerVals = urlConn.getHeaderFields().get("Set-Cookie");
+ for(String val : headerVals) {
+ if(val.startsWith(COOKIE)) cookie = val;
+ }
+ url = createRedirectUrl(location);
+ urlConn = (HttpURLConnection) url.openConnection();
+ urlConn.setRequestProperty("Cookie", cookie);
+ }
+
+ // read response
+ BufferedReader input = new BufferedReader(new InputStreamReader(urlConn.getInputStream()));
+ StringBuilder response= new StringBuilder();
+ String line;
+ while( (line = input.readLine()) != null ) response.append(line).append("\n");
+ input.close();
+
+ if(isLogDebugEnabled()) logDebug("Response: " + response);
+
+ return response.toString();
+ } catch (IOException e) {
+ logError("Sending request to Wimba Classroom failed. Request: " + url.toString(), e);
+ return "";
+ }
+ }
+
+ private URL createRedirectUrl(String location) {
+ UriBuilder ubu = UriBuilder.fromUri(protocol + "://" + baseUrl).port(port).path(location);
+
+ URL url = null;
+ try {
+ url = ubu.build().toURL();
+ } catch (Exception e) {
+ logWarn("Error while creating redirect URL for Wimba Classroom request.", e);
+ // try to build the URL in a naiv way below
+ }
+ if(url == null) {
+ // error case, try the naiv way
+ try {
+ String urlString = new String(protocol + "://" + baseUrl + ":" + port + location);
+ url = new URL(urlString);
+ } catch (MalformedURLException e) {
+ logError("Error while creating URL for Wimba Classroom request. Please check the configuration!", e);
+ }
+ }
+
+ if(isLogDebugEnabled()) logDebug("Redirect: " + url);
+
+ return url;
+ }
+
+ private URL createRequestUrl(Map<String, String> parameters) {
+ UriBuilder ubu = UriBuilder.fromUri(protocol + "://" + baseUrl).port(port).path("admin").path("api").path("api.pl");
+
+ for(String key : parameters.keySet()) {
+ ubu.queryParam(key, parameters.get(key));
+ }
+
+ URL url = null;
+ try {
+ url = ubu.build().toURL();
+ } catch (Exception e) {
+ logWarn("Error while creating URL for Wimba Classroom request.", e);
+ // try to build the URL in a naiv way below
+ }
+ if(url == null) {
+ // error case, try the naiv way
+ try {
+ StringBuilder sb = new StringBuilder(protocol + "://" + baseUrl + ":" + port + "/admin/api/api.pl");
+ if(!parameters.isEmpty()) sb.append("?");
+ for(String key : parameters.keySet()) {
+ sb.append(key + "=" + parameters.get(key) + "&");
+ }
+ sb.replace(sb.length(), sb.length(), "");
+ url = new URL(sb.toString());
+ } catch (MalformedURLException e) {
+ logError("Error while creating URL for Wimba Classroom request. Please check the configuration!", e);
+ }
+ }
+
+ if(isLogDebugEnabled()) logDebug("Request: " + url);
+
+ return url;
+ }
+
+ private void handleError(StatusCode status, Throwable cause) {
+ logError("Request to Wimba Classroom returned error: " + status.getCode() + " (" + status.name() + ")", cause);
+ }
+
+ private String param(boolean bool) {
+ return bool ? "1" : "0";
+ }
+
+ @Override
+ public Map<String, String> getTemplates() {
+ // no support for templating meetings
+ return Collections.emptyMap();
+ }
+
+ ////////////////////////////
+ // setters used by spring //
+ ////////////////////////////
+ public void setEnabled(boolean enabled) {
+ this.enabled = enabled;
+ }
+
+ public void setProviderId(String providerId) {
+ this.providerId = providerId;
+ }
+
+ public void setDisplayName(String displayName) {
+ this.displayName = displayName;
+ }
+
+ public void setProtocol(String protocol) {
+ this.protocol = protocol;
+ }
+
+ public void setPort(int port) {
+ this.port = port;
+ }
+
+ public void setBaseUrl(String baseUrl) {
+ this.baseUrl = baseUrl;
+ }
+
+ public void setAdminLogin(String adminLogin) {
+ this.adminLogin = adminLogin;
+ }
+
+ public void setAdminPassword(String adminPassword) {
+ this.adminPassword = adminPassword;
+ }
+
+ public void setDefaultConfig(WimbaClassroomConfiguration config) {
+ defaultConfig = config;
+ defaultConfig.setProviderId(providerId);
+ }
+
+ /////////////////////////////
+ // getters used internally //
+ /////////////////////////////
+
+ protected String getProtocol() {
+ return protocol;
+ }
+
+ protected int getPort() {
+ return port;
+ }
+
+ protected String getBaseUrl() {
+ return baseUrl;
+ }
+
+ protected String getAdminLogin() {
+ return adminLogin;
+ }
+
+ protected String getAdminPassword() {
+ return adminPassword;
+ }
+
+ public WimbaClassroomConfiguration getDefaultConfig() {
+ return defaultConfig;
+ }
+
+}
+//</OLATCE-103>
\ No newline at end of file
diff --git a/src/main/java/de/bps/course/nodes/vc/provider/wimba/WimbaConfigController.java b/src/main/java/de/bps/course/nodes/vc/provider/wimba/WimbaConfigController.java
new file mode 100644
index 0000000000000000000000000000000000000000..b34cd836b84ca38bff0740cf93798869a5320e20
--- /dev/null
+++ b/src/main/java/de/bps/course/nodes/vc/provider/wimba/WimbaConfigController.java
@@ -0,0 +1,113 @@
+//<OLATCE-103>
+/**
+ *
+ * BPS Bildungsportal Sachsen GmbH<br>
+ * Bahnhofstrasse 6<br>
+ * 09111 Chemnitz<br>
+ * Germany<br>
+ *
+ * Copyright (c) 2005-2011 by BPS Bildungsportal Sachsen GmbH<br>
+ * http://www.bps-system.de<br>
+ *
+ * All rights reserved.
+ */
+package de.bps.course.nodes.vc.provider.wimba;
+
+import org.olat.core.gui.UserRequest;
+import org.olat.core.gui.components.Component;
+import org.olat.core.gui.components.link.Link;
+import org.olat.core.gui.components.link.LinkFactory;
+import org.olat.core.gui.components.velocity.VelocityContainer;
+import org.olat.core.gui.control.Controller;
+import org.olat.core.gui.control.Event;
+import org.olat.core.gui.control.WindowControl;
+import org.olat.core.gui.control.controller.BasicController;
+import org.olat.core.gui.media.RedirectMediaResource;
+
+/**
+ *
+ * Description:<br>
+ * Config controller to adjust settings of Wimba Classroom, e.g. for usage in course editor
+ *
+ * <P>
+ * Initial Date: 06.01.2011 <br>
+ * @author skoeber
+ */
+public class WimbaConfigController extends BasicController {
+
+ private static String COMMAND_OPEN_ROOMSETTINGS = WimbaClassroomProvider.TARGET_OPEN_ROOMSETTINGS;
+ private static String COMMAND_OPEN_MEDIASETTINGS = WimbaClassroomProvider.TARGET_OPEN_MEDIASETTINGS;
+
+ // GUI
+ private VelocityContainer editVC;
+ private WimbaEditForm editForm;
+ private Link openRoomSettings, openMediaSettings;
+
+ private WimbaClassroomProvider wimba;
+ private WimbaClassroomConfiguration config;
+ private String roomId;
+
+ protected WimbaConfigController(UserRequest ureq, WindowControl wControl, String roomId, WimbaClassroomProvider wimba, WimbaClassroomConfiguration config) {
+ super(ureq, wControl);
+ this.wimba = wimba;
+ this.config = config;
+ this.roomId = roomId;
+
+ editVC = createVelocityContainer("edit");
+ editForm = new WimbaEditForm(ureq, wControl, config);
+ listenTo(editForm);
+ editVC.put("editForm", editForm.getInitialComponent());
+
+ openRoomSettings = LinkFactory.createButton(COMMAND_OPEN_ROOMSETTINGS, editVC, this);
+ openMediaSettings = LinkFactory.createButton(COMMAND_OPEN_MEDIASETTINGS, editVC, this);
+ openRoomSettings.setTarget("_blank");
+ openMediaSettings.setTarget("_blank");
+
+ putInitialPanel(editVC);
+ }
+
+ @Override
+ protected void event(UserRequest ureq, Controller source, Event event) {
+ if(source == editForm) {
+ fireEvent(ureq, event);
+ }
+ }
+
+ @Override
+ protected void event(UserRequest ureq, Component source, Event event) {
+ if(source == openRoomSettings | source == openMediaSettings) {
+ boolean exists = wimba.existsClassroom(roomId, config);
+ if(exists) {
+ openWimbaUrl(ureq, ((Link)source).getCommand());
+ } else {
+ // normally this case should not occure, but be failsafe and show msg
+ getWindowControl().setError("error.no.room");
+ }
+ return;
+ }
+ }
+
+ private void openWimbaUrl(UserRequest ureq, String target) {
+ boolean success = wimba.createModerator(ureq.getIdentity(), roomId);
+ if(success) {
+ wimba.login(ureq.getIdentity(), null);
+ String url = wimba.createServiceUrl(target, roomId);
+ RedirectMediaResource rmr = new RedirectMediaResource(url);
+ ureq.getDispatchResult().setResultingMediaResource(rmr);
+ } else {
+ // could not create moderator or update the rights
+ getWindowControl().setError(translate("error.update.rights"));
+ return;
+ }
+ }
+
+ @Override
+ protected void doDispose() {
+ if(editForm != null) {
+ removeAsListenerAndDispose(editForm);
+ editForm = null;
+ }
+ }
+
+}
+//</OLATCE-103>
\ No newline at end of file
diff --git a/src/main/java/de/bps/course/nodes/vc/provider/wimba/WimbaDisplayController.java b/src/main/java/de/bps/course/nodes/vc/provider/wimba/WimbaDisplayController.java
new file mode 100644
index 0000000000000000000000000000000000000000..c4c74e55c8d729ac58724e10c87c17788c01c816
--- /dev/null
+++ b/src/main/java/de/bps/course/nodes/vc/provider/wimba/WimbaDisplayController.java
@@ -0,0 +1,388 @@
+//<OLATCE-103>
+/**
+ *
+ * BPS Bildungsportal Sachsen GmbH<br>
+ * Bahnhofstrasse 6<br>
+ * 09111 Chemnitz<br>
+ * Germany<br>
+ *
+ * Copyright (c) 2005-2011 by BPS Bildungsportal Sachsen GmbH<br>
+ * http://www.bps-system.de<br>
+ *
+ * All rights reserved.
+ */
+package de.bps.course.nodes.vc.provider.wimba;
+
+import java.net.URL;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+
+import org.olat.core.gui.UserRequest;
+import org.olat.core.gui.components.Component;
+import org.olat.core.gui.components.link.Link;
+import org.olat.core.gui.components.link.LinkFactory;
+import org.olat.core.gui.components.table.DefaultColumnDescriptor;
+import org.olat.core.gui.components.table.StaticColumnDescriptor;
+import org.olat.core.gui.components.table.TableController;
+import org.olat.core.gui.components.table.TableDataModel;
+import org.olat.core.gui.components.table.TableEvent;
+import org.olat.core.gui.components.table.TableGuiConfiguration;
+import org.olat.core.gui.components.velocity.VelocityContainer;
+import org.olat.core.gui.control.Controller;
+import org.olat.core.gui.control.Event;
+import org.olat.core.gui.control.WindowControl;
+import org.olat.core.gui.control.controller.BasicController;
+import org.olat.core.gui.media.RedirectMediaResource;
+import org.olat.core.gui.translator.Translator;
+
+/**
+ *
+ * Description:<br>
+ * Display controller for Wimba Classroom usage at run-time
+ *
+ * <P>
+ * Initial Date: 06.01.2011 <br>
+ * @author skoeber
+ */
+public class WimbaDisplayController extends BasicController {
+
+ private static String COMMAND_JOIN_MODERATOR = "cmd.join.moderator";
+ private static String COMMAND_JOIN_LEARNER = "cmd.join.learner";
+ private static String COMMAND_JOIN_GUEST = "cmd.join.guest";
+ private static String COMMAND_START_MEETING = "cmd.start.meeting";
+ private static String COMMAND_CLOSE_MEETING = "cmd.close.meeting";
+ private static String COMMAND_UNCLOSE_MEETING = "cmd.unclose.meeting";
+ private static String COMMAND_UPDATE_MEETING = "cmd.update.meeting";
+ private static String COMMAND_OPEN_MANAGEROOM = WimbaClassroomProvider.TARGET_OPEN_MANAGEROOM;
+ private static String COMMAND_OPEN_POLLRESULTS = WimbaClassroomProvider.TARGET_OPEN_POLLRESULTS;
+ private static String COMMAND_OPEN_TRACKING = WimbaClassroomProvider.TARGET_OPEN_TRACKING;
+ private static String COMMAND_OPEN_WIZARD = WimbaClassroomProvider.TARGET_OPEN_WIZARD;
+ private static String COMMAND_OPEN_RECORDING = "cmd.open.recording";
+ private static String COMMAND_TOGGLESTATUS_RECORDING = "cmd.togglestatus.recording";
+ private static String COMMAND_DELETE_RECORDING = "cmd.delete.recording";
+
+ // GUI
+ private VelocityContainer runVC;
+ private Link joinModerator, joinLearner, joinGuest;
+ private Link startMeeting, closeMeeting, uncloseMeeting, updateMeeting;
+ private Link openWizard, openManageRoom, openPollResults, openTracking;
+ private TableController recTable;
+
+ //data
+ private WimbaClassroomConfiguration config;
+ private String name, description;
+ private String roomId;
+ private RecordingsTableModel recTableModel;
+
+ private WimbaClassroomProvider wimba;
+
+ protected WimbaDisplayController(UserRequest ureq, WindowControl wControl, String roomId, String name, String description, boolean isModerator,
+ WimbaClassroomConfiguration config, WimbaClassroomProvider provider) {
+ super(ureq, wControl);
+ this.wimba = provider;
+ this.config = config;
+ this.roomId = roomId;
+ this.name = name;
+ this.description = description;
+
+ runVC = createVelocityContainer("run");
+
+ boolean exists = wimba.existsClassroom(roomId, config);
+ boolean closed = exists ? wimba.isPreviewMode(roomId, false) : false;
+ boolean isGuest = ureq.getUserSession().getRoles().isGuestOnly();
+ boolean showGuestLink = config.isGuestAccessAllowed();
+
+ if(isModerator) {
+ wimba.createModerator(ureq.getIdentity(), roomId);
+ } else if(!isGuest) {
+ wimba.createUser(ureq.getIdentity(), roomId);
+ }
+
+ String guestLink = wimba.createClassroomGuestUrl(roomId, ureq.getIdentity(), config).toString();
+
+ joinModerator = LinkFactory.createButton(COMMAND_JOIN_MODERATOR, runVC, this);
+ joinLearner = LinkFactory.createButton(COMMAND_JOIN_LEARNER, runVC, this);
+ joinGuest = LinkFactory.createButton(COMMAND_JOIN_GUEST, runVC, this);
+ startMeeting = LinkFactory.createButton(COMMAND_START_MEETING, runVC, this);
+ closeMeeting = LinkFactory.createButton(COMMAND_CLOSE_MEETING, runVC, this);
+ uncloseMeeting = LinkFactory.createButton(COMMAND_UNCLOSE_MEETING, runVC, this);
+ updateMeeting = LinkFactory.createButton(COMMAND_UPDATE_MEETING, runVC, this);
+ // set target to be able to open new browser window on event
+ joinGuest.setTarget("_blank");
+ joinLearner.setTarget("_blank");
+ joinModerator.setTarget("_blank");
+
+ joinLearner.setEnabled(!closed);
+ joinGuest.setEnabled(!closed);
+
+ runVC.contextPut("exists", exists);
+ runVC.contextPut("closed", closed);
+ runVC.contextPut("isGuest", isGuest);
+ runVC.contextPut("isModerator", isModerator);
+ runVC.contextPut("showGuestLink", showGuestLink);
+ runVC.contextPut("guestLink", guestLink);
+
+ // convenience links
+ openWizard = LinkFactory.createButton(COMMAND_OPEN_WIZARD, runVC, this);
+ openWizard.setTarget("_blank");
+
+ // moderator links
+ if(isModerator) {
+ openManageRoom = LinkFactory.createButton(COMMAND_OPEN_MANAGEROOM, runVC, this);
+ openPollResults = LinkFactory.createButton(COMMAND_OPEN_POLLRESULTS, runVC, this);
+ openTracking = LinkFactory.createButton(COMMAND_OPEN_TRACKING, runVC, this);
+ openManageRoom.setTarget("_blank");
+ openPollResults.setTarget("_blank");
+ openTracking.setTarget("_blank");
+ }
+
+ // show recordings
+ TableGuiConfiguration tableConfig = new TableGuiConfiguration();
+ tableConfig.setColumnMovingOffered(false);
+ tableConfig.setDisplayRowCount(true);
+ tableConfig.setPageingEnabled(true);
+ tableConfig.setTableEmptyMessage(translate("table.recordings.empty"));
+ recTable = new TableController(tableConfig, ureq, wControl, getTranslator());
+ DefaultColumnDescriptor recCol = new DefaultColumnDescriptor("table.recordings.name", 1, COMMAND_OPEN_RECORDING, getLocale());
+ recCol.setIsPopUpWindowAction(true, null);
+ recTable.addColumnDescriptor(recCol);
+ if(isModerator) {
+ recTable.addColumnDescriptor(new DefaultColumnDescriptor("table.recordings.status", 2, COMMAND_TOGGLESTATUS_RECORDING, getLocale()));
+ recTable.addColumnDescriptor(new StaticColumnDescriptor(COMMAND_DELETE_RECORDING, "table.recordings.action", translate("table.recordings.delete")));
+ }
+ Map<String, String> recordings = wimba.listRecordings(roomId);
+ List<String> keys = new ArrayList<String>(recordings.keySet());
+ Collections.sort(keys);
+ List<Object[]> recordingData = new ArrayList<Object[]>();
+ for(String key : keys) {
+ String title = recordings.get(key);
+ boolean preview = wimba.isPreviewMode(key, true);
+ /*
+ * for moderators: add all recordings and show actions
+ * for users: add only recordings that are not in preview mode
+ */
+ if(!preview | isModerator) recordingData.add(new Object[] {key, title, preview});
+ }
+ recTableModel = new RecordingsTableModel(recordingData, getTranslator());
+ recTable.setTableDataModel(recTableModel);
+ listenTo(recTable);
+ runVC.put("recordingsTable", recTable.getInitialComponent());
+
+ putInitialPanel(runVC);
+ }
+
+ @Override
+ protected void event(UserRequest ureq, Component source, Event event) {
+ if(source == startMeeting) {
+ boolean success = wimba.createClassroom(roomId, name, description, null, null, config);
+ if(success) {
+ runVC.contextPut("exists", true);
+ runVC.setDirty(true);
+ } else {
+ getWindowControl().setError(translate("error.create.room"));
+ }
+ } else if(source == joinModerator) {
+ boolean success = wimba.existsClassroom(roomId, config);
+ // update rights for user to moderate meeting
+ if(success) {
+ success = wimba.createModerator(ureq.getIdentity(), roomId);
+ } else {
+ // room not found, should not appear
+ getWindowControl().setError(translate("error.no.room"));
+ return;
+ }
+ // login the user as moderator
+ if(success) {
+ success = wimba.login(ureq.getIdentity(), null);
+ } else {
+ // could not create moderator or update the rights
+ getWindowControl().setError(translate("error.update.rights"));
+ return;
+ }
+ // redirect to the meeting
+ if(success) {
+ joinMeeting(ureq, false);
+ } else {
+ // login failed
+ getWindowControl().setError(translate("error.no.login"));
+ return;
+ }
+ return;
+ } else if(source == joinLearner) {
+ joinMeeting(ureq, false);
+ return;
+ } else if(source == joinGuest) {
+ joinMeeting(ureq, true);
+ return;
+ } else if(source == closeMeeting) {
+ boolean success = wimba.setPreviewMode(roomId, true, false);
+ if(success) {
+ runVC.contextPut("closed", true);
+ runVC.setDirty(true);
+ } else {
+ // closing failed
+ getWindowControl().setError(translate("error.remove.room"));
+ }
+ } else if(source == uncloseMeeting) {
+ boolean success = wimba.setPreviewMode(roomId, false, false);
+ if(success) {
+ runVC.contextPut("closed", false);
+ runVC.setDirty(true);
+ } else {
+ // reopen failed
+ getWindowControl().setError(translate("error.update.room"));
+ }
+ } else if(source == updateMeeting) {
+ boolean success = wimba.updateClassroom(roomId, name, description, null, null, config);
+ if(success) {
+ getWindowControl().setInfo(translate("success.update.room"));
+ } else {
+ // update failed
+ getWindowControl().setError(translate("error.update.room"));
+ }
+ } else if(source == openWizard | source == openManageRoom | source == openPollResults | source == openTracking) {
+ openWimbaUrl(ureq, ((Link)source).getCommand());
+ return;
+ }
+ }
+
+ @Override
+ protected void event(UserRequest ureq, Controller source, Event event) {
+ if(source == recTable) {
+ if(event instanceof TableEvent) {
+ TableEvent tEvent = (TableEvent)event;
+ String action = tEvent.getActionId();
+ int row = tEvent.getRowId();
+ String key = (String) recTable.getTableDataModel().getValueAt(row, 0);
+ if(action.equals(COMMAND_OPEN_RECORDING)) {
+ wimba.login(ureq.getIdentity(), null);
+ URL url = wimba.createClassroomRecordingUrl(key, ureq.getIdentity(), config);
+ RedirectMediaResource rmr = new RedirectMediaResource(url.toString());
+ ureq.getDispatchResult().setResultingMediaResource(rmr);
+ return;
+ } else if(action.equals(COMMAND_TOGGLESTATUS_RECORDING)) {
+ Object[] entry = (Object[]) recTable.getTableDataModel().getObject(row);
+ Boolean preview = (Boolean) entry[2];
+ if(wimba.setPreviewMode(key, !preview, true)) {
+ String text = preview ? "table.recordings.unclose.success" : "table.recordings.close.success";
+ getWindowControl().setInfo(translate(text));
+ recTableModel.toggleStatus(row);
+ recTable.modelChanged();
+ runVC.setDirty(true);
+ } else {
+ String text = preview ? "table.recordings.unclose.error" : "table.recordings.close.error";
+ getWindowControl().setError(translate(text));
+ }
+ } else if(action.equals(COMMAND_DELETE_RECORDING)) {
+ if(wimba.removeClassroomRecording(key, config)) {
+ getWindowControl().setInfo(translate("table.recordings.delete.success"));
+ recTableModel.removeRecording(row);
+ recTable.modelChanged();
+ runVC.setDirty(true);
+ } else {
+ getWindowControl().setError(translate("table.recordings.delete.error"));
+ }
+ }
+ }
+ }
+ }
+
+ private void openWimbaUrl(UserRequest ureq, String target) {
+ boolean success = wimba.createModerator(ureq.getIdentity(), roomId);
+ if(success) {
+ wimba.login(ureq.getIdentity(), null);
+ String url = wimba.createServiceUrl(target, roomId);
+ RedirectMediaResource rmr = new RedirectMediaResource(url);
+ ureq.getDispatchResult().setResultingMediaResource(rmr);
+ } else {
+ // could not create moderator or update the rights
+ getWindowControl().setError(translate("error.update.rights"));
+ return;
+ }
+ }
+
+ private void joinMeeting(UserRequest ureq, boolean guest) {
+ URL url;
+ if(guest) {
+ url = wimba.createClassroomGuestUrl(roomId, ureq.getIdentity(), config);
+ } else {
+ boolean success = wimba.login(ureq.getIdentity(), null);
+ // no success, maybe the user account doesn't exist, create it and try the login again
+ if(!success) wimba.createUser(ureq.getIdentity(), roomId);
+ wimba.login(ureq.getIdentity(), null);
+ url = wimba.createClassroomUrl(roomId, ureq.getIdentity(), config);
+ }
+ RedirectMediaResource rmr = new RedirectMediaResource(url.toString());
+ ureq.getDispatchResult().setResultingMediaResource(rmr);
+ }
+
+ @Override
+ protected void doDispose() {
+ // nothing to dispose
+ }
+
+}
+
+class RecordingsTableModel implements TableDataModel {
+
+ private List<Object[]> recordings = new ArrayList<Object[]>();
+ private Translator translator;
+
+ public RecordingsTableModel(List<Object[]> recordings, Translator translator) {
+ this.recordings.addAll(recordings);
+ this.translator = translator;
+ }
+
+ @Override
+ public int getColumnCount() {
+ return 2;
+ }
+
+ @Override
+ public int getRowCount() {
+ return recordings.size();
+ }
+
+ @Override
+ public Object getValueAt(int row, int col) {
+ Object[] recording = this.recordings.get(row);
+ switch(col) {
+ case 0: return recording[col];//key
+ case 1: return recording[col];//title
+ case 2: //action string depending on status
+ Boolean preview = (Boolean) recording[col];
+ return preview
+ ? translator.translate("table.recordings.unclose")
+ : translator.translate("table.recordings.close");
+ default: return recording[col];
+ }
+ }
+
+ @Override
+ public Object getObject(int row) {
+ return recordings.get(row);
+ }
+
+ @Override
+ public void setObjects(List objects) {
+ this.recordings = objects;
+ }
+
+ @Override
+ public Object createCopyWithEmptyList() {
+ // not used
+ return "";
+ }
+
+ public void removeRecording(int row) {
+ this.recordings.remove(row);
+ }
+
+ public void toggleStatus(int row) {
+ Boolean status = (Boolean) this.recordings.get(row)[2];
+ this.recordings.get(row)[2] = !status;
+ }
+}
+//</OLATCE-103>
diff --git a/src/main/java/de/bps/course/nodes/vc/provider/wimba/WimbaEditForm.java b/src/main/java/de/bps/course/nodes/vc/provider/wimba/WimbaEditForm.java
new file mode 100644
index 0000000000000000000000000000000000000000..7c19cc7a6c5ec2872825783056eeaa13b5b15994
--- /dev/null
+++ b/src/main/java/de/bps/course/nodes/vc/provider/wimba/WimbaEditForm.java
@@ -0,0 +1,78 @@
+//<OLATCE-103>
+/**
+ *
+ * BPS Bildungsportal Sachsen GmbH<br>
+ * Bahnhofstrasse 6<br>
+ * 09111 Chemnitz<br>
+ * Germany<br>
+ *
+ * Copyright (c) 2005-2011 by BPS Bildungsportal Sachsen GmbH<br>
+ * http://www.bps-system.de<br>
+ *
+ * All rights reserved.
+ */
+package de.bps.course.nodes.vc.provider.wimba;
+
+import org.olat.core.gui.UserRequest;
+import org.olat.core.gui.components.form.flexible.FormItemContainer;
+import org.olat.core.gui.components.form.flexible.elements.MultipleSelectionElement;
+import org.olat.core.gui.components.form.flexible.impl.FormBasicController;
+import org.olat.core.gui.components.form.flexible.impl.elements.FormSubmit;
+import org.olat.core.gui.control.Controller;
+import org.olat.core.gui.control.WindowControl;
+import org.olat.course.editor.NodeEditController;
+
+/**
+ *
+ * Description:<br>
+ * Edit form for date list and Wimba Classroom specific configuration
+ *
+ * <P>
+ * Initial Date: 12.01.2011 <br>
+ * @author skoeber
+ */
+public class WimbaEditForm extends FormBasicController {
+
+ // GUI
+ private FormSubmit submit;
+ private MultipleSelectionElement multiSelectOptions;
+ private static String OPTION_GUEST_ACCESS = "vc.guest.access";
+
+ // data
+ private WimbaClassroomConfiguration config;
+
+ public WimbaEditForm(UserRequest ureq, WindowControl wControl, WimbaClassroomConfiguration config) {
+ super(ureq, wControl, FormBasicController.LAYOUT_VERTICAL);
+ this.config = config;
+
+ initForm(this.flc, this, ureq);
+ }
+
+ @Override
+ protected void initForm(FormItemContainer formLayout, Controller listener, UserRequest ureq) {
+
+ // options
+ String[] optionKeys = new String[] {OPTION_GUEST_ACCESS};
+ String[] optionVals = new String[] {translate(OPTION_GUEST_ACCESS)};
+ multiSelectOptions = uifactory.addCheckboxesVertical("vc.options", "vc.options.label", formLayout, optionKeys, optionVals, null, 1);
+ multiSelectOptions.select(OPTION_GUEST_ACCESS, config.isGuestAccessAllowed());
+ multiSelectOptions.showLabel(false);
+
+ submit = new FormSubmit("subm", "submit");
+
+ formLayout.add(submit);
+ }
+
+ @Override
+ protected void formOK(UserRequest ureq) {
+ config.setGuestAccessAllowed(multiSelectOptions.getSelectedKeys().contains(OPTION_GUEST_ACCESS));
+ fireEvent(ureq, NodeEditController.NODECONFIG_CHANGED_EVENT);
+ }
+
+ @Override
+ protected void doDispose() {
+ // nothing to dispose
+ }
+
+}
+//<OLATCE-103>
diff --git a/src/main/java/de/bps/course/nodes/vc/provider/wimba/WimbaResponse.java b/src/main/java/de/bps/course/nodes/vc/provider/wimba/WimbaResponse.java
new file mode 100644
index 0000000000000000000000000000000000000000..ac7ddfddd1583282587e2c76eb84b3eb11f8ca88
--- /dev/null
+++ b/src/main/java/de/bps/course/nodes/vc/provider/wimba/WimbaResponse.java
@@ -0,0 +1,92 @@
+//<OLATCE-103>
+/**
+ *
+ * BPS Bildungsportal Sachsen GmbH<br>
+ * Bahnhofstrasse 6<br>
+ * 09111 Chemnitz<br>
+ * Germany<br>
+ *
+ * Copyright (c) 2005-2011 by BPS Bildungsportal Sachsen GmbH<br>
+ * http://www.bps-system.de<br>
+ *
+ * All rights reserved.
+ */
+package de.bps.course.nodes.vc.provider.wimba;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+/**
+ *
+ * Description:<br>
+ * Response object for API calls to Wimba Classroom
+ *
+ * <P>
+ * Initial Date: 07.01.2011 <br>
+ * @author skoeber
+ */
+public class WimbaResponse {
+
+ private StatusCode status = StatusCode.UNDEFINED;
+ private List<Map<String, String>> records = new ArrayList<Map<String,String>>();
+
+ /*
+ * several constructors for efficiency
+ */
+
+ public WimbaResponse() {
+ //
+ }
+
+ public WimbaResponse(StatusCode status) {
+ setStatus(status);
+ }
+
+ public WimbaResponse(int code) {
+ setStatus(code);
+ }
+
+ protected StatusCode getStatus() {
+ return status;
+ }
+
+ protected void setStatus(StatusCode status) {
+ this.status = status;
+ }
+
+ protected void setStatus(int code) {
+ this.status = StatusCode.getStatus(code);
+ }
+
+ protected void addRecord(Map<String, String> record) {
+ records.add(record);
+ }
+
+ protected List<Map<String, String>> getRecords() {
+ return records;
+ }
+
+ /**
+ * Will return the first value found, but there may be more than this one
+ * @param key
+ * @return value found or <code>null</code>
+ */
+ protected String findRecord(String key) {
+ String value = null;
+ for(Map<String, String> record : records) {
+ value = record.get(key);
+ }
+ return value;
+ }
+
+ protected boolean hasRecords() {
+ return !records.isEmpty();
+ }
+
+ protected int numRecords() {
+ return records.size();
+ }
+
+}
+//</OLATCE-103>
\ No newline at end of file
diff --git a/src/main/java/de/bps/course/nodes/vc/provider/wimba/_chelp/ced-vc-config.html b/src/main/java/de/bps/course/nodes/vc/provider/wimba/_chelp/ced-vc-config.html
new file mode 100644
index 0000000000000000000000000000000000000000..adc858afa765afe8c30f8223b5377bf518a9eb0d
--- /dev/null
+++ b/src/main/java/de/bps/course/nodes/vc/provider/wimba/_chelp/ced-vc-config.html
@@ -0,0 +1,5 @@
+<!-- <OLATCE-103> -->
+<p>$r.translate("chelp.vc1")</p>
+<p>$r.translate("chelp.vc2")</p>
+<p>$r.translate("chelp.vc3")</p>
+<!-- </OLATCE-103> -->
\ No newline at end of file
diff --git a/src/main/java/de/bps/course/nodes/vc/provider/wimba/_content/edit.html b/src/main/java/de/bps/course/nodes/vc/provider/wimba/_content/edit.html
new file mode 100644
index 0000000000000000000000000000000000000000..3950a4b95d3ece44a66c3b2becba83bb7ec005e3
--- /dev/null
+++ b/src/main/java/de/bps/course/nodes/vc/provider/wimba/_content/edit.html
@@ -0,0 +1,7 @@
+<!-- <OLATCE-103> -->
+$r.contextHelpWithWrapper("de.bps.course.nodes.vc.provider.wimba","ced-vc-config.html","chelp.hover.vc.config")
+$r.render("cmd.open.roomsettings")
+<!-- $r.render("cmd.open.mediasettings") -->
+
+$r.render("editForm")
+<!-- </OLATCE-103> -->
\ No newline at end of file
diff --git a/src/main/java/de/bps/course/nodes/vc/provider/wimba/_content/run.html b/src/main/java/de/bps/course/nodes/vc/provider/wimba/_content/run.html
new file mode 100644
index 0000000000000000000000000000000000000000..9458271c7a53ac5f0364857528bf19da6093f094
--- /dev/null
+++ b/src/main/java/de/bps/course/nodes/vc/provider/wimba/_content/run.html
@@ -0,0 +1,58 @@
+<!-- <OLATCE-103> -->
+#if($exists)
+ #if($closed)
+ <p class="b_warning">$r.translate("meeting.status")</p>
+ #end
+
+ #if($isModerator)
+ #if(!$closed)
+ <p>$r.translate("cmd.join.moderator.intro")</p>
+ #end
+ <p>
+ $r.render("cmd.join.moderator")
+ </p>
+ $r.render("recordingsTable")
+ <div class="b_info">
+ <p><strong>$r.translate("title.options")</strong></p>
+ #if($showGuestLink)
+ <p>$r.translate("description.guestlink")
+ <pre>$guestLink</pre></p>
+ <br/>
+ #end
+ #if($closed)
+ ##<p class="b_warning">$r.translate("meeting.status")</p>
+ $r.render("cmd.unclose.meeting")
+ #else
+ $r.render("cmd.close.meeting")
+ #end
+ ##$r.render("cmd.update.meeting")
+ $r.render("cmd.open.manageroom")
+ $r.render("cmd.open.pollresults")
+ ##$r.render("cmd.open.tracking")
+ </div>
+ #else
+ #if($isGuest && $showGuestLink)
+ $r.render("cmd.join.guest")
+ #else
+ #if(!$closed)
+ <p>$r.translate("cmd.join.learner.intro")</p>
+ #end
+ $r.render("cmd.join.learner")
+ <p>
+ $r.render("recordingsTable")
+ </p>
+ #end
+ #end
+#else
+ #if($isModerator)
+ <p>$r.translate("cmd.start.meeting.intro")</p>
+ $r.render("cmd.start.meeting")
+ #else
+ <p>$r.translate("cmd.join.learner.wait")</p>
+ #end
+#end
+<div class="b_info">
+<p>$r.translate("cmd.open.wizard.intro")</p>
+$r.render("cmd.open.wizard")
+</div>
+<!-- </OLATCE-103> -->
\ No newline at end of file
diff --git a/src/main/java/de/bps/course/nodes/vc/provider/wimba/_i18n/LocalStrings_de.properties b/src/main/java/de/bps/course/nodes/vc/provider/wimba/_i18n/LocalStrings_de.properties
new file mode 100644
index 0000000000000000000000000000000000000000..c61a7a56f83f497dd1a9ffc1e8c7dc79473058c9
--- /dev/null
+++ b/src/main/java/de/bps/course/nodes/vc/provider/wimba/_i18n/LocalStrings_de.properties
@@ -0,0 +1,61 @@
+#<OLATCE-103>
+vc.options.label=Optionen
+vc.guest.access=Gastzugang erlauben
+
+cmd.close.meeting=Virtuelles Klassenzimmer schlie\u00dfen
+cmd.unclose.meeting=Virtuelles Klassenzimmer \u00f6ffnen
+cmd.delete.recording=Aufzeichnung l\u00f6schen
+cmd.join.guest=Meeting als Gast betreten
+cmd.join.moderator=Meeting moderieren
+cmd.join.moderator.intro=Das virtuelle Klassenzimmer ist ge\u00f6ffnet. Sie k\u00f6nnen das Meeting moderieren. Teilnehmer k\u00f6nnen dem Meeting ohne Zustimmung eines Moderators ggf. nicht beitreten.
+cmd.join.learner=Klassenzimmer betreten
+cmd.join.learner.intro=Das virtuelle Klassenzimmer kann betreten werden.
+cmd.join.learner.wait=Das virtuelle Klassenzimmer wurde noch nicht er\u00f6ffnet.
+cmd.open.manageroom=Rauminhalte verwalten
+cmd.open.pollresults=Umfrageergebnisse einsehen
+cmd.open.recording=Aufzeichnung starten
+cmd.open.tracking=Tracking
+cmd.open.roomsettings=Raumkonfiguration
+cmd.open.mediasettings=Medienkonfiguration
+cmd.open.wizard=Setup-Wizard starten
+cmd.open.wizard.intro=Benutzen Sie den Setup Wizard um sicherzustellen, dass ihr Computer f\u00fcr die Benutzung von Wimba Classroom vorbereitet ist.
+cmd.start.meeting=Meeting starten
+cmd.start.meeting.intro=Das virtuelle Klassenzimmer wurde noch nicht ge\u00f6ffnet. Teilnehmer k\u00f6nnen einem geplanten Meeting je nach Konfiguration ggf. noch nicht beitreten.
+cmd.update.meeting=Konfiguration synchronisieren
+description.guestlink=Der Gastzugang f\u00fcr dieses Meeting ist erlaubt. Folgender Link erm\u00f6glicht den direkten Zugang zum virtuellen Klassenzimmer als Gast:
+title.options=Erweiterte Optionen f\u00fcr Kursautoren
+
+table.recordings.empty=Es sind keine Aufzeichnungen f\u00fcr dieses virtuelle Klassenzimmer verf\u00fcgbar.
+table.recordings.name=Aufzeichnungen
+table.recordings.action=Aktion
+table.recordings.close=Aufzeichnung schlie\u00dfen
+table.recordings.close.error=Die Aufzeichnung konnte nicht geschlossen werden. Bitte wenden Sie sich an Ihren Betreuer oder Ihre Systemadministratoren.
+table.recordings.close.success=Aufzeichnung erfolgreich geschlossen
+table.recordings.delete=Aufzeichnung entfernen
+table.recordings.delete.error=Die Aufzeichnung konnte nicht entfernt werden. Bitte wenden Sie sich an Ihren Betreuer oder Ihre Systemadministratoren.
+table.recordings.delete.success=Aufzeichnung erfolgreich entfernt
+table.recordings.unclose=Aufzeichnung \u00f6ffnen
+table.recordings.unclose.error=Die Aufzeichnung konnte nicht ge\u00f6ffnet werden. Bitte wenden Sie sich an Ihren Betreuer oder Ihre Systemadministratoren.
+table.recordings.unclose.success=Aufzeichnung erfolgreich ge\u00f6ffnet
+table.recordings.status=Status \u00e4ndern
+
+error.no.room=Das virtuelle Klassenzimmer konnte nicht geladen werden. Bitte wenden Sie sich an Ihren Betreuer oder Ihre Systemadministratoren.
+error.no.login=Die Anmeldung war nicht erfolgreich. Bitte wenden Sie sich an Ihren Betreuer oder Ihre Systemadministratoren.
+error.create.room=Das virtuelle Klassenzimmer konnte nicht erzeugt werden. Bitte wenden Sie sich an Ihren Betreuer oder Ihre Systemadministratoren.
+error.close.room=Das virtuelle Klassenzimmer konnte nicht geschlossen werden. Bitte wenden Sie sich an Ihren Betreuer oder Ihre Systemadministratoren.
+error.remove.room=Das virtuelle Klassenzimmer konnte nicht entfernt werden. Bitte wenden Sie sich an Ihren Betreuer oder Ihre Systemadministratoren.
+error.update.room=Das virtuelle Klassenzimmer konnte nicht mit den aktuellen Einstellungen synchronisiert werden. Bitte wenden Sie sich an Ihren Betreuer oder Ihre Systemadministratoren.
+error.update.rights=Ihnen konnten nicht die notwendigen Rechte f\u00fcr dieses Meeting zugewiesen werden. Bitte wenden Sie sich an Ihren Betreuer oder Ihre Systemadministratoren.
+
+meeting.status=Das Meeting ist geschlossen und kann momentan nicht von Studenten betreten werden.
+
+sync.meeting.title=Virtuelles Klassenzimmer synchronisieren
+sync.meeting.text=Sie haben die Einstellungen f\u00fcr diese virtuelle Klassenzimmer ge\u00e4ndert, nachdem dieses er\u00f6ffnet wurde. Die \u00c4nderungen werden erst wirksam, wenn Sie das virtuelle Klassenzimmer mit den neuen Einstellungen synchronisieren. Die Einstellungen k\u00f6nnen auch jederzeit direkt im Kurs synchronisiert werden. M\u00f6chten Sie die Einstellungen jetzt synchronisieren?
+success.update.room=Das virtuelle Klassenzimmer wurde erfolgreich mit den aktuellen Einstellungen synchronisiert.
+
+chelp.ced-vc-config.title=Erweiterte Konfiguration (Wimba Classroom)
+chelp.hover.vc.config=Hilfe zur erweiterten Konfiguration des Virtuellen Klassenzimmers
+chelp.vc1=Mit Klick auf "Raumkonfiguration" \u00f6ffnet sich ein neues Fenster, in welchem Sie Ihr Wimba-Meeting vorkonfigurieren k\u00f6nnen. Aktivieren oder deaktivieren Sie z.B. den Chat, das eBoard oder die Archivierung des Meetings.
+chelp.vc2=Mit Klick auf "Medienkonfiguration" werden Ihnen technische Daten zu Ihrem Wimba-Meeting angezeigt.
+chelp.vc3=Sollen Nutzer auch anonym an Meetings teilnehmen d\u00fcrfen, aktivieren Sie bitte die Option "Gastzugang erlauben".
+#</OLATCE-103>
\ No newline at end of file
diff --git a/src/main/java/de/bps/course/nodes/vc/provider/wimba/_i18n/LocalStrings_en.properties b/src/main/java/de/bps/course/nodes/vc/provider/wimba/_i18n/LocalStrings_en.properties
new file mode 100644
index 0000000000000000000000000000000000000000..7f0571cccaefddb0510dff756f541002c28d3af6
--- /dev/null
+++ b/src/main/java/de/bps/course/nodes/vc/provider/wimba/_i18n/LocalStrings_en.properties
@@ -0,0 +1,60 @@
+#<OLATCE-103 OLATCE-619>
+vc.options.label=Options
+vc.guest.access=Allow access as guest (anonymously)
+
+cmd.close.meeting=Close virtual classroom
+cmd.unclose.meeting=Reopen virtual classroom
+cmd.delete.recording=Delete recording
+cmd.join.guest=Enter virtual classroom as guest
+cmd.join.moderator=Moderate virtual classroom
+cmd.join.moderator.intro=The virtual classroom has been opened. You may now enter the classroom and moderate the meeting. Participants might not be able to join the meeting until they are granted access by a moderator.
+cmd.join.learner=Enter virtual classroom
+cmd.join.learner.intro=You can join the virtual classroom.
+cmd.join.learner.wait=The virtual classroom has not been opened, yet. Please contact your tutor for any further information.
+cmd.open.manageroom=Manage room content
+cmd.open.pollresults=View survey results
+cmd.open.recording=Start recording
+cmd.open.tracking=Tracking
+cmd.open.roomsettings=Room settings
+cmd.open.mediasettings=Media settings
+cmd.open.wizard=Start setup wizard
+cmd.open.wizard.intro=Run the setup wizard to make sure that your computer is able to use the Wimba Classroom.
+cmd.start.meeting=Open virtual classroom
+cmd.start.meeting.intro=The virtual classroom has not been opened, yet. Participants might not be able to enter the classroom for a meeting.
+cmd.update.meeting=Syncronize configuration
+description.guestlink=Guest access for this meeting is allowed. The following link gives a direct access to the virtual classroom as a guest:
+title.options=Additional information and options for authors
+
+table.recordings.empty=There are no recordings available for this virtual classroom.
+table.recordings.name=Recordings
+table.recordings.action=Action
+table.recordings.close=Close recording
+table.recordings.close.error=Sorry! An error occured while removing the recording. Please inform your support or system administrator.
+table.recordings.close.success=Closed recording successfully
+table.recordings.delete=Remove recording
+table.recordings.delete.error=Sorry! An error occured while removing the recording. Please inform your support or system administrator.
+table.recordings.delete.success=Recording removed successfully
+table.recordings.unclose=Open recording
+table.recordings.unclose.error=Sorry! An error occured while opening the recording. Please inform your support or system administrator.
+table.recordings.unclose.success=Recording opened successfully
+table.recordings.status=Change status
+
+error.no.room=Sorry! An error occured while loading the virtual classroom. Please inform your tutor or system administrator.
+error.no.login=Login was not successfull. Please, contact your tutor or system administrator for any further questions.
+error.create.room=Sorry! An error occured while creating the virtual classroom. Please inform your tutor or system administrator.
+error.remove.room=Sorry! An error occured while removing the virtual class room. Please inform your tutor or system administrator.
+error.update.room=Sorry! An error occured while synchronizing the virtual class room with the actual configuration. Please inform your tutor or system administrator.
+error.update.rights=Sorry! An error occured while granting access to the virtual classroom. Please inform your tutor or system administrator.
+
+meeting.status=This virtual classroom ist currently closed. Students cannot access this room.
+
+sync.meeting.title=Synchronize virtual classroom
+sync.meeting.text=You have changed the configuration of the virtual classroom after it had been started. The changes will be taken into account only after having synchronized the virtual class room with the new configuration. You can synchronize the configuration at any time directly from the course run. Do you want to synchronize now?
+success.update.room=The virtual classroom has been synchronized successfully with its new configuration.
+
+chelp.ced-vc-config.title=Extended configuration (Wimba Classroom)
+chelp.hover.vc.config=Help about configuration of the virtual classroom
+chelp.vc1=Choose "Room settings" to pre-configure your wimba meeting room. Activate or deactivate chat, eboard, archiving etc.
+chelp.vc2=Choose "Media settings" to get technical information about your wimba meeting.
+chelp.vc3=If users may participate anonymously, please activate "Allow access as guest".
+#</OLATCE-103 OLATCE-619>
\ No newline at end of file
diff --git a/src/main/java/de/bps/course/nodes/vc/provider/wimba/_spring/wimbaContext.xml b/src/main/java/de/bps/course/nodes/vc/provider/wimba/_spring/wimbaContext.xml
new file mode 100644
index 0000000000000000000000000000000000000000..38168a031f2172ada6ff2aab7ec443442ce6d30c
--- /dev/null
+++ b/src/main/java/de/bps/course/nodes/vc/provider/wimba/_spring/wimbaContext.xml
@@ -0,0 +1,31 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<beans xmlns="http://www.springframework.org/schema/beans"
+ xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+ xmlns:context="http://www.springframework.org/schema/context"
+ xsi:schemaLocation="
+ http://www.springframework.org/schema/beans
+ http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
+ http://www.springframework.org/schema/context
+ http://www.springframework.org/schema/context/spring-context-3.0.xsd">
+
+ <bean id="wimbaDefaultConfig" class="de.bps.course.nodes.vc.provider.wimba.WimbaClassroomConfiguration">
+ <!-- general -->
+ <property name="createMeetingImmediately" value="true" />
+ <!-- Wimba specific -->
+ <property name="toolsToStudentsEnabled" value="true" />
+ <property name="studentsSpeakAllowed" value="true" />
+ <property name="studentsVideoAllowed" value="true" />
+ <property name="userStatusIndicatorsEnabled" value="true" />
+ <property name="userStatusUpdateInChatEnabled" value="true" />
+ <property name="studentEBoardEnabled" value="true" />
+ <property name="breakoutRoomsEnabled" value="true" />
+ <property name="archivingEnabled" value="true" />
+ <property name="autoOpenNewArchives" value="false" />
+ <property name="appshareEnabled" value="true" />
+ <property name="powerPointImportEnabled" value="true" />
+ <property name="guestAccessAllowed" value="false" />
+ <property name="studentsChatAllowed" value="true" />
+ <property name="studentsPrivateChatAllowed" value="true" />
+ </bean>
+
+</beans>
\ No newline at end of file
diff --git a/src/main/java/de/bps/security/_spring/sslContext.xml b/src/main/java/de/bps/security/_spring/sslContext.xml
index 9a2fb6ef29c0e81ade1a5695b81b4a2876c00f43..db010967ff1a30de32616696401c6c0128745e12 100644
--- a/src/main/java/de/bps/security/_spring/sslContext.xml
+++ b/src/main/java/de/bps/security/_spring/sslContext.xml
@@ -10,7 +10,7 @@
<context:property-placeholder location="classpath:serviceconfig/olat.properties, classpath:olat.local.properties" />
<!-- SSL/TLS communication properties -->
- <bean id="sslConfigurationModule" class="de.bps.security.SSLConfigurationModule" init-method="init">
+ <bean id="sslConfigurationModule" class="de.bps.security.SSLConfigurationModule">
<property name="keyStoreFile" value="${onyx.keystore.file}" />
<property name="keyStorePass" value="${onyx.keystore.pass}" />
<property name="keyStoreType" value="${onyx.keystore.type}" />
diff --git a/src/main/java/org/olat/core/commons/taskExecutor/TaskExecutorManager.java b/src/main/java/org/olat/core/commons/taskExecutor/TaskExecutorManager.java
index 257abd1afe8dde7a6f691da3697500867fd78fe0..17a75579ffb352df8486a01dedfd76aedfbde61d 100644
--- a/src/main/java/org/olat/core/commons/taskExecutor/TaskExecutorManager.java
+++ b/src/main/java/org/olat/core/commons/taskExecutor/TaskExecutorManager.java
@@ -52,6 +52,10 @@ public class TaskExecutorManager extends BasicManager {
return INSTANCE;
}
+ public void destroy() {
+ taskExecutor.shutDown();
+ }
+
/**
* runs the task and wraps it in a new runnable to catch uncatched errors
* and may close db sessions used in the task.
diff --git a/src/main/java/org/olat/core/commons/taskExecutor/_spring/taskExecutorCorecontext.xml b/src/main/java/org/olat/core/commons/taskExecutor/_spring/taskExecutorCorecontext.xml
index eabf981905157d3621c3abebbe1b6531920a1442..d81cb746370ab17e76e7fce984d3db9700a521fa 100644
--- a/src/main/java/org/olat/core/commons/taskExecutor/_spring/taskExecutorCorecontext.xml
+++ b/src/main/java/org/olat/core/commons/taskExecutor/_spring/taskExecutorCorecontext.xml
@@ -11,7 +11,7 @@
<context:property-placeholder location="classpath:serviceconfig/olat.properties, classpath:olat.local.properties" />
<context:annotation-config />
-<bean id="taskExecutorManager" class="org.olat.core.commons.taskExecutor.TaskExecutorManager" >
+<bean id="taskExecutorManager" class="org.olat.core.commons.taskExecutor.TaskExecutorManager" destroy-method="destroy">
<constructor-arg index="0">
<bean class="org.olat.core.commons.taskExecutor.ThreadPoolTaskExecutor">
<!-- poolSize -->
diff --git a/src/main/resources/serviceconfig/olat.properties b/src/main/resources/serviceconfig/olat.properties
index f5f42e0ad6125255d24d7492412f7faaecf5081d..5aaeabf2af6b1133c3280677793b859cd2c74776 100644
--- a/src/main/resources/serviceconfig/olat.properties
+++ b/src/main/resources/serviceconfig/olat.properties
@@ -549,6 +549,8 @@ course.node.dateenrollment.enabled=false
course.node.basiclti.enabled=true
course.node.portfolio.enabled=true
course.node.infomessage.enabled=true
+course.node.vc.enabled=false
+course.node.vitero.enabled=false
########################################
# Options for e-portfolio
@@ -558,3 +560,43 @@ portfolio.map.styles=default,comic,leather
portfolio.map.styles.values=default,comic,leather
#offer a list of all maps shared to public. Don't enable if > 500 public maps exist! The maps can still be viewed by opening a users vcard.
portfolio.offer.public.map.list=true
+
+########################################
+# Options for Virtual Classrooms
+########################################
+
+#Adobe connect
+vc.adobe.enabled=false
+vc.adobe.protocol=http
+vc.adobe.port=80
+vc.adobe.baseurl=localhost
+vc.adobe.adminlogin=login
+vc.adobe.adminpassword=pass
+#account-id is optional
+vc.adobe.accountid=7410
+vc.adobe.showoptions=true
+#The type of user accounts
+vc.adobe.usertype=user
+vc.adobe.usertype.values=guest,user
+
+#Winba
+vc.winba.enabled=false
+vc.winba.protocol=http
+vc.winba.port=80
+vc.winba.baseurl=localhost
+vc.winba.adminlogin=admin
+vc.winba.adminpassword=password
+
+#Vitero
+vc.vitero.enabled=false
+vc.vitero.protocol=http
+vc.vitero.port=8080
+vc.vitero.baseurl=localhost
+vc.vitero.contextPath=vitero
+vc.vitero.adminlogin=admin
+vc.vitero.adminpassword=007
+vc.vitero.customerid=1
+vc.vitero.olatTimeZoneId=Africa/Ceuta
+vc.vitero.olatTimeZoneId.values=c.f. listing of Vitero
+vc.vitero.deleteVmsUserOnUserDelete=true
+
diff --git a/src/main/resources/serviceconfig/org/olat/core/commons/scheduler/_spring/olatextconfig.xml b/src/main/resources/serviceconfig/org/olat/core/commons/scheduler/_spring/olatextconfig.xml
index c68d10bf9c852f6d8d5861f410ba59dd55ca7a6e..04020a8a314bad0e6379c3191169ca1cfa1951e3 100644
--- a/src/main/resources/serviceconfig/org/olat/core/commons/scheduler/_spring/olatextconfig.xml
+++ b/src/main/resources/serviceconfig/org/olat/core/commons/scheduler/_spring/olatextconfig.xml
@@ -36,6 +36,7 @@ How to add a new job:
<ref bean="changePresenceJobTrigger" />
<!-- <ref bean="dumpJMXJobTrigger"/> -->
<ref bean="registrationTrigger"/>
+ <ref bean="adobeCleanupJob"/>
<!--
<ref bean="translationToolStatusGeneratorTrigger"/>
-->
diff --git a/src/main/webapp/static/themes/default/all/olat.css b/src/main/webapp/static/themes/default/all/olat.css
index 4a81502e9ff06aeb8db2ba4cbdae2046237a75c1..e3523d857cf5e0feb468d9447dcd5b81e7b95237 100644
--- a/src/main/webapp/static/themes/default/all/olat.css
+++ b/src/main/webapp/static/themes/default/all/olat.css
@@ -332,6 +332,12 @@
a.o_cal_icon:hover { background-image: url(../images/olat/calendar_over.png)!important}
.o_lti_icon { background-image: url(../images/olat/basiclti.png)!important}
a.o_lti_icon:hover { background-image: url(../images/olat/basiclti_over.png)!important}
+ /* <OLATCE-103> */
+ .o_vc_icon { background-image: url(../images/olat/vc.png)!important }
+ a.o_vc_icon:hover { background-image: url(../images/olat/vc_over.png)!important }
+ /* </OLATCE-103> */
+ .o_vitero_icon { background-image: url(../images/olat/vitero.png)!important }
+ a.o_vitero_icon:hover { background-image: url(../images/olat/vitero_over.png)!important }
.o_ep_icon, .o_EPStructuredMapTemplate_icon { background-image: url(../images/brasato/eportfolio/ep_icon.png)!important}
a.o_ep_icon:hover { background-image: url(../images/brasato/eportfolio/ep_icon_over.png)!important}
.o_infomsg_icon { background-image: url(../images/olat/infomessage.png)!important}
diff --git a/src/main/webapp/static/themes/default/images/olat/vc.png b/src/main/webapp/static/themes/default/images/olat/vc.png
new file mode 100755
index 0000000000000000000000000000000000000000..031996014fd3d08214da326888523fe9743454bd
Binary files /dev/null and b/src/main/webapp/static/themes/default/images/olat/vc.png differ
diff --git a/src/main/webapp/static/themes/default/images/olat/vc_over.png b/src/main/webapp/static/themes/default/images/olat/vc_over.png
new file mode 100755
index 0000000000000000000000000000000000000000..6f0b2a7d003f9795554cdb7218d25d3f5da82b56
Binary files /dev/null and b/src/main/webapp/static/themes/default/images/olat/vc_over.png differ
diff --git a/src/main/webapp/static/themes/default/images/olat/vitero.png b/src/main/webapp/static/themes/default/images/olat/vitero.png
new file mode 100644
index 0000000000000000000000000000000000000000..966cfbffb7b4192611564131a7d9133a7d19eeff
Binary files /dev/null and b/src/main/webapp/static/themes/default/images/olat/vitero.png differ
diff --git a/src/main/webapp/static/themes/default/images/olat/vitero_dis.png b/src/main/webapp/static/themes/default/images/olat/vitero_dis.png
new file mode 100644
index 0000000000000000000000000000000000000000..fc12c54c1e1a97b2410e902c81af7414d4d6be9a
Binary files /dev/null and b/src/main/webapp/static/themes/default/images/olat/vitero_dis.png differ
diff --git a/src/main/webapp/static/themes/default/images/olat/vitero_over.png b/src/main/webapp/static/themes/default/images/olat/vitero_over.png
new file mode 100644
index 0000000000000000000000000000000000000000..84005b6eb443df8e1787d9d7903a98695de0d8ea
Binary files /dev/null and b/src/main/webapp/static/themes/default/images/olat/vitero_over.png differ