How to use

LookupTableRowType

in

com.evolveum.midpoint.xml.ns._public.common.common_3

public LookupTableRowType toJAXB() {
  LookupTableRowType row = new LookupTableRowType();
  row.setId(Long.valueOf(id));
  row.setKey(key);
  row.setLastChangeTimestamp(lastChangeTimestamp);
  row.setValue(value);
  row.setLabel(RPolyString.copyToJAXB(label));
  return row;
}

private void addLookupTableRows(Session session, String tableOid, Collection<PrismContainerValue> values, int currentId, boolean deleteBeforeAdd) throws SchemaException {
  for (PrismContainerValue value : values) {
    LookupTableRowType rowType = new LookupTableRowType();
    rowType.setupContainerValue(value);
    if (deleteBeforeAdd) {
      deleteRowByKey(session, tableOid, rowType.getKey());
    }
    RLookupTableRow row = RLookupTableRow.toRepo(tableOid, rowType);
    row.setId(currentId);
    currentId++;
    session.save(row);
  }
}

@Override
protected LookupTableRowType createItem(PrismContainerValue value) {
  LookupTableRowType row = new LookupTableRowType();
  row.setupContainerValue(value);
  return row;
}

public LookupTableRowType clone() {
  LookupTableRowType object = new LookupTableRowType();
  PrismContainerValue value = asPrismContainerValue().clone();
  object.setupContainerValue(value);
  return object;
}

@Test
public void test265ReplaceRowsNewId() throws Exception {
  OperationResult result = new OperationResult("test265ReplaceRowsNewId");
  LookupTableRowType rowNoId = new LookupTableRowType(prismContext);
  rowNoId.setKey("key new plus");
  rowNoId.setValue("value now plus");
  List<ItemDelta<?,?>> modifications = prismContext.deltaFor(LookupTableType.class)
      .item(F_ROW).replace(rowNoId)
      .asItemDeltas();
  executeAndCheckModification(modifications, result, 0, keysOf(rowNoId));
}

private static RLookupTableRow toRepo(LookupTableRowType row) throws SchemaException {
  RLookupTableRow rRow = new RLookupTableRow();
  rRow.setId(RUtil.toInteger(row.getId()));
  if (row.getKey() == null) {
    throw new SchemaException("Attempt to insert a row with no key");
  }
  rRow.setKey(row.getKey());
  rRow.setLabel(RPolyString.copyFromJAXB(row.getLabel()));
  rRow.setLastChangeTimestamp(row.getLastChangeTimestamp());
  if (rRow.getLastChangeTimestamp() == null) {
    XMLGregorianCalendar cal = XMLGregorianCalendarType.asXMLGregorianCalendar(new Date());
    rRow.setLastChangeTimestamp(cal);
    row.setLastChangeTimestamp(cal);
  }
  rRow.setValue(row.getValue());
  return rRow;
}

private void checkLookupTable(PrismObject<LookupTableType> lookupTable, String name, OperationResult subresult) {
  checkObjectPropertyPolyString(lookupTable, LookupTableType.F_NAME, subresult, name);
  checkObjectProperty(lookupTable, LookupTableType.F_DESCRIPTION, subresult, SelfTestData.POLICIJA);
  LookupTableType lookupTableType = lookupTable.asObjectable();
  assertEquals("Unexpected number of rows", 1, lookupTableType.getRow().size(), subresult);
  LookupTableRowType rowType = lookupTableType.getRow().get(0);
  assertEquals("Unexpected key value", INSANE_NATIONAL_STRING, rowType.getKey(), subresult);
  assertEquals("Unexpected 'value' value", INSANE_NATIONAL_STRING, rowType.getValue(), subresult);
  assertPolyStringType("Unexpected label value", INSANE_NATIONAL_STRING, rowType.getLabel(), subresult);
}

private void assertRow(PrismContainerValue<LookupTableRowType> tableContainerValue, String key, String value, PolyStringType label, XMLGregorianCalendar lastChangeTimestamp) {
  LookupTableRowType row = tableContainerValue.asContainerable();
  assertEquals("wrong key", key, row.getKey());
  assertEquals("wrong value", value, row.getValue());
  assertEquals("wrong label", label, row.getLabel());
  assertEquals("wrong lastChangeTimestamp", lastChangeTimestamp, row.getLastChangeTimestamp());
}

