Example usage for javax.xml.namespace QName getLocalPart

List of usage examples for javax.xml.namespace QName getLocalPart

  1. HOME
  2. Java
  3. javax
  4. javax.xml.namespace.*
  5. QName
  6. getLocalPart

Introduction

In this page you can find the example usage for javax.xml.namespace QName getLocalPart.

Prototype

public String getLocalPart()

Source Link

Document

Get the local part of this QName.

Usage

From source file:com.collabnet.ccf.teamforge.TFTrackerHandler.java

/**
 * Updates fields of tracker definition This method currently does not
 * support conflict detection/*from  w  w  w.  ja  va 2s  .  co m*/
 * 
 * @param ga
 * @param trackerId
 *            tracker in question
 * @param fieldsToBeChanged
 *            fields to be adjusted
 * @param connection
 * @return
 * @throws RemoteException
 */
public TrackerDO updateTrackerMetaData(GenericArtifact ga, String trackerId,
        Map<String, SortedSet<String>> fieldsToBeChanged, Connection connection) throws RemoteException {
    Exception exception = null;
    for (String fieldName : fieldsToBeChanged.keySet()) {
        boolean updated = false;
        while (!updated) {
            updated = true;
            try {
                // we have to refetch this data in the loop to avoid version
                // mismatch exceptions
                TrackerFieldDO[] fields = connection.getTrackerClient().getFields(trackerId);

                // find field in question (we do not create new fields yet)
                TrackerFieldDO trackerField = null;
                for (TrackerFieldDO field : fields) {
                    if (field.getName().equals(fieldName)) {
                        trackerField = field;
                        break;
                    }
                }
                if (trackerField == null) {
                    throw new CCFRuntimeException(
                            "Field " + fieldName + " of tracker " + trackerId + " could not be found.");
                }

                // find out whether field is single select or multi select
                boolean fieldIsSingleSelect = trackerField.getFieldType()
                        .equals(TrackerFieldDO.FIELD_TYPE_SINGLE_SELECT);

                SortedSet<String> anticipatedFieldValues = fieldsToBeChanged.get(fieldName);
                List<TrackerFieldValueDO> deletedFieldValues = new ArrayList<TrackerFieldValueDO>();
                Set<String> addedFieldValues = new HashSet<String>();
                Map<String, String> currentValues = new HashMap<String, String>();
                TrackerFieldValueDO[] currentFieldValues = trackerField.getFieldValues();

                for (TrackerFieldValueDO currentFieldValue : currentFieldValues) {
                    currentValues.put(currentFieldValue.getValue(), currentFieldValue.getId());
                    if (!anticipatedFieldValues.contains(currentFieldValue.getValue())) {
                        deletedFieldValues.add(currentFieldValue);
                    }
                }

                for (String anticipatedFieldValue : anticipatedFieldValues) {
                    if (!currentValues.containsKey(anticipatedFieldValue)) {
                        addedFieldValues.add(anticipatedFieldValue);
                    }
                }

                if (deletedFieldValues.isEmpty() && addedFieldValues.isEmpty()) {
                    continue;
                }

                List<TrackerFieldValueDO> updatedValuesList = new ArrayList<TrackerFieldValueDO>();
                for (String anticipatedFieldValue : anticipatedFieldValues) {
                    TrackerFieldValueDO fieldValue = new TrackerFieldValueDO(connection.supports60(),
                            connection.supports50());
                    fieldValue.setIsDefault(false);
                    fieldValue.setValue(anticipatedFieldValue);
                    fieldValue.setId(currentValues.get(anticipatedFieldValue));
                    updatedValuesList.add(fieldValue);
                }

                // we cannot delete field values if those are still used by
                // tracker
                // items
                for (TrackerFieldValueDO deletedFieldValue : deletedFieldValues) {
                    if (isFieldValueUsed(trackerId, fieldName, deletedFieldValue, fieldIsSingleSelect,
                            connection)) {
                        log.warn("Could not delete field value " + deletedFieldValue.getValue() + " of field "
                                + fieldName + " in tracker " + trackerId
                                + " because there are still artifacts that use this value.");
                        int insertIndex = getInsertIndex(updatedValuesList, deletedFieldValue);
                        updatedValuesList.add(insertIndex, deletedFieldValue);
                    }
                }
                TrackerFieldValueDO[] fieldValues = new TrackerFieldValueDO[updatedValuesList.size()];
                updatedValuesList.toArray(fieldValues);
                trackerField.setFieldValues(fieldValues);
                connection.getTrackerClient().setField(trackerId, trackerField);
            } catch (AxisFault e) {
                javax.xml.namespace.QName faultCode = e.getFaultCode();
                if (!faultCode.getLocalPart().equals("VersionMismatchFault")) {
                    // throw e;
                    // we do not throw an error yet since we like to give
                    // other fields the chance to be properly updated
                    log.error(
                            "During TF meta data update, an error occured, proceeding to give other fields a chance to be updated ..."
                                    + e.getMessage(),
                            e);
                    exception = e;
                    continue;
                }
                updated = false;
                // we currently do not support conflict detection for meta
                // data updates
                logConflictResolutor.warn("Stale tracker meta data update, will override in any case ...:", e);
            }
        }
    }
    if (exception != null) {
        throw new CCFRuntimeException("During TF tracker meta data update, at least one exception occured.",
                exception);
    }
    return connection.getTrackerClient().getTrackerData(trackerId);
}

