/*
* Copyright 2012-2013 Hauser Olsson GmbH
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package ch.agent.crnickl.mongodb;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.bson.types.ObjectId;
import ch.agent.crnickl.T2DBException;
import ch.agent.crnickl.T2DBMsg;
import ch.agent.crnickl.T2DBMsg.E;
import ch.agent.crnickl.api.Attribute;
import ch.agent.crnickl.api.Chronicle;
import ch.agent.crnickl.api.DBObjectType;
import ch.agent.crnickl.api.Database;
import ch.agent.crnickl.api.Property;
import ch.agent.crnickl.api.Series;
import ch.agent.crnickl.api.Surrogate;
import ch.agent.crnickl.impl.ChronicleImpl;
import ch.agent.crnickl.impl.Permission;
import ch.agent.crnickl.impl.SeriesImpl;
import ch.agent.crnickl.mongodb.T2DBMMsg.J;
import com.mongodb.BasicDBObject;
import com.mongodb.DBCursor;
import com.mongodb.DBObject;
/**
* A stateless object with methods providing read access to chronicles and
* series.
*
* @author Jean-Paul Vetterli
*/
public class ReadMethodsForChroniclesAndSeries extends MongoDatabaseMethods {
public ReadMethodsForChroniclesAndSeries() {
}
/**
* Find a chronicle corresponding to a surrogate. An
* exception is thrown if there is no such chronicle.
*
* @param s a surrogate
* @return a chronicle, never null
* @throws T2DBException
*/
public Chronicle getChronicle(Surrogate s) throws T2DBException {
DBObject obj = getObject(s, false);
Throwable cause = null;
if (obj != null)
try {
Chronicle chronicle = unpack(s.getDatabase(), (BasicDBObject) obj);
check(Permission.READ, chronicle);
return chronicle;
} catch (Exception e) {
cause = e;
}
throw T2DBMsg.exception(cause, E.E40104, s.toString());
}
/**
* Find a chronicle with a given parent and name.
*
* @param parent a chronicle
* @param name a string
* @return a chronicle or null
* @throws T2DBException
*/
public Chronicle getChronicleOrNull(Chronicle parent, String name) throws T2DBException {
try {
Database database = parent.getDatabase();
DBObject obj = getMongoDB(database).getChronicles().findOne(
mongoObject(MongoDatabase.FLD_CHRON_PARENT, getIdOrZero(parent),
MongoDatabase.FLD_CHRON_NAME, name));
if (obj != null) {
Chronicle chronicle = unpack(database, (BasicDBObject) obj);
check(Permission.READ, chronicle);
return chronicle;
} else
return null;
} catch (Exception e) {
throw T2DBMsg.exception(e, E.E40123, name, parent.getName(true));
}
}
public Collection<Chronicle> getChroniclesByParent(Chronicle parent) throws T2DBException {
Collection<Chronicle> result = new ArrayList<Chronicle>();
if (check(Permission.DISCOVER, parent, false)) {
try {
Database db = parent.getDatabase();
DBCursor cursor = getMongoDB(db).getChronicles().find(
mongoObject(MongoDatabase.FLD_CHRON_PARENT, getIdOrZero(parent)));
try {
while (cursor.hasNext()) {
Chronicle chronicle = unpack(db, (BasicDBObject) cursor.next());
check(Permission.READ, chronicle);
result.add(chronicle);
}
} finally {
cursor.close();
}
} catch (Exception e) {
throw T2DBMsg.exception(e, E.E40122, parent.getName(true));
}
}
return result;
}
/**
* The method completes the attribute with the value found for one of the
* entities in the list and returns true. If no value was found, the method
* return false. If more than value was found, the one selected corresponds
* to the first entity encountered in the list.
*
* @param chronicles a list of chronicles
* @param attribute an attribute
* @return true if any value found
* @throws T2DBException
*/
public boolean getAttributeValue(List<Chronicle> chronicles, Attribute<?> attribute) throws T2DBException {
boolean found = false;
Surrogate s = attribute.getProperty().getSurrogate();
Database db = s.getDatabase();
try {
ObjectId[] chrOids = new ObjectId[chronicles.size()];
int offset = 0;
for(Chronicle chronicle : chronicles) {
chrOids[offset++] = getId(chronicle);
}
DBCursor cursor = getMongoDB(db).getAttributes().find(
mongoObject(MongoDatabase.FLD_ATTR_PROP,
getId(s), MongoDatabase.FLD_ATTR_CHRON,
mongoObject(Operator.IN.op(), chrOids)));
offset = Integer.MAX_VALUE;
BasicDBObject objAtOffset = null;
while (cursor.hasNext()) {
BasicDBObject obj = (BasicDBObject) cursor.next();
ObjectId chrOid = obj.getObjectId(MongoDatabase.FLD_ATTR_CHRON);
int offset1 = findOffset(chrOid, chronicles);
if (offset1 < offset) {
offset = offset1;
objAtOffset = obj;
}
if (offset == 0)
break;
}
if (objAtOffset != null) {
ObjectId chrOid = objAtOffset.getObjectId(MongoDatabase.FLD_ATTR_CHRON);
Surrogate chronicle = makeSurrogate(db, DBObjectType.CHRONICLE, chrOid);
check(Permission.READ, chronicle);
attribute.scan(objAtOffset.getString(MongoDatabase.FLD_ATTR_VALUE));
String description = objAtOffset.getString(MongoDatabase.FLD_ATTR_DESC);
if (description.length() > 0)
attribute.setDescription(description);
found = true;
}
} catch (Exception e) {
throw T2DBMsg.exception(e, E.E40120, attribute.getProperty().getName());
}
return found;
}
/**
* Return a list of chronicles with a given value for a given property.
*
* @param property a property
* @param value a value
* @param maxSize the maximum size of the result or 0 for no limit
* @return a list of chronicles, possibly empty, never null
* @throws T2DBException
*/
public <T>List<Chronicle> getChroniclesByAttributeValue(Property<T> property, T value, int maxSize) throws T2DBException {
List<Chronicle> result = new ArrayList<Chronicle>();
Surrogate s = property.getSurrogate();
Database db = s.getDatabase();
try {
DBCursor cursor = getMongoDB(db).getAttributes().find(
mongoObject(MongoDatabase.FLD_ATTR_PROP,
getId(s), MongoDatabase.FLD_ATTR_VALUE,
property.getValueType().toString(value)));
while (cursor.hasNext()) {
BasicDBObject obj = (BasicDBObject) cursor.next();
ObjectId chrOid = obj.getObjectId(MongoDatabase.FLD_ATTR_CHRON);
Surrogate chronicle = makeSurrogate(db, DBObjectType.CHRONICLE, chrOid);
try {
check(Permission.READ, chronicle);
result.add(new ChronicleImpl(chronicle));
} catch (T2DBException e) {
// ignore "unreadable" chronicles
}
}
} catch (Exception e) {
throw T2DBMsg.exception(e, E.E40119, property.getName(), value);
}
return result;
}
/**
* Find a series corresponding to a surrogate.
*
* @param s a surrogate
* @return a series or null
* @throws T2DBException
*/
public <T>Series<T> getSeries(Surrogate s) throws T2DBException {
BasicDBObject obj = (BasicDBObject) getObject(s, false);
Throwable cause = null;
if (obj != null)
try {
ObjectId chrOid = obj.getObjectId(MongoDatabase.FLD_SER_CHRON);
int serNum = obj.getInt(MongoDatabase.FLD_SER_NUM);
Chronicle chronicle = new ChronicleImpl(
makeSurrogate(s.getDatabase(), DBObjectType.CHRONICLE, chrOid));
check(Permission.READ, chronicle);
Series<T> series = new SeriesImpl<T>(chronicle, null, serNum, s);
return series;
} catch (Exception e) {
cause = e;
}
throw T2DBMsg.exception(cause, E.E40104, s.toString());
}
/**
* Return array of series in the positions corresponding to the
* requested numbers. These numbers are series numbers within the schema,
* not the series keys in the database. When a requested number in the array is
* non-positive, the corresponding series will be null in the result. A
* series can also be null when the requested number is positive but the
* series has no data and has not been set up in the database (and therefore
* has no series database key).
* <p>
* Note. There is no exception if the chronicle does not exist. This behavior makes
* it easier to implement the wishful transaction protocol (i.e. testing again if it
* was okay to delete a chronicle after it was deleted).
*
* @param chronicle a chronicle
* @param names an array of simple names to plug into the series
* @param numbers an array of numbers
* @return an array of series
* @throws T2DBException
*/
public <T>Series<T>[] getSeries(Chronicle chronicle, String[] names, int[] numbers) throws T2DBException {
if (names.length != numbers.length)
throw new IllegalArgumentException("lengths of names[] and numbers[] differ");
@SuppressWarnings("unchecked")
Series<T>[] result = new SeriesImpl[numbers.length];
if (result.length > 0) {
Map<Integer, Integer> map = new HashMap<Integer, Integer>();
for (int i = 0; i < numbers.length; i++) {
if (numbers[i] > 0) {
if (map.put(numbers[i], i) != null)
throw new IllegalArgumentException("duplicate number: " + numbers[i]);
}
}
Surrogate s = chronicle.getSurrogate();
Database db = s.getDatabase();
try {
check(Permission.READ, chronicle);
} catch (Exception e) {
throw T2DBMsg.exception(e, E.E40104, s.toString());
}
try {
DBCursor cursor = getMongoDB(db).getSeries().find(
mongoObject(MongoDatabase.FLD_SER_CHRON,
getId(chronicle), MongoDatabase.FLD_SER_NUM,
mongoObject(Operator.IN.op(), numbers)),
mongoObject(MongoDatabase.FLD_SER_NUM, 1));
while (cursor.hasNext()) {
BasicDBObject obj = (BasicDBObject) cursor.next();
ObjectId serOid = obj.getObjectId(MongoDatabase.FLD_ID);
int serNumber = obj.getInt(MongoDatabase.FLD_SER_NUM);
int i = map.get(serNumber);
result[i] = new SeriesImpl<T>(chronicle,
names[i], numbers[i],
makeSurrogate(db, DBObjectType.SERIES, serOid));
}
} catch (Exception e) {
throw T2DBMsg.exception(e, E.E40121, chronicle.getName(true));
}
}
return result;
}
private Chronicle unpack(Database db, BasicDBObject obj) throws T2DBException {
try {
ObjectId id = obj.getObjectId(MongoDatabase.FLD_ID);
Surrogate s = makeSurrogate(db, DBObjectType.CHRONICLE, id);
ChronicleImpl.RawData data = new ChronicleImpl.RawData();
data.setSurrogate(s);
data.setName(obj.getString(MongoDatabase.FLD_CHRON_NAME));
data.setDescription(obj.getString(MongoDatabase.FLD_CHRON_DESC));
ObjectId parentId = obj.getObjectId(MongoDatabase.FLD_CHRON_PARENT);
data.setCollection(parentId == null ? db.getTopChronicle() :
new ChronicleImpl(makeSurrogate(db, DBObjectType.CHRONICLE, parentId)));
ObjectId schemaId = obj.getObjectId(MongoDatabase.FLD_CHRON_SCHEMA);
data.setSchema(schemaId == null ? null : makeSurrogate(db, DBObjectType.SCHEMA, schemaId));
Chronicle chronicle = new ChronicleImpl(data);
return chronicle;
} catch (ClassCastException e) {
throw T2DBMMsg.exception(e, J.J81010, obj.toString());
}
}
private int findOffset(ObjectId id, List<Chronicle> chronicles) {
int found = -1;
int offset = 0;
for(Chronicle chronicle : chronicles) {
if (getId(chronicle).equals(id)) {
found = offset;
break;
}
offset++;
}
if (found < 0)
throw new RuntimeException("chronicle not found: " + id);
return found;
}
}