@Test
public void test252DeleteNonexistingRow() throws Exception {
  OperationResult result = new OperationResult("test252DeleteNonexistingRow");
  LookupTableRowType rowNoId = new LookupTableRowType(prismContext);
  rowNoId.setKey("non-existing-key");
  List<ItemDelta<?,?>> modifications = prismContext.deltaFor(LookupTableType.class)
      .item(F_ROW).delete(rowNoId)
      .asItemDeltas();
  executeAndCheckModification(modifications, result, 0, null);
}

OperationResult result = task.getResult();
LookupTableRowType row = new LookupTableRowType();
row.setKey("gi_GO");
row.setLabel(PrismTestUtil.createPolyStringType("Gobbledygook"));
ObjectDelta<LookupTableType> delta = prismContext.deltaFactory().object().createModificationAddContainer(LookupTableType.class,
    LOOKUP_LANGUAGES_OID, LookupTableType.F_ROW, row);

/**
 * Create an instance of {@link LookupTableRowType }
 * 
 */
public LookupTableRowType createLookupTableRowType() {
  return new LookupTableRowType();
}

@Test
public void test250DeleteRow() throws Exception {
  OperationResult result = new OperationResult("test250DeleteRow");
  LookupTableRowType row3 = new LookupTableRowType(prismContext);
  row3.setId(3L);
  List<ItemDelta<?,?>> modifications = prismContext.deltaFor(LookupTableType.class)
      .item(F_ROW).delete(row3)
      .asItemDeltas();
  executeAndCheckModification(modifications, result, 0, null);
}

@Test(expectedExceptions = SchemaException.class)
public void test228AddKeylessRow2() throws Exception {
  OperationResult result = new OperationResult("test228AddKeylessRow2");
  LookupTableRowType row = new LookupTableRowType();
  row.setValue("value");
  List<ItemDelta<?,?>> modifications = prismContext.deltaFor(LookupTableType.class)
      .item(F_ROW).add(row)
      .asItemDeltas();
  repositoryService.modifyObject(LookupTableType.class, tableOid, modifications, null, result);
}

    if (value.getId() != null) {
      deleteRowById(session, tableOid, value.getId());
    } else if (value.asContainerable().getKey() != null) {
      deleteRowByKey(session, tableOid, value.asContainerable().getKey());
    } else {
LookupTableRowType rowType = row.toJAXB();
delta.setParentPath(ItemPath.EMPTY_PATH);
delta.applyTo(rowType.asPrismContainerValue());
if (!QNameUtil.match(name, LookupTableRowType.F_LAST_CHANGE_TIMESTAMP)) {
  rowType.setLastChangeTimestamp(null);   // in order to get filled in via toRepo call below

    options, result);
for (LookupTableRowType row: lookup.asObjectable().getRow()) {
  PolyStringType polyLabel = row.getLabel();
  String key = row.getKey();
  String label = key;
  if (polyLabel != null) {

Iterator<LookupTableRowType> iterator = expectedObject.asObjectable().getRow().iterator();
while (iterator.hasNext()) {
  if (replacedKeys.contains(iterator.next().getKey())) {
    iterator.remove();
  LookupTableRowType row = findRow(actualObject, key, true);
  checkCurrentTimestamp(row);
  row.setLastChangeTimestamp(null);
  LookupTableRowType rowExp = findRow(expectedObject, key, false);
  if (rowExp != null) {
    rowExp.setLastChangeTimestamp(null);

private List<String> keysOf(LookupTableRowType... rows) {
  List<String> keys = new ArrayList<>(rows.length);
  for (LookupTableRowType row : rows) {
    keys.add(row.getKey());
  }
  return keys;
}

public LookupTableRowType key(String value) {
  setKey(value);
  return this;
}

public LookupTableRowType value(String value) {
  setValue(value);
  return this;
}

public LookupTableRowType id(Long value) {
  setId(value);
  return this;
}