From source file:ee.ria.xroad.common.message.SaxSoapParserImpl.java

@SneakyThrows
protected void writeEndElementXml(String prefix, QName element, Attributes attributes, Writer writer) {
    writer.append("</");
    String localName = element.getLocalPart();
    String tag = StringUtils.isEmpty(prefix) ? localName : prefix + ":" + localName;
    writer.append(tag);//  www  .j  a  va2 s  . co m
    writer.append('>');
}

From source file:ee.ria.xroad.common.message.SaxSoapParserImpl.java

@SneakyThrows
protected void writeStartElementXml(String prefix, QName element, Attributes attributes, Writer writer) {
    writer.append('<');
    String localName = element.getLocalPart();
    String tag = StringUtils.isEmpty(prefix) ? localName : prefix + ":" + localName;
    writer.append(tag);//from w ww.j  ava 2s.co m
    for (int i = 0; i < attributes.getLength(); i++) {
        String escapedAttrValue = StringEscapeUtils.escapeXml11(attributes.getValue(i));
        writer.append(String.format(" %s=\"%s\"", attributes.getQName(i), escapedAttrValue));
    }
    writer.append('>');
}

From source file:com.ettrema.httpclient.Host.java

/**
 * TODO: should optimise so it only generates once per set of fields
 * /*from w w  w  . j  a va 2  s .c  o m*/
 * @param fields
 * @return 
 */
private String buildPropFindXml(List<QName> fields) {
    try {
        if (fields == null) {
            fields = defaultFields;
        }
        Element elPropfind = new Element("propfind", RespUtils.NS_DAV);
        Document doc = new Document(elPropfind);
        Element elProp = new Element("prop", RespUtils.NS_DAV);
        elPropfind.addContent(elProp);
        for (QName qn : fields) {
            Element elName = new Element(qn.getLocalPart(), qn.getPrefix(), qn.getNamespaceURI());
            elProp.addContent(elName);
        }
        XMLOutputter outputter = new XMLOutputter();
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        outputter.output(doc, out);
        return out.toString("UTF-8");
    } catch (IOException ex) {
        throw new RuntimeException(ex);
    }
}

From source file:com.evolveum.midpoint.web.page.admin.server.PageTaskAdd.java

