public String getVocabularyLabel(String voc_name, String key) {
DirectoryService ds = Framework.getLocalService(DirectoryService.class);
if (ds == null) {
return key;
}
List<String> vocs = new ArrayList<String>();
List<String> keys = new ArrayList<String>();
if (voc_name.contains("/")) {
String[] parts = voc_name.split("\\/");
for (String part : parts) {
vocs.add(part);
}
parts = key.split("\\/");
for (String part : parts) {
keys.add(part);
}
} else {
vocs.add(voc_name);
keys.add(key);
}
List<String> values = new ArrayList<String>();
for (int i = 0; i < vocs.size(); i++) {
String voc = vocs.get(i);
String keyValue = keys.get(i);
if (ds.getDirectoryNames().contains(voc)) {
Directory dir = ds.getDirectory(voc);
String schema = dir.getSchema();
if ("vocabulary".equals(schema) || "xvocabulary".equals(schema)) {
try (Session session = dir.getSession()) {
DocumentModel entry = session.getEntry(keyValue);
if (entry != null) {
values.add((String) entry.getProperty(schema, "label"));
}
}
}
}
}
if (values.size() == 0) {
return key;
} else if (values.size() == 1) {
return values.get(0);
} else {
String result = "";
for (int i = 0; i < values.size(); i++) {
if (i > 0) {
result = result + " / ";
}
result = result + values.get(i);
}
return result;
}
}
protected NuxeoOAuthConsumer getEntry(String consumerKey, String keyType) {
DirectoryService ds = Framework.getService(DirectoryService.class);
try (Session session = ds.open(DIRECTORY_NAME)) {
DocumentModel entry = session.getEntry(consumerKey);
if (entry == null) {
return null;
}
return NuxeoOAuthConsumer.createFromDirectoryEntry(entry, keyType);
}
}
public static DocumentModel getDirectoryEntry(String directoryName, String entryId)
throws ClientException {
if (entryId == null) {
return null;
}
DirectoryService dirService = Framework.getService(DirectoryService.class);
try (Session session = dirService.open(directoryName)) {
return session.getEntry(entryId);
}
}
@Override
public void deleteConsumer(String consumerKey) {
try {
DirectoryService ds = Framework.getService(DirectoryService.class);
try (Session session = ds.open(DIRECTORY_NAME)) {
session.deleteEntry(consumerKey);
}
} catch (ClientException e) {
log.error("Unable to delete consumer " + consumerKey, e);
}
}
@Override
public void registerContribution(
Object contribution, String extensionPoint, ComponentInstance contributor) {
MockMemoryDirectoryDescriptor desc = (MockMemoryDirectoryDescriptor) contribution;
String directoryName = desc.name;
reg.put(directoryName, desc);
try {
DirectoryService directoryService = Framework.getService(DirectoryService.class);
directoryService.registerDirectory(directoryName, this);
} catch (Exception e) {
throw new DirectoryException("Error in Directory Service lookup", e);
}
}
@Override
public void unregisterContribution(
Object contribution, String extensionPoint, ComponentInstance contributor) {
String directoryName = ((MockMemoryDirectoryDescriptor) contribution).name;
reg.remove(directoryName);
try {
DirectoryService directoryService = Framework.getService(DirectoryService.class);
if (directoryService != null) {
directoryService.unregisterDirectory(directoryName, this);
}
} catch (Exception e) {
throw new DirectoryException("Error in Directory Service lookup", e);
}
}
@After
public void tearDown() throws Exception {
memoryDirectoryFactory.unregisterDirectory(memdir1);
memoryDirectoryFactory.unregisterDirectory(memdir2);
memoryDirectoryFactory.unregisterDirectory(memdir3);
directoryService.unregisterDirectory("memdirs", memoryDirectoryFactory);
}
@Test
public void testUpdateReadonlyMultidir() throws Exception {
MultiDirectory readonlyMultidir =
(MultiDirectory) directoryService.getDirectory("readonlymulti");
MultiDirectorySession readonlyDir = (MultiDirectorySession) readonlyMultidir.getSession();
Session dir1 = memdir1.getSession();
Session dir2 = memdir2.getSession();
Session dir3 = memdir3.getSession();
// multi-subdirs update
DocumentModel e = readonlyDir.getEntry("1");
assertEquals("foo1", e.getProperty("schema3", "thefoo"));
assertEquals("bar1", e.getProperty("schema3", "thebar"));
e.setProperty("schema3", "thefoo", "fffooo1");
e.setProperty("schema3", "thebar", "babar1");
readonlyDir.updateEntry(e);
e = readonlyDir.getEntry("1");
// the multidirectory entry was not updated
assertEquals("foo1", e.getProperty("schema3", "thefoo"));
assertEquals("bar1", e.getProperty("schema3", "thebar"));
// neither the underlying directories
assertEquals("foo1", dir1.getEntry("1").getProperty("schema1", "foo"));
assertEquals("bar1", dir2.getEntry("1").getProperty("schema2", "bar"));
assertNull(dir3.getEntry("1"));
}
@Override
public NuxeoOAuthConsumer storeConsumer(NuxeoOAuthConsumer consumer) {
DirectoryService ds = Framework.getService(DirectoryService.class);
try (Session session = ds.open(DIRECTORY_NAME)) {
Map<String, Object> init = new HashMap<String, Object>();
init.put("consumerKey", consumer.consumerKey);
DocumentModel entry = session.createEntry(init);
consumer.asDocumentModel(entry);
session.updateEntry(entry);
if (entry == null) {
return null;
}
consumer = NuxeoOAuthConsumer.createFromDirectoryEntry(entry, null);
return consumer;
}
}
@Override
public List<NuxeoOAuthConsumer> listConsumers() {
List<NuxeoOAuthConsumer> result = new ArrayList<NuxeoOAuthConsumer>();
try {
DirectoryService ds = Framework.getService(DirectoryService.class);
try (Session session = ds.open(DIRECTORY_NAME)) {
DocumentModelList entries = session.getEntries();
for (DocumentModel entry : entries) {
result.add(NuxeoOAuthConsumer.createFromDirectoryEntry(entry, null));
}
}
} catch (ClientException e) {
log.error("Error while fetching consumer directory", e);
}
return result;
}
public static DocumentModelList getDirectoryEntries(String directoryName, String... entryIds)
throws ClientException {
if (entryIds == null) {
return null;
}
DirectoryService dirService = Framework.getService(DirectoryService.class);
try (Session session = dirService.open(directoryName)) {
DocumentModelList result = new DocumentModelListImpl();
for (String entryId : entryIds) {
DocumentModel entry = session.getEntry(entryId);
if (entry != null) {
result.add(entry);
}
}
return result;
}
}
protected void createUser(String userName, String password) {
try (org.nuxeo.ecm.directory.Session userDir = directoryService.open("userDirectory")) {
Map<String, Object> user = new HashMap<String, Object>();
user.put("username", userName);
user.put("password", password);
userDir.createEntry(user);
}
}
@Test
public void testReadOnlyEntryFromMultidirectory() throws Exception {
MultiDirectory readonlyMultidir =
(MultiDirectory) directoryService.getDirectory("readonlymulti");
MultiDirectorySession readonlyDir = (MultiDirectorySession) readonlyMultidir.getSession();
// all should be readonly
assertTrue(BaseSession.isReadOnlyEntry(readonlyDir.getEntry("1")));
assertTrue(BaseSession.isReadOnlyEntry(readonlyDir.getEntry("2")));
assertTrue(BaseSession.isReadOnlyEntry(readonlyDir.getEntry("3")));
assertTrue(BaseSession.isReadOnlyEntry(readonlyDir.getEntry("4")));
}
public static DirectoryEntry readJson(JsonParser jp, MultivaluedMap<String, String> httpHeaders)
throws IOException {
JsonToken tok = jp.nextToken();
// skip {
if (jp.getCurrentToken() == JsonToken.START_OBJECT) {
tok = jp.nextToken();
}
String directoryName = null;
JsonNode propertiesNode = null;
while (tok != JsonToken.END_OBJECT) {
String key = jp.getCurrentName();
jp.nextToken();
if ("directoryName".equals(key)) {
directoryName = jp.readValueAs(String.class);
} else if ("properties".equals(key)) {
propertiesNode = jp.readValueAsTree();
} else if ("entity-type".equals(key)) {
String entityType = jp.readValueAs(String.class);
if (!DirectoryEntryWriter.ENTITY_TYPE.equals(entityType)) {
throw new WebApplicationException(Response.Status.BAD_REQUEST);
}
} else {
log.debug("Unknown key: " + key);
jp.skipChildren();
}
tok = jp.nextToken();
}
DirectoryService ds = Framework.getLocalService(DirectoryService.class);
Directory directory = ds.getDirectory(directoryName);
if (directory == null) {
throw new WebResourceNotFoundException("Directory " + directoryName + " does not exists");
}
return getDirectoryEntryFromNode(propertiesNode, directory);
}
@After
public void tearDown() throws Exception {
// delete certificates associated with user ids
try (Session sqlSession = directoryService.open(CERTIFICATE_DIRECTORY_NAME)) {
sqlSession.deleteEntry(DEFAULT_USER_ID);
sqlSession.deleteEntry(SECOND_USER_ID);
}
// delete users
userManager.deleteUser(DEFAULT_USER_ID);
userManager.deleteUser(SECOND_USER_ID);
}
protected void deleteUser(String userName) {
try (org.nuxeo.ecm.directory.Session userDir = directoryService.open("userDirectory")) {
userDir.deleteEntry(userName);
}
}
@Before
public void setUp() {
continentSession = directoryService.getDirectory("continent").getSession();
countrySession = directoryService.getDirectory("country").getSession();
}
@Before
public void setUp() throws Exception {
// mem dir factory
directoryService = Framework.getLocalService(DirectoryService.class);
memoryDirectoryFactory = new MemoryDirectoryFactory();
directoryService.registerDirectory("memdirs", memoryDirectoryFactory);
// create and register mem directories
Map<String, Object> e;
// dir 1
Set<String> schema1Set = new HashSet<String>(Arrays.asList("uid", "foo"));
memdir1 = new MemoryDirectory("dir1", "schema1", schema1Set, "uid", "foo");
memoryDirectoryFactory.registerDirectory(memdir1);
Session dir1 = memdir1.getSession();
e = new HashMap<String, Object>();
e.put("uid", "1");
e.put("foo", "foo1");
dir1.createEntry(e);
e = new HashMap<String, Object>();
e.put("uid", "2");
e.put("foo", "foo2");
dir1.createEntry(e);
// dir 2
Set<String> schema2Set = new HashSet<String>(Arrays.asList("id", "bar"));
memdir2 = new MemoryDirectory("dir2", "schema2", schema2Set, "id", null);
memoryDirectoryFactory.registerDirectory(memdir2);
Session dir2 = memdir2.getSession();
e = new HashMap<String, Object>();
e.put("id", "1");
e.put("bar", "bar1");
dir2.createEntry(e);
e = new HashMap<String, Object>();
e.put("id", "2");
e.put("bar", "bar2");
dir2.createEntry(e);
// dir 3
Set<String> schema3Set = new HashSet<String>(Arrays.asList("uid", "thefoo", "thebar"));
memdir3 = new MemoryDirectory("dir3", "schema3", schema3Set, "uid", "thefoo");
memoryDirectoryFactory.registerDirectory(memdir3);
Session dir3 = memdir3.getSession();
e = new HashMap<String, Object>();
e.put("uid", "3");
e.put("thefoo", "foo3");
e.put("thebar", "bar3");
dir3.createEntry(e);
e = new HashMap<String, Object>();
e.put("uid", "4");
e.put("thefoo", "foo4");
e.put("thebar", "bar4");
dir3.createEntry(e);
// the multi directory
multiDir = (MultiDirectory) directoryService.getDirectory("multi");
dir = (MultiDirectorySession) multiDir.getSession();
}
/** Recomputes all the info needed for efficient access. */
private void recomputeSourceInfos() throws DirectoryException {
final Schema schema = schemaManager.getSchema(schemaName);
if (schema == null) {
throw new DirectoryException(
String.format("Directory '%s' has unknown schema '%s'", directory.getName(), schemaName));
}
final Set<String> sourceFields = new HashSet<String>();
for (Field f : schema.getFields()) {
sourceFields.add(f.getName().getLocalName());
}
if (!sourceFields.contains(schemaIdField)) {
throw new DirectoryException(
String.format(
"Directory '%s' schema '%s' has no id field '%s'",
directory.getName(), schemaName, schemaIdField));
}
List<SourceInfo> newSourceInfos = new ArrayList<SourceInfo>(2);
for (SourceDescriptor source : descriptor.sources) {
int ndirs = source.subDirectories.length;
if (ndirs == 0) {
throw new DirectoryException(
String.format(
"Directory '%s' source '%s' has no subdirectories",
directory.getName(), source.name));
}
final List<SubDirectoryInfo> subDirectoryInfos = new ArrayList<SubDirectoryInfo>(ndirs);
SubDirectoryInfo authDirectoryInfo = null;
boolean hasRequiredDir = false;
for (SubDirectoryDescriptor subDir : source.subDirectories) {
final String dirName = subDir.name;
final String dirSchemaName = directoryService.getDirectorySchema(dirName);
final String dirIdField = directoryService.getDirectoryIdField(dirName);
final boolean dirIsAuth = directoryService.getDirectoryPasswordField(dirName) != null;
final Map<String, String> fromSource = new HashMap<String, String>();
final Map<String, String> toSource = new HashMap<String, String>();
final Map<String, Serializable> defaultEntry = new HashMap<String, Serializable>();
final boolean dirIsOptional = subDir.isOptional;
// XXX check authenticating
final Schema dirSchema = schemaManager.getSchema(dirSchemaName);
if (dirSchema == null) {
throw new DirectoryException(
String.format(
"Directory '%s' source '%s' subdirectory '%s' " + "has unknown schema '%s'",
directory.getName(), source.name, dirName, dirSchemaName));
}
// record default field mappings if same name and record default
// values
final Set<String> dirSchemaFields = new HashSet<String>();
for (Field f : dirSchema.getFields()) {
final String fieldName = f.getName().getLocalName();
dirSchemaFields.add(fieldName);
if (sourceFields.contains(fieldName)) {
// XXX check no duplicates!
fromSource.put(fieldName, fieldName);
toSource.put(fieldName, fieldName);
}
// XXX cast to Serializable
defaultEntry.put(fieldName, (Serializable) f.getDefaultValue());
}
// treat renamings
// XXX id field ?
for (FieldDescriptor field : subDir.fields) {
final String sourceFieldName = field.forField;
final String fieldName = field.name;
if (!sourceFields.contains(sourceFieldName)) {
throw new DirectoryException(
String.format(
"Directory '%s' source '%s' subdirectory '%s' "
+ "has mapping for unknown field '%s'",
directory.getName(), source.name, dirName, sourceFieldName));
}
if (!dirSchemaFields.contains(fieldName)) {
throw new DirectoryException(
String.format(
"Directory '%s' source '%s' subdirectory '%s' "
+ "has mapping of unknown field' '%s'",
directory.getName(), source.name, dirName, fieldName));
}
fromSource.put(sourceFieldName, fieldName);
toSource.put(fieldName, sourceFieldName);
}
SubDirectoryInfo subDirectoryInfo =
new SubDirectoryInfo(
dirName,
dirSchemaName,
dirIdField,
dirIsAuth,
fromSource,
toSource,
defaultEntry,
dirIsOptional);
subDirectoryInfos.add(subDirectoryInfo);
if (dirIsAuth) {
if (authDirectoryInfo != null) {
throw new DirectoryException(
String.format(
"Directory '%s' source '%s' has two subdirectories "
+ "with a password field, '%s' and '%s'",
directory.getName(), source.name, authDirectoryInfo.dirName, dirName));
}
authDirectoryInfo = subDirectoryInfo;
}
if (!dirIsOptional) {
hasRequiredDir = true;
}
}
if (isAuthenticating() && authDirectoryInfo == null) {
throw new DirectoryException(
String.format(
"Directory '%s' source '%s' has no subdirectory " + "with a password field",
directory.getName(), source.name));
}
if (!hasRequiredDir) {
throw new DirectoryException(
String.format(
"Directory '%s' source '%s' only has optional subdirectories: "
+ "no directory can be used has a reference.",
directory.getName(), source.name));
}
newSourceInfos.add(new SourceInfo(source, subDirectoryInfos, authDirectoryInfo));
}
sourceInfos = newSourceInfos;
}