private void initLayout() {
    Form mainForm = new Form(ID_FORM_MAIN);
    add(mainForm);//from  w ww  . j a v a2s .c  o  m

    final DropDownChoice resource = new DropDownChoice<>(ID_RESOURCE,
            new PropertyModel<TaskAddResourcesDto>(model, TaskAddDto.F_RESOURCE),
            new AbstractReadOnlyModel<List<TaskAddResourcesDto>>() {

                @Override
                public List<TaskAddResourcesDto> getObject() {
                    return createResourceList();
                }
            }, new IChoiceRenderer<TaskAddResourcesDto>() {

                @Override
                public Object getDisplayValue(TaskAddResourcesDto dto) {
                    return dto.getName();
                }

                @Override
                public String getIdValue(TaskAddResourcesDto dto, int index) {
                    return Integer.toString(index);
                }
            });
    resource.add(new VisibleEnableBehaviour() {

        @Override
        public boolean isEnabled() {
            TaskAddDto dto = model.getObject();
            boolean sync = TaskCategory.LIVE_SYNCHRONIZATION.equals(dto.getCategory());
            boolean recon = TaskCategory.RECONCILIATION.equals(dto.getCategory());
            boolean importAccounts = TaskCategory.IMPORTING_ACCOUNTS.equals(dto.getCategory());
            return sync || recon || importAccounts;
        }
    });
    resource.add(new AjaxFormComponentUpdatingBehavior("onchange") {

        @Override
        protected void onUpdate(AjaxRequestTarget target) {
            Task task = createSimpleTask(OPERATION_LOAD_RESOURCE);
            OperationResult result = task.getResult();
            List<QName> objectClassList = new ArrayList<>();

            TaskAddResourcesDto resourcesDto = model.getObject().getResource();

            if (resourcesDto != null) {
                PrismObject<ResourceType> resource = WebModelUtils.loadObject(ResourceType.class,
                        resourcesDto.getOid(), PageTaskAdd.this, task, result);

                try {
                    ResourceSchema schema = RefinedResourceSchema.getResourceSchema(resource,
                            getPrismContext());
                    schema.getObjectClassDefinitions();

                    for (Definition def : schema.getDefinitions()) {
                        objectClassList.add(def.getTypeName());
                    }

                    model.getObject().setObjectClassList(objectClassList);
                } catch (Exception e) {
                    LoggingUtils.logException(LOGGER, "Couldn't load object class list from resource.", e);
                    error("Couldn't load object class list from resource.");
                }

            }

            target.add(get(ID_FORM_MAIN + ":" + ID_OBJECT_CLASS));
        }
    });
    resource.setOutputMarkupId(true);
    mainForm.add(resource);

    final DropDownChoice focusType = new DropDownChoice<>(ID_FOCUS_TYPE,
            new PropertyModel<QName>(model, TaskAddDto.F_FOCUS_TYPE), new AbstractReadOnlyModel<List<QName>>() {

                @Override
                public List<QName> getObject() {
                    return createFocusTypeList();
                }
            }, new IChoiceRenderer<QName>() {

                @Override
                public Object getDisplayValue(QName object) {
                    if (FocusType.COMPLEX_TYPE.equals(object)) {
                        return "All (including role,orgs,users)";
                    }
                    return object.getLocalPart();
                }

                @Override
                public String getIdValue(QName object, int index) {
                    return Integer.toString(index);
                }
            });
    focusType.setOutputMarkupId(true);
    focusType.add(new VisibleEnableBehaviour() {

        @Override
        public boolean isEnabled() {
            TaskAddDto dto = model.getObject();
            return TaskCategory.RECOMPUTATION.equals(dto.getCategory());
        }
    });
    mainForm.add(focusType);

    final DropDownChoice kind = new DropDownChoice<>(ID_KIND,
            new PropertyModel<ShadowKindType>(model, TaskAddDto.F_KIND),
            new AbstractReadOnlyModel<List<ShadowKindType>>() {

                @Override
                public List<ShadowKindType> getObject() {
                    return createShadowKindTypeList();
                }
            }, new IChoiceRenderer<ShadowKindType>() {

                @Override
                public Object getDisplayValue(ShadowKindType object) {
                    return object.value();
                }

                @Override
                public String getIdValue(ShadowKindType object, int index) {
                    return Integer.toString(index);
                }
            });
    kind.setOutputMarkupId(true);
    kind.add(new VisibleEnableBehaviour() {

        @Override
        public boolean isEnabled() {
            TaskAddDto dto = model.getObject();
            boolean sync = TaskCategory.LIVE_SYNCHRONIZATION.equals(dto.getCategory());
            boolean recon = TaskCategory.RECONCILIATION.equals(dto.getCategory());
            boolean importAccounts = TaskCategory.IMPORTING_ACCOUNTS.equals(dto.getCategory());
            return sync || recon || importAccounts;
        }
    });
    mainForm.add(kind);

    final TextField<String> intent = new TextField<>(ID_INTENT,
            new PropertyModel<String>(model, TaskAddDto.F_INTENT));
    mainForm.add(intent);
    intent.setOutputMarkupId(true);
    intent.add(new VisibleEnableBehaviour() {

        @Override
        public boolean isEnabled() {
            TaskAddDto dto = model.getObject();
            boolean sync = TaskCategory.LIVE_SYNCHRONIZATION.equals(dto.getCategory());
            boolean recon = TaskCategory.RECONCILIATION.equals(dto.getCategory());
            boolean importAccounts = TaskCategory.IMPORTING_ACCOUNTS.equals(dto.getCategory());
            return sync || recon || importAccounts;
        }
    });

    AutoCompleteSettings autoCompleteSettings = new AutoCompleteSettings();
    autoCompleteSettings.setShowListOnEmptyInput(true);
    final AutoCompleteTextField<String> objectClass = new AutoCompleteTextField<String>(ID_OBJECT_CLASS,
            new PropertyModel<String>(model, TaskAddDto.F_OBJECT_CLASS), autoCompleteSettings) {

        @Override
        protected Iterator<String> getChoices(String input) {
            return prepareObjectClassChoiceList(input);
        }
    };
    objectClass.add(new VisibleEnableBehaviour() {

        @Override
        public boolean isEnabled() {
            TaskAddDto dto = model.getObject();
            boolean sync = TaskCategory.LIVE_SYNCHRONIZATION.equals(dto.getCategory());
            boolean recon = TaskCategory.RECONCILIATION.equals(dto.getCategory());
            boolean importAccounts = TaskCategory.IMPORTING_ACCOUNTS.equals(dto.getCategory());
            return sync || recon || importAccounts;
        }
    });
    mainForm.add(objectClass);

    DropDownChoice type = new DropDownChoice<>(ID_CATEGORY,
            new PropertyModel<String>(model, TaskAddDto.F_CATEGORY), new AbstractReadOnlyModel<List<String>>() {

                @Override
                public List<String> getObject() {
                    return createCategoryList();
                }
            }, new IChoiceRenderer<String>() {

                @Override
                public Object getDisplayValue(String item) {
                    return PageTaskAdd.this.getString("pageTask.category." + item);
                }

                @Override
                public String getIdValue(String item, int index) {
                    return Integer.toString(index);
                }
            });
    type.add(new AjaxFormComponentUpdatingBehavior("onChange") {

        @Override
        protected void onUpdate(AjaxRequestTarget target) {
            target.add(resource);
            target.add(intent);
            target.add(kind);
            target.add(objectClass);
            target.add(focusType);
        }
    });
    type.setRequired(true);
    mainForm.add(type);

    TextField<String> name = new TextField<>(ID_NAME, new PropertyModel<String>(model, TaskAddDto.F_NAME));
    name.setRequired(true);
    mainForm.add(name);

    initScheduling(mainForm);
    initAdvanced(mainForm);

    CheckBox dryRun = new CheckBox(ID_DRY_RUN, new PropertyModel<Boolean>(model, TaskAddDto.F_DRY_RUN));
    mainForm.add(dryRun);

    initButtons(mainForm);
}

From source file:com.evolveum.midpoint.web.component.wizard.resource.SynchronizationStep.java

private void initObjectSyncEditor(WebMarkupContainer editor) {
    Label editorLabel = new Label(ID_EDITOR_LABEL, new AbstractReadOnlyModel<String>() {
        @Override/*  w ww.  ja va2  s . co m*/
        public String getObject() {
            if (!isAnySelected()) {
                return null; // shouldn't occur
            }
            String name = syncDtoModel.getObject().getSelected().getName() != null
                    ? syncDtoModel.getObject().getSelected().getName()
                    : "";
            return getString("SynchronizationStep.label.editSyncObject", name);
        }
    });
    editorLabel.setOutputMarkupId(true);
    editor.add(editorLabel);

    TextField editorName = new TextField<>(ID_EDITOR_NAME,
            new PropertyModel<String>(syncDtoModel, ResourceSynchronizationDto.F_SELECTED + ".name"));
    editorName.add(new UpdateNamesBehaviour());
    parentPage.addEditingEnabledBehavior(editorName);
    editor.add(editorName);

    TextArea editorDescription = new TextArea<>(ID_EDITOR_DESCRIPTION,
            new PropertyModel<String>(syncDtoModel, ResourceSynchronizationDto.F_SELECTED + ".description"));
    parentPage.addEditingEnabledBehavior(editorDescription);
    editor.add(editorDescription);

    DropDownChoice editorKind = new DropDownChoice<>(ID_EDITOR_KIND,
            new PropertyModel<>(syncDtoModel, ResourceSynchronizationDto.F_SELECTED + ".kind"),
            WebComponentUtil.createReadonlyModelFromEnum(ShadowKindType.class), new EnumChoiceRenderer<>());
    editorKind.setNullValid(true);
    editorKind.add(new UpdateNamesBehaviour());
    parentPage.addEditingEnabledBehavior(editorKind);
    editor.add(editorKind);

    TextField editorIntent = new TextField<>(ID_EDITOR_INTENT,
            new PropertyModel<String>(syncDtoModel, ResourceSynchronizationDto.F_SELECTED + ".intent"));
    editorIntent.add(new UpdateNamesBehaviour());
    parentPage.addEditingEnabledBehavior(editorIntent);
    editor.add(editorIntent);

    MultiValueAutoCompleteTextPanel<QName> editorObjectClass = new MultiValueAutoCompleteTextPanel<QName>(
            ID_EDITOR_OBJECT_CLASS,
            new PropertyModel<>(syncDtoModel, ResourceSynchronizationDto.F_SELECTED + ".objectClass"), true,
            parentPage.getReadOnlyModel()) {

        @Override
        protected IModel<String> createTextModel(final IModel<QName> model) {
            return new PropertyModel<>(model, "localPart");
        }

        @Override
        protected QName createNewEmptyItem() {
            return new QName("");
        }

        @Override
        protected boolean buttonsDisabled() {
            return !isAnySelected();
        }

        @Override
        protected List<QName> createObjectList() {
            return syncDtoModel.getObject().getObjectClassList();
        }

        @Override
        protected String createAutoCompleteObjectLabel(QName object) {
            return object.getLocalPart();
        }

        @Override
        protected IValidator<String> createAutoCompleteValidator() {
            return createObjectClassValidator(new AbstractReadOnlyModel<List<QName>>() {
                @Override
                public List<QName> getObject() {
                    return syncDtoModel.getObject().getObjectClassList();
                }
            });
        }
    };
    parentPage.addEditingEnabledBehavior(editorObjectClass);
    editor.add(editorObjectClass);

    // TODO: switch to ObjectTypeSelectPanel
    DropDownChoice editorFocus = new DropDownChoice<>(ID_EDITOR_FOCUS,
            new PropertyModel<>(syncDtoModel, ResourceSynchronizationDto.F_SELECTED + ".focusType"),
            new AbstractReadOnlyModel<List<QName>>() {

                @Override
                public List<QName> getObject() {
                    return WebComponentUtil.createFocusTypeList();
                }
            }, new QNameChoiceRenderer());
    editorFocus.setNullValid(true);
    editorFocus.add(new UpdateNamesBehaviour());
    parentPage.addEditingEnabledBehavior(editorFocus);
    editor.add(editorFocus);

    CheckBox editorEnabled = new CheckBox(ID_EDITOR_ENABLED,
            new PropertyModel<>(syncDtoModel, ResourceSynchronizationDto.F_SELECTED + ".enabled"));
    parentPage.addEditingEnabledBehavior(editorEnabled);
    editor.add(editorEnabled);

    AjaxSubmitLink editorCondition = new AjaxSubmitLink(ID_EDITOR_BUTTON_CONDITION) {

        @Override
        protected void onSubmit(AjaxRequestTarget target, Form<?> form) {
            conditionEditPerformed(target);
        }
    };
    addDisableClassModifier(editorCondition);
    editor.add(editorCondition);

    AjaxSubmitLink editorConfirmation = new AjaxSubmitLink(ID_EDITOR_BUTTON_CONFIRMATION) {

        @Override
        protected void onSubmit(AjaxRequestTarget target, Form<?> form) {
            confirmationEditPerformed(target);
        }
    };
    addDisableClassModifier(editorConfirmation);
    editor.add(editorConfirmation);

    DropDownChoice editorObjectTemplate = new DropDownChoice<>(ID_EDITOR_OBJECT_TEMPLATE,
            new PropertyModel<>(syncDtoModel, ResourceSynchronizationDto.F_SELECTED + ".objectTemplateRef"),
            new AbstractReadOnlyModel<List<ObjectReferenceType>>() {

                @Override
                public List<ObjectReferenceType> getObject() {
                    return WebModelServiceUtils.createObjectReferenceList(ObjectTemplateType.class,
                            getPageBase(), syncDtoModel.getObject().getObjectTemplateMap());
                }
            }, new ObjectReferenceChoiceRenderer(syncDtoModel.getObject().getObjectTemplateMap()));
    editorObjectTemplate.setNullValid(true);
    parentPage.addEditingEnabledBehavior(editorObjectTemplate);
    editor.add(editorObjectTemplate);

    CheckBox editorReconcile = new CheckBox(ID_EDITOR_RECONCILE,
            new PropertyModel<>(syncDtoModel, ResourceSynchronizationDto.F_SELECTED + ".reconcile"));
    parentPage.addEditingEnabledBehavior(editorReconcile);
    editor.add(editorReconcile);

    TriStateComboPanel opportunistic = new TriStateComboPanel(ID_EDITOR_OPPORTUNISTIC,
            new PropertyModel<>(syncDtoModel, ResourceSynchronizationDto.F_SELECTED + ".opportunistic"));
    parentPage.addEditingEnabledBehavior(opportunistic);
    editor.add(opportunistic);

    MultiValueTextEditPanel editorCorrelation = new MultiValueTextEditPanel<ConditionalSearchFilterType>(
            ID_EDITOR_EDITOR_CORRELATION,
            new PropertyModel<>(syncDtoModel, ResourceSynchronizationDto.F_SELECTED + ".correlation"),
            new PropertyModel<>(syncDtoModel, ResourceSynchronizationDto.F_SELECTED_CORRELATION), false, true,
            parentPage.getReadOnlyModel()) {

        @Override
        protected IModel<String> createTextModel(final IModel<ConditionalSearchFilterType> model) {
            return new Model<String>() {

                @Override
                public String getObject() {
                    StringBuilder sb = new StringBuilder();

                    ConditionalSearchFilterType searchFilter = model.getObject();
                    if (searchFilter != null && searchFilter.getDescription() != null) {
                        sb.append(searchFilter.getDescription());
                    }

                    if (sb.toString().isEmpty()) {
                        sb.append(getString("SynchronizationStep.label.notSpecified"));
                    }

                    return sb.toString();
                }
            };
        }

        @Override
        protected ConditionalSearchFilterType createNewEmptyItem() {
            return new ConditionalSearchFilterType();
        }

        @Override
        protected void editPerformed(AjaxRequestTarget target, ConditionalSearchFilterType object) {
            correlationEditPerformed(target, object);
        }

        @Override
        protected void performAddValueHook(AjaxRequestTarget target, ConditionalSearchFilterType added) {
            parentPage.refreshIssues(target);
        }

        @Override
        protected void performRemoveValueHook(AjaxRequestTarget target,
                ListItem<ConditionalSearchFilterType> item) {
            parentPage.refreshIssues(target);
        }

        @Override
        protected boolean buttonsDisabled() {
            return !isAnySelected();
        }
    };
    editor.add(editorCorrelation);

    MultiValueTextEditPanel editorReaction = new MultiValueTextEditPanel<SynchronizationReactionType>(
            ID_EDITOR_REACTION,
            new PropertyModel<>(syncDtoModel, ResourceSynchronizationDto.F_SELECTED + ".reaction"),
            new PropertyModel<>(syncDtoModel, ResourceSynchronizationDto.F_SELECTED_REACTION), false, true,
            parentPage.getReadOnlyModel()) {

        @Override
        protected IModel<String> createTextModel(final IModel<SynchronizationReactionType> model) {
            return new Model<String>() {

                @Override
                public String getObject() {
                    SynchronizationReactionType reaction = model.getObject();
                    if (reaction == null) {
                        return "";
                    }
                    StringBuilder sb = new StringBuilder();
                    sb.append(reaction.getName() != null ? reaction.getName() + " " : "");
                    sb.append("(");
                    if (reaction.getSituation() != null) {
                        sb.append(reaction.getSituation());
                    }
                    if (Boolean.TRUE.equals(reaction.isSynchronize()) || !reaction.getAction().isEmpty()) {
                        sb.append(" -> ");
                        if (!reaction.getAction().isEmpty()) {
                            boolean first = true;
                            for (SynchronizationActionType action : reaction.getAction()) {
                                if (first) {
                                    first = false;
                                } else {
                                    sb.append(", ");
                                }
                                sb.append(StringUtils.substringAfter(action.getHandlerUri(), "#"));
                            }
                        } else {
                            sb.append("sync"); // TODO i18n
                        }
                    }
                    sb.append(")");
                    return sb.toString();
                }
            };
        }

        @Override
        protected SynchronizationReactionType createNewEmptyItem() {
            return new SynchronizationReactionType();
        }

        @Override
        protected void editPerformed(AjaxRequestTarget target, SynchronizationReactionType object) {
            reactionEditPerformed(target, object);
        }

        @Override
        protected void performAddValueHook(AjaxRequestTarget target, SynchronizationReactionType added) {
            parentPage.refreshIssues(target);
        }

        @Override
        protected void performRemoveValueHook(AjaxRequestTarget target,
                ListItem<SynchronizationReactionType> item) {
            parentPage.refreshIssues(target);
        }

        @Override
        protected boolean buttonsDisabled() {
            return !isAnySelected();
        }
    };
    editorReaction.setOutputMarkupId(true);
    editor.add(editorReaction);

    Label kindTooltip = new Label(ID_T_KIND);
    kindTooltip.add(new InfoTooltipBehavior());
    editor.add(kindTooltip);

    Label intentTooltip = new Label(ID_T_INTENT);
    intentTooltip.add(new InfoTooltipBehavior());
    editor.add(intentTooltip);

    Label objClassTooltip = new Label(ID_T_OBJ_CLASS);
    objClassTooltip.add(new InfoTooltipBehavior());
    editor.add(objClassTooltip);

    Label focusTooltip = new Label(ID_T_FOCUS);
    focusTooltip.add(new InfoTooltipBehavior());
    editor.add(focusTooltip);

    Label enabledTooltip = new Label(ID_T_ENABLED);
    enabledTooltip.add(new InfoTooltipBehavior());
    editor.add(enabledTooltip);

    Label conditionTooltip = new Label(ID_T_CONDITION);
    conditionTooltip.add(new InfoTooltipBehavior());
    editor.add(conditionTooltip);

    Label confirmationTooltip = new Label(ID_T_CONFIRMATION);
    confirmationTooltip.add(new InfoTooltipBehavior());
    editor.add(confirmationTooltip);

    Label objTemplateTooltip = new Label(ID_T_OBJ_TEMPLATE);
    objTemplateTooltip.add(new InfoTooltipBehavior());
    editor.add(objTemplateTooltip);

    Label reconcileTooltip = new Label(ID_T_RECONCILE);
    reconcileTooltip.add(new InfoTooltipBehavior());
    editor.add(reconcileTooltip);

    Label opportunisticTooltip = new Label(ID_T_OPPORTUNISTIC);
    opportunisticTooltip.add(new InfoTooltipBehavior());
    editor.add(opportunisticTooltip);

    Label correlationTooltip = new Label(ID_T_CORRELATION);
    correlationTooltip.add(new InfoTooltipBehavior());
    editor.add(correlationTooltip);

    Label reactionTooltip = new Label(ID_T_REACTION);
    reactionTooltip.add(new InfoTooltipBehavior());
    editor.add(reactionTooltip);
}

From source file:com.evolveum.midpoint.web.page.admin.configuration.PageAccounts.java

private IValidator<String> createObjectClassValidator() {
    return new IValidator<String>() {

        @Override/*  w  ww . j  a va2s .c om*/
        public void validate(IValidatable<String> validatable) {
            String value = validatable.getValue();
            AccountDetailsSearchDto dto = searchModel.getObject();
            List<QName> accountObjectClassList = dto.getObjectClassList();
            List<String> accountObjectClassListString = new ArrayList<>();

            for (QName objectClass : accountObjectClassList) {
                accountObjectClassListString.add(objectClass.getLocalPart());
            }

            if (!accountObjectClassListString.contains(value)) {
                error(createStringResource("PageAccounts.message.validationError", value).getString());
            }
        }
    };
}

From source file:com.evolveum.midpoint.web.page.admin.configuration.PageAccounts.java

private ObjectQuery createObjectQuery() {
    AccountDetailsSearchDto dto = searchModel.getObject();
    ObjectQuery query = new ObjectQuery();

    List<ObjectFilter> filters = new ArrayList<>();
    String searchText = dto.getText();
    ShadowKindType kind = dto.getKind();
    String intent = dto.getIntent();
    String objectClass = dto.getObjectClass();
    FailedOperationTypeType failedOperatonType = dto.getFailedOperationType();

    if (StringUtils.isNotEmpty(searchText)) {
        PolyStringNormalizer normalizer = getPrismContext().getDefaultPolyStringNormalizer();
        String normalized = normalizer.normalize(searchText);

        ObjectFilter substring = SubstringFilter.createSubstring(ShadowType.F_NAME, ShadowType.class,
                getPrismContext(), PolyStringNormMatchingRule.NAME, normalized);
        filters.add(substring);/*from   www  . j  ava  2  s .c  om*/
    }

    if (kind != null) {
        ObjectFilter kindFilter = EqualFilter.createEqual(ShadowType.F_KIND, ShadowType.class,
                getPrismContext(), null, kind);
        filters.add(kindFilter);
    }

    if (StringUtils.isNotEmpty(intent)) {
        ObjectFilter intentFilter = EqualFilter.createEqual(ShadowType.F_INTENT, ShadowType.class,
                getPrismContext(), null, intent);
        filters.add(intentFilter);
    }

    if (failedOperatonType != null) {
        ObjectFilter failedOperationFilter = EqualFilter.createEqual(ShadowType.F_FAILED_OPERATION_TYPE,
                ShadowType.class, getPrismContext(), null, failedOperatonType);
        filters.add(failedOperationFilter);
    }

    if (StringUtils.isNotEmpty(objectClass)) {
        QName objClass = new QName(objectClass);

        for (QName q : dto.getObjectClassList()) {
            if (objectClass.equals(q.getLocalPart())) {
                objClass = q;
            }
        }

        ObjectFilter objectClassFilter = EqualFilter.createEqual(ShadowType.F_OBJECT_CLASS, ShadowType.class,
                getPrismContext(), null, objClass);
        filters.add(objectClassFilter);
    }

    AndFilter searchFilter;
    if (!filters.isEmpty()) {
        searchFilter = AndFilter.createAnd(filters);

        ObjectFilter resourceFilter = createResourceQueryFilter();
        query.setFilter(
                resourceFilter != null ? AndFilter.createAnd(searchFilter, resourceFilter) : searchFilter);
    } else {
        query.setFilter(createResourceQueryFilter());
    }

    return query;
}

From source file:com.evolveum.midpoint.prism.marshaller.ItemPathHolder.java

private void addPureXpath(StringBuilder sb) {
    if (!absolute && segments.isEmpty()) {
        // Empty segment list gives a "local node" XPath
        sb.append(".");
        return;/* www  . ja  v a 2  s.  c  o  m*/
    }

    if (absolute) {
        sb.append("/");
    }

    boolean first = true;

    for (PathHolderSegment seg : segments) {

        if (seg.isIdValueFilter()) {

            sb.append("[");
            sb.append(seg.getValue());
            sb.append("]");

        } else {

            if (!first) {
                sb.append("/");
            } else {
                first = false;
            }

            if (seg.isVariable()) {
                sb.append("$");
            }
            QName qname = seg.getQName();

            if (ObjectReferencePathSegment.QNAME.equals(qname)) {
                sb.append(ObjectReferencePathSegment.SYMBOL);
            } else if (ParentPathSegment.QNAME.equals(qname)) {
                sb.append(ParentPathSegment.SYMBOL);
            } else if (IdentifierPathSegment.QNAME.equals(qname)) {
                sb.append(IdentifierPathSegment.SYMBOL);
            } else if (!StringUtils.isEmpty(qname.getPrefix())) {
                sb.append(qname.getPrefix()).append(':').append(qname.getLocalPart());
            } else {
                if (StringUtils.isNotEmpty(qname.getNamespaceURI())) {
                    String prefix = GlobalDynamicNamespacePrefixMapper
                            .getPreferredPrefix(qname.getNamespaceURI());
                    seg.setQNamePrefix(prefix); // hack - we modify the path segment here (only the form, not the meaning), but nevertheless it's ugly
                    sb.append(seg.getQName().getPrefix()).append(':').append(seg.getQName().getLocalPart());
                } else {
                    // no namespace, no prefix
                    sb.append(qname.getLocalPart());
                }
            }
        }
    }
}

From source file:com.evolveum.midpoint.prism.marshaller.XPathHolder.java

private void addPureXpath(StringBuilder sb) {
    if (!absolute && segments.isEmpty()) {
        // Empty segment list gives a "local node" XPath
        sb.append(".");
        return;/*from ww  w  .j a v  a2  s  .  c  om*/
    }

    if (absolute) {
        sb.append("/");
    }

    boolean first = true;

    for (XPathSegment seg : segments) {

        if (seg.isIdValueFilter()) {

            sb.append("[");
            sb.append(seg.getValue());
            sb.append("]");

        } else {

            if (!first) {
                sb.append("/");
            } else {
                first = false;
            }

            if (seg.isVariable()) {
                sb.append("$");
            }
            QName qname = seg.getQName();

            if (ObjectReferencePathSegment.QNAME.equals(qname)) {
                sb.append(ObjectReferencePathSegment.SYMBOL);
            } else if (ParentPathSegment.QNAME.equals(qname)) {
                sb.append(ParentPathSegment.SYMBOL);
            } else if (IdentifierPathSegment.QNAME.equals(qname)) {
                sb.append(IdentifierPathSegment.SYMBOL);
            } else if (!StringUtils.isEmpty(qname.getPrefix())) {
                sb.append(qname.getPrefix() + ":" + qname.getLocalPart());
            } else {
                if (StringUtils.isNotEmpty(qname.getNamespaceURI())) {
                    String prefix = GlobalDynamicNamespacePrefixMapper
                            .getPreferredPrefix(qname.getNamespaceURI());
                    seg.setQNamePrefix(prefix); // hack - we modify the path segment here (only the form, not the meaning), but nevertheless it's ugly
                    sb.append(seg.getQName().getPrefix() + ":" + seg.getQName().getLocalPart());
                } else {
                    // no namespace, no prefix
                    sb.append(qname.getLocalPart());
                }
            }
        }
    }
}