/**
* List the entities in JSON format
*
* @param entities entities to return as JSON strings
*/
public static String writeJSON(Iterable<Entity> entities) {
logger.log(Level.INFO, "creating JSON format object");
StringBuilder sb = new StringBuilder();
int i = 0;
sb.append("{\"data\": [");
for (Entity result : entities) {
Map<String, Object> properties = result.getProperties();
sb.append("{");
if (result.getKey().getName() == null)
sb.append("\"name\" : \"" + result.getKey().getId() + "\",");
else sb.append("\"name\" : \"" + result.getKey().getName() + "\",");
for (String key : properties.keySet()) {
Object object = properties.get(key);
if (object instanceof Text) {
Text value = (Text) properties.get(key);
sb.append("\"" + key + "\" : \"" + value.getValue() + "\",");
// logger.info(value.getValue());//debug;
} else {
sb.append("\"" + key + "\" : \"" + properties.get(key) + "\",");
}
}
sb.deleteCharAt(sb.lastIndexOf(","));
sb.append("},");
i++;
}
if (i > 0) {
sb.deleteCharAt(sb.lastIndexOf(","));
}
sb.append("]}");
return sb.toString();
}
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, IOException {
String[] parts = req.getRequestURI().split("/");
String secret = parts[parts.length - 1];
String sessionId = parts[parts.length - 2];
PoorSession session = PoorSessionManager.findSessionById(sessionId);
if (session == null) {
resp.sendError(404, "Wrong credentials");
return;
}
Query query = new Query("User").addFilter("external-secret", FilterOperator.EQUAL, secret);
DatastoreService datastore = DatastoreServiceFactory.getDatastoreService();
PreparedQuery preparedQuery = datastore.prepare(query);
Entity entity = preparedQuery.asSingleEntity();
if (entity == null) {
resp.sendError(404, "Wrong credentials");
return;
}
String userId = entity.getProperty("email").toString();
log.info("Logging in user " + userId + "with session " + sessionId + " and secret " + secret);
PoorSessionManager.loginSession(session, userId);
// send success signal to the ext login page
ChannelService channelService = ChannelServiceFactory.getChannelService();
channelService.sendMessage(new ChannelMessage(sessionId, "success"));
resp.getWriter().write("Your browser is now logged in");
}
@Test
public void testEntityOnlyContainsProjectedProperties() throws Exception {
Entity a =
createEntity("Product", 1).withProperty("name", "b").withProperty("price", 1L).store();
Entity b =
createEntity("Product", 2).withProperty("name", "a").withProperty("price", 2L).store();
Query query =
new Query("Product")
.addProjection(new PropertyProjection("price", Long.class))
.setFilter(new Query.FilterPredicate("name", IN, Arrays.asList("a", "b")));
Entity firstResult = service.prepare(query).asList(FetchOptions.Builder.withDefaults()).get(0);
assertEquals(1, firstResult.getProperties().size());
assertEquals("price", firstResult.getProperties().keySet().iterator().next());
query =
new Query("Product")
.setKeysOnly()
.setFilter(new Query.FilterPredicate("name", IN, Arrays.asList("a", "b")));
firstResult = service.prepare(query).asList(FetchOptions.Builder.withDefaults()).get(0);
assertEquals(0, firstResult.getProperties().size());
}
@Override
public Datastore.Stats getStats(boolean useCache) {
if (useCache) {
try {
Stats cachedStats = (Stats) STATS_CACHE.get(STATS_CACHE_KEY);
if (cachedStats != null) {
return cachedStats;
}
logger.info("Stats not in cache, re-computing");
} catch (InvalidValueException err) {
logger.log(Level.WARNING, "Could not load data from memcache", err);
}
}
Stats ret = new Stats();
DatastoreService datastore = DatastoreServiceFactory.getDatastoreService();
PreparedQuery pq =
datastore.prepare(new com.google.appengine.api.datastore.Query("__Stat_Kind__"));
for (Entity kindStat : pq.asIterable()) {
String kind = (String) kindStat.getProperty("kind_name");
if ("Channel".equals(kind)) {
ret.numChannels = ((Long) kindStat.getProperty("count")).intValue();
ret.timestamp = (Date) kindStat.getProperty("timestamp");
}
}
ret.numUsers = countUsersActiveInLastNDays(datastore, -1);
ret.oneDayActiveUsers = countUsersActiveInLastNDays(datastore, 1);
ret.sevenDayActiveUsers = countUsersActiveInLastNDays(datastore, 7);
ret.thirtyDayActiveUsers = countUsersActiveInLastNDays(datastore, 30);
STATS_CACHE.put(STATS_CACHE_KEY, ret);
return ret;
}
public Entity implement(Key requirementVersionKey, Key contentVersionKey) {
Entity requirementVersion = this.find(requirementVersionKey);
requirementVersion.setProperty(
RequirementVersion.CONTENT_KEY_STRING, KeyFactory.keyToString(contentVersionKey));
this.merge(requirementVersion);
return requirementVersion;
}
/**
* Retrieve
*
* @throws IOException
* @throws IllegalArgumentException
* @throws NoSuchProviderException
* @throws NoSuchAlgorithmException
*/
private long computeAndReturnTime(
long remainTime, List<Entity> works, List<PlayWorkBean> playWorks)
throws NoSuchAlgorithmException, NoSuchProviderException, IllegalArgumentException,
IOException {
int sortedSize = works.size();
// randomize for getting work in the list
int randomId = Random.getInstance().getNumericRandomInt(sortedSize);
// get work
Entity currentWork = works.remove(randomId);
long randomWorkTime = 0;
// music case
if (WorkTypeEnum.MUSIC.name().equals(currentWork.getProperty("type"))) {
Long musicTime = (Long) currentWork.getProperty("time");
randomWorkTime = musicTime.longValue();
} else {
// randomize for work time displaying
randomWorkTime = minWorkTime + Random.getInstance().getNumericRandomInt(maxWorkTime);
}
// avoid randomWorkTime to be superior at remain time
if (remainTime < randomWorkTime) {
randomWorkTime = remainTime;
}
playWorks.add(new PlayWorkBean(Long.valueOf(randomWorkTime), currentWork.getKey()));
return randomWorkTime;
}
/**
* Searches for an existing entity
*
* @param searchIn what kind of entity to search in
* @param parent the parent for the entity, set to null to skip using
* @param filters the values to search for
* @return found key for entity
*/
public static Key getSingleKey(String searchIn, Key parent, FilterWrapper... filters) {
Entity foundEntity = getSingleEntity(searchIn, parent, true, filters);
if (foundEntity != null) {
return foundEntity.getKey();
}
return null;
}
public void testSimpleSerializeWithoutTxns() throws Exception {
switchDatasource(PersistenceManagerFactoryName.nontransactional);
pm.setDetachAllOnCommit(true);
DetachableJDO pojo = new DetachableJDO();
pojo.setVal("yar");
Date now = new Date();
pojo.setDate(now);
pm.makePersistent(pojo);
// DN3 changes this from P_NEW to DETACHED_CLEAN since detachAllOnCommit
assertEquals(ObjectState.DETACHED_CLEAN, JDOHelper.getObjectState(pojo));
pm.close();
assertEquals(ObjectState.DETACHED_CLEAN, JDOHelper.getObjectState(pojo));
assertEquals(Date.class, pojo.getDate().getClass());
pm = pmf.getPersistenceManager();
assertEquals(ObjectState.DETACHED_CLEAN, JDOHelper.getObjectState(pojo));
pojo = toBytesAndBack(pojo);
assertEquals("yar", pojo.getVal());
assertEquals(ObjectState.DETACHED_CLEAN, JDOHelper.getObjectState(pojo));
pojo.setVal("not yar");
Date newDate = new Date(pojo.getDate().getTime() + 1);
pojo.getDate().setTime(newDate.getTime());
assertEquals(ObjectState.DETACHED_DIRTY, JDOHelper.getObjectState(pojo));
pm.makePersistent(pojo);
pm.close();
Entity e = ds.get(KeyFactory.createKey(DetachableJDO.class.getSimpleName(), pojo.getId()));
assertEquals("not yar", e.getProperty("val"));
assertEquals(newDate, e.getProperty("date"));
}
public void doPost(HttpServletRequest req, HttpServletResponse resp) throws IOException {
long time_start, time_end;
DatastoreService datastore = DSF.getDatastoreService();
Query query = new Query("GeoPos");
time_start = System.currentTimeMillis();
PreparedQuery pq = datastore.prepare(query);
// List<Entity> result = datastore.prepare(query).asList(FetchOptions.Builder.withLimit(5));
for (Entity geopos : pq.asIterable()) {
// RTree.insert(new float[] {Float.parseFloat(geopos.getProperty("latitude").toString()),
// Float.parseFloat(geopos.getProperty("longitude").toString())}, new float[] {0.0f, 0.0f},
// geopos);
// resp.getWriter().println(geopos.getProperty("name"));
// resp.getWriter().println(geopos.getProperty("latitude"));
// resp.getWriter().println(geopos.getProperty("longitude"));
RTree.insert(
new float[] {
Float.parseFloat(geopos.getProperty("latitude").toString()),
Float.parseFloat(geopos.getProperty("longitude").toString())
},
new float[] {0.0f, 0.0f},
geopos);
}
time_end = System.currentTimeMillis();
resp.getWriter().println((time_end - time_start));
// resp.sendRedirect("/rtree.jsp");
}
public void testSerializeWithOneToMany_AddChildToReattached() throws Exception {
pm.setDetachAllOnCommit(true);
beginTxn();
HasOneToManyListJDO pojo = new HasOneToManyListJDO();
pojo.setVal("yar");
BidirectionalChildListJDO bidir = new BidirectionalChildListJDO();
bidir.setChildVal("yar2");
pojo.addBidirChild(bidir);
pm.makePersistent(pojo);
commitTxn();
pm.close();
pm = pmf.getPersistenceManager();
pojo = toBytesAndBack(pojo);
assertEquals("yar", pojo.getVal());
assertEquals(1, pojo.getBidirChildren().size());
beginTxn();
pojo = pm.makePersistent(pojo);
BidirectionalChildListJDO bidir2 = new BidirectionalChildListJDO();
bidir.setChildVal("yar3");
pojo.addBidirChild(bidir2);
bidir2.setParent(pojo);
commitTxn();
Entity e = ds.get(KeyFactory.stringToKey(bidir2.getId()));
assertEquals(KeyFactory.stringToKey(pojo.getId()), e.getKey().getParent());
}
public void testSimpleSerializeWithTxns()
throws IOException, ClassNotFoundException, EntityNotFoundException {
pm.setDetachAllOnCommit(true);
beginTxn();
DetachableJDO pojo = new DetachableJDO();
pojo.setVal("yar");
Date now = new Date();
pojo.setDate(now);
pm.makePersistent(pojo);
commitTxn();
assertEquals(ObjectState.DETACHED_CLEAN, JDOHelper.getObjectState(pojo));
assertEquals(Date.class, pojo.getDate().getClass());
pm.close();
assertEquals(ObjectState.DETACHED_CLEAN, JDOHelper.getObjectState(pojo));
pm = pmf.getPersistenceManager();
assertEquals(ObjectState.DETACHED_CLEAN, JDOHelper.getObjectState(pojo));
pojo = toBytesAndBack(pojo);
assertEquals("yar", pojo.getVal());
assertEquals(now, pojo.getDate());
assertEquals(ObjectState.DETACHED_CLEAN, JDOHelper.getObjectState(pojo));
beginTxn();
assertEquals(ObjectState.DETACHED_CLEAN, JDOHelper.getObjectState(pojo));
pojo.setVal("not yar");
Date newDate = new Date(pojo.getDate().getTime() + 1);
pojo.getDate().setTime(newDate.getTime());
assertEquals(ObjectState.DETACHED_DIRTY, JDOHelper.getObjectState(pojo));
pm.makePersistent(pojo);
commitTxn();
Entity e = ds.get(KeyFactory.createKey(DetachableJDO.class.getSimpleName(), pojo.getId()));
assertEquals("not yar", e.getProperty("val"));
assertEquals(newDate, e.getProperty("date"));
}
public void testSerializeWithOneToMany_AddUnidirectionalChildToDetached() throws Exception {
pm.setDetachAllOnCommit(true);
beginTxn();
HasOneToManyListJDO pojo = new HasOneToManyListJDO();
pojo.setVal("yar");
Flight flight = new Flight();
flight.setName("harry");
pojo.addFlight(flight);
pm.makePersistent(pojo);
commitTxn();
pm.close();
pm = pmf.getPersistenceManager();
pojo = toBytesAndBack(pojo);
assertEquals("yar", pojo.getVal());
assertEquals(1, pojo.getFlights().size());
Flight flight2 = new Flight();
flight2.setName("not harry");
pojo.addFlight(flight2);
beginTxn();
pojo = pm.makePersistent(pojo);
commitTxn();
Entity e = ds.get(KeyFactory.stringToKey(flight2.getId()));
assertEquals(KeyFactory.stringToKey(pojo.getId()), e.getKey().getParent());
}
public void testSerializeWithMultiValueProps() throws Exception {
pm.setDetachAllOnCommit(true);
beginTxn();
DetachableWithMultiValuePropsJDO pojo = new DetachableWithMultiValuePropsJDO();
pojo.setStrList(Utils.newArrayList("c", "d"));
pm.makePersistent(pojo);
commitTxn();
assertEquals(ObjectState.DETACHED_CLEAN, JDOHelper.getObjectState(pojo));
pm.close();
assertEquals(ObjectState.DETACHED_CLEAN, JDOHelper.getObjectState(pojo));
pm = pmf.getPersistenceManager();
assertEquals(ObjectState.DETACHED_CLEAN, JDOHelper.getObjectState(pojo));
pojo = toBytesAndBack(pojo);
assertEquals(Utils.newArrayList("c", "d"), pojo.getStrList());
assertEquals(ObjectState.DETACHED_CLEAN, JDOHelper.getObjectState(pojo));
beginTxn();
assertEquals(ObjectState.DETACHED_CLEAN, JDOHelper.getObjectState(pojo));
// reattach to the pm - this turns our regular list field into a managed
// list field
pojo = pm.makePersistent(pojo);
assertEquals(ObjectState.PERSISTENT_CLEAN, JDOHelper.getObjectState(pojo));
pojo.getStrList().add("e");
commitTxn();
Entity e =
ds.get(
KeyFactory.createKey(
DetachableWithMultiValuePropsJDO.class.getSimpleName(), pojo.getId()));
assertEquals(3, ((List<String>) e.getProperty("strList")).size());
assertEquals(Utils.newArrayList("c", "d", "e"), e.getProperty("strList"));
}
/**
* Convenience function to extend this MarkerObj with another MarkerObj. Normally used when
* updating the database. entityMe param makes sure that the current user has permission to update
* some properties.
*/
public void extend(MarkerObj other, Entity entityMe) {
lat = other.lat;
lng = other.lng;
cat = other.cat;
near = other.near;
info = other.info;
privacy = other.privacy;
updatedDate = new Date().getTime();
String myName = (String) entityMe.getProperty("name");
String myPrivileges = (String) entityMe.getProperty("privileges");
if (myPrivileges.equals("random")) {
title = myName;
} else {
if (other.title != null) title = other.title;
}
if (myPrivileges.equals("admin")) {
if (other.type != null) type = other.type;
if (other.author != null) author = other.author;
if (other.creationDate != null) creationDate = other.creationDate;
}
// TODO: Remove properties that do not apply anymore if the type was changed (not important, low
// priority).
}
@Override
public List<DataObj> getAllDataObj(String deviceId) {
ArrayList<DataObj> list = new ArrayList<DataObj>();
DatastoreService datastore = DatastoreServiceFactory.getDatastoreService();
// The Query interface assembles a query
Query q = new Query("DataObj");
q.addFilter("deviceId", Query.FilterOperator.EQUAL, deviceId);
// q.addSort("score", SortDirection.DESCENDING);
// PreparedQuery contains the methods for fetching query results
// from the datastore
PreparedQuery pq = datastore.prepare(q);
for (Entity result : pq.asIterable()) {
double longCord = (double) result.getProperty("longCord");
double latCord = (double) result.getProperty("latCord");
double value = (double) result.getProperty("value");
long time = (Long) result.getProperty("time");
list.add(new DataObj(deviceId, longCord, latCord, value, time));
}
return list;
}
@InSequence(10)
@Test
@OperateOnDeployment("dep1")
public void insertIntoBlobstoreOnDep1() throws Exception {
BlobstoreService service = BlobstoreServiceFactory.getBlobstoreService();
FileService fileService = FileServiceFactory.getFileService();
AppEngineFile file = fileService.createNewBlobFile("text/plain", "uploadedText.txt");
FileWriteChannel channel = fileService.openWriteChannel(file, true);
try {
channel.write(ByteBuffer.wrap(TEXT.getBytes()));
} finally {
channel.closeFinally();
}
waitForSync();
BlobKey blobKey = fileService.getBlobKey(file);
System.out.println("Blob key: " + blobKey);
byte[] bytes = service.fetchData(blobKey, 0, Long.MAX_VALUE);
Assert.assertEquals(TEXT, new String(bytes));
DatastoreService ds = DatastoreServiceFactory.getDatastoreService();
Entity dsBK = new Entity("blobTestId", 1);
dsBK.setProperty("blogId", blobKey.getKeyString());
ds.put(dsBK);
waitForSync();
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, IOException {
// super.doPost(req, resp);
DatastoreService datastore = DatastoreServiceFactory.getDatastoreService();
Gson gson = new Gson();
Plan pl = gson.fromJson(req.getParameter("PARAM"), Plan.class);
Entity plan = new Entity("Plan");
plan.setProperty("title", pl.getTitle());
plan.setProperty("description", pl.getDesc());
plan.setProperty("domain", pl.getDomain());
plan.setProperty("totalLength", pl.getTotalTime());
System.out.println(pl.getTotalTime());
Key planKey = datastore.put(plan);
List<Exercise> listEx = pl.getExercises();
Entity exercise;
for (Exercise ex : listEx) {
exercise = new Entity("Exercise", planKey);
exercise.setProperty("title", ex.getTitle());
exercise.setProperty("description", ex.getDesc());
String length = ex.getLength();
String[] splitStr = length.split(":");
Integer seconds = Integer.parseInt(splitStr[0]) * 60 + Integer.parseInt(splitStr[1]);
exercise.setProperty("length", seconds);
exercise.setProperty("row", ex.getRow());
datastore.put(exercise);
}
}
@SuppressWarnings("deprecation")
@GET
@Path("/list/")
@Produces("application/json")
public JSONArray doGet(@QueryParam("ids") String paramIds) {
DatastoreService datastore = DatastoreServiceFactory.getDatastoreService();
String[] ids = paramIds.split(",");
JSONArray jsonMovies = new JSONArray();
for (String id : ids) {
Entity movieEntity;
JSONObject movieToAdd = null;
Query query = new Query("Movie").addFilter("redboxid", Query.FilterOperator.EQUAL, id);
List<Entity> movieEntitiesArray =
datastore.prepare(query).asList(FetchOptions.Builder.withLimit(5));
if (movieEntitiesArray.size() == 0) {
// need to get the movie from the Redbox and then add to db
movieEntity = getRedboxInfoAndAdd();
} else {
movieEntity = movieEntitiesArray.get(0);
}
try {
// todo put the movie properties here
movieToAdd.put("title", movieEntity.getProperty("title"));
} catch (JSONException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
return jsonMovies;
}
@SuppressWarnings("unchecked")
@Override
protected Response findPizzaComponents(String token) {
if (token == null) {
return RestResponse.FORBIDDEN();
}
DatastoreService datastore = DatastoreServiceFactory.getDatastoreService();
Key key = KeyFactory.createKey("PizzaFactory", token);
List<PizzaCrust> components = null;
try {
Entity pizzaFactory = datastore.get(key);
List<EmbeddedEntity> list = (List<EmbeddedEntity>) pizzaFactory.getProperty(type);
components = new ArrayList<PizzaCrust>();
if (list != null) {
for (EmbeddedEntity e : list) {
PizzaCrust component = PizzaCrustResource.entityToObject(e);
components.add(component);
}
}
GenericEntity<List<PizzaCrust>> lists = new GenericEntity<List<PizzaCrust>>(components) {};
response = RestResponse.OK(lists);
} catch (EntityNotFoundException e) {
response = RestResponse.NOT_FOUND();
}
return response;
}
/**
* This method is used for updating an existing entity. If the entity does not exist in the
* datastore, an exception is thrown. It uses HTTP PUT method.
*
* @param store the entity to be updated.
* @return The updated entity.
* @throws UnauthorizedException
*/
@ApiMethod(
name = "modify",
scopes = {Config.EMAIL_SCOPE},
clientIds = {Config.CHROME_CLIENT_ID, Config.WEB_CLIENT_ID, Config.API_EXPLORER_CLIENT_ID})
public ServiceResponse modify(
@Named("_name") String _name, @Named("_id") Long _id, ServiceRequest req, User user)
throws UnauthorizedException {
if (user == null) {
throw new UnauthorizedException("UnauthorizedException # User is Null.");
}
Key key = KeyFactory.createKey(_name, _id);
Date currentDate = new Date();
String userEmail = user.getEmail();
DatastoreService dsService = DatastoreServiceFactory.getDatastoreService();
ServiceResponse res = new ServiceResponse();
try {
Entity entity = dsService.get(key);
entity.setProperty(_updatedAt, currentDate);
entity.setProperty(_updatedBy, userEmail);
entity.setUnindexedProperty(data, new Text(req.getData()));
dsService.put(entity);
res.set_id(entity.getKey().getId());
} catch (com.google.appengine.api.datastore.EntityNotFoundException e) {
throw new EntityNotFoundException("Object does not exist.");
}
return res;
}
/**
* Get a UUID property from an entity
*
* @param entity the entity to get the UUID from
* @param propertyName name of the property
* @return Stored UUID, null if it doesn't exist
*/
public static UUID getPropertyUuid(Entity entity, String propertyName) {
if (entity.hasProperty(propertyName)) {
return UUID.fromString((String) entity.getProperty(propertyName));
}
return null;
}
private ServiceResponse updateStatus(String _name, Long _id, String _status, User user)
throws UnauthorizedException {
if (user == null) {
throw new UnauthorizedException("UnauthorizedException # User is Null.");
}
Key key = KeyFactory.createKey(_name, _id);
Date currentDate = new Date();
String userEmail = user.getEmail();
DatastoreService dsService = DatastoreServiceFactory.getDatastoreService();
ServiceResponse res = new ServiceResponse();
try {
Entity entity = dsService.get(key);
entity.setProperty(_updatedAt, currentDate);
entity.setProperty(_updatedBy, userEmail);
entity.setProperty(_status, _status);
dsService.put(entity);
res.set_id(entity.getKey().getId());
} catch (com.google.appengine.api.datastore.EntityNotFoundException e) {
throw new EntityNotFoundException("Object does not exist");
}
return res;
}
/**
* Persists {@code this} test report to the given {@link
* com.google.appengine.api.datastore.DatastoreService} and invalidate the cache.
*
* @param reports the reports entry point
*/
public void save(Reports reports) {
final Entity entity = new Entity(TEST_REPORT, buildTypeId + buildId);
entity.setProperty("buildTypeId", buildTypeId);
entity.setProperty("buildId", buildId);
entity.setProperty("buildDate", buildDate);
entity.setProperty("buildDuration", buildDuration);
entity.setProperty("numberOfPassedTests", numberOfPassedTests);
entity.setProperty("numberOfIgnoredTests", numberOfIgnoredTests);
entity.setProperty("numberOfFailedTests", numberOfFailedTests);
final JSONArray jsonArrayFailedTests = new JSONArray();
for (Test oneFailingTest : failedTests) {
jsonArrayFailedTests.put(oneFailingTest.asJson());
}
entity.setProperty("failedTests", new Text(jsonArrayFailedTests.toString()));
final JSONArray jsonArrayIgnoredTests = new JSONArray();
for (Test oneIgnoredTest : ignoredTests) {
jsonArrayIgnoredTests.put(oneIgnoredTest.asJson());
}
entity.setProperty("ignoredTests", new Text(jsonArrayIgnoredTests.toString()));
final DatastoreService datastoreService = reports.getDatastoreService();
datastoreService.put(entity);
final MemcacheService memcacheService = reports.getMemcacheService();
memcacheService.delete(buildTypeId); // invalidate cache
}
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, IOException {
String source = req.getParameter("source");
ImagesService imagesService = ImagesServiceFactory.getImagesService();
DatastoreService datastore = DatastoreServiceFactory.getDatastoreService();
List<Filter> filters = new ArrayList<Filter>();
Query query = new Query(GAEFeedRepository.FEED_ITEM_KIND);
filters.add(new Query.FilterPredicate("source", FilterOperator.EQUAL, source));
filters.add(new Query.FilterPredicate("img1A", FilterOperator.EQUAL, 1));
filters.add(new Query.FilterPredicate("img2A", FilterOperator.EQUAL, 1));
query.setFilter(CompositeFilterOperator.and(filters));
query.addSort("publishedDate", SortDirection.DESCENDING);
PreparedQuery pq = datastore.prepare(query);
int pageSize = 30;
resp.setContentType("text/html");
resp.getWriter().println(" <ul>");
FetchOptions fetchOptions = FetchOptions.Builder.withLimit(pageSize);
String startCursor = req.getParameter("cursor");
// If this servlet is passed a cursor parameter, let's use it
if (startCursor != null) {
fetchOptions.startCursor(Cursor.fromWebSafeString(startCursor));
}
QueryResultList<Entity> results = pq.asQueryResultList(fetchOptions);
for (Entity entity : results) {
resp.getWriter()
.println(
"<li>"
+ entity.getProperty("imageLink")
+ " / "
+ imagesService.getServingUrl(
ServingUrlOptions.Builder.withBlobKey((BlobKey) entity.getProperty("img2")))
+ " / <img height=40 width=40 src=\""
+ imagesService.getServingUrl(
ServingUrlOptions.Builder.withBlobKey((BlobKey) entity.getProperty("img2")))
+ "\" />");
}
resp.getWriter().println("</li> </entity></ul> ");
String cursor = results.getCursor().toWebSafeString();
// Assuming this servlet lives at '/people'
resp.getWriter()
.println(
"<a href=\"/p8admin/ListFeedItems?cursor="
+ cursor
+ "&source="
+ source
+ "\">Next page</a>");
}
public void remove(Key requirementVersionKey) {
LogEntityManager logEntityManager = new LogEntityManager();
Transaction txn = datastore.beginTransaction();
try {
Entity artifactVersion = this.find(requirementVersionKey);
Entity artifact = this.find(artifactVersion.getParent());
Entity project = this.find(artifact.getParent());
logEntityManager.persist(
project.getKey(),
new Date(),
"O usu�rio "
+ artifact.getProperty(Artifact.CREATOR_ID)
+ " removeu o requisito "
+ artifact.getProperty(Artifact.NUMBER)
+ ": "
+ artifact.getProperty(Artifact.TITLE)
+ " do projeto "
+ project.getProperty(Project.PROJECT_NAME));
super.remove(requirementVersionKey);
txn.commit();
} finally {
if (txn.isActive()) {
txn.rollback();
throw new TransactionException();
}
}
}
@SuppressWarnings("deprecation")
public static Entity getEntity(String id) {
Entity entity = null;
if (syncCache.contains(id)) {
entity = (Entity) syncCache.get(id);
}
if (entity == null) {
Query q = new Query("storedString");
// q.setFilter(new Query.FilterPredicate("id", Query.FilterOperator.EQUAL, id));
q.addFilter("id", Query.FilterOperator.EQUAL, id);
PreparedQuery pq = datastore.prepare(q);
try {
entity = pq.asSingleEntity();
} catch (PreparedQuery.TooManyResultsException e) {
Iterator<Entity> iter = pq.asIterator();
while (iter.hasNext()) {
Entity ent = iter.next();
if (entity == null) {
entity = ent;
} else {
datastore.delete(ent.getKey());
}
}
}
if (entity != null) {
// log.warning("store (because found in datastore) :"+id+" : "+entity.getKey());
syncCache.put(id, entity);
}
}
// log.warning("return :"+id+" : "+(entity!=null?entity.getKey():""));
return entity;
}
@Test
public void testProjectionOfCollectionPropertyWithFilterOnCollectionProperty() throws Exception {
Entity e =
createEntity("Product", 1)
.withProperty("name", Arrays.asList("aaa", "bbb"))
.withProperty("price", Arrays.asList(10L, 20L))
.store();
Query query =
new Query("Product")
.addProjection(new PropertyProjection("name", String.class))
.setFilter(new Query.FilterPredicate("price", GREATER_THAN, 0L))
.addSort("price")
.addSort("name");
PreparedQuery preparedQuery = service.prepare(query);
List<Entity> results = preparedQuery.asList(withDefaults());
assertEquals(4, results.size());
assertEquals(e.getKey(), results.get(0).getKey());
assertEquals(e.getKey(), results.get(1).getKey());
assertEquals(e.getKey(), results.get(2).getKey());
assertEquals(e.getKey(), results.get(3).getKey());
assertEquals("aaa", results.get(0).getProperty("name"));
assertEquals("bbb", results.get(1).getProperty("name"));
assertEquals("aaa", results.get(2).getProperty("name"));
assertEquals("bbb", results.get(3).getProperty("name"));
}
public static String verifyToken(String token) {
DatastoreService datastore = DatastoreServiceFactory.getDatastoreService();
Transaction txn = datastore.beginTransaction();
try {
Query searchToken = new Query("Token").addFilter("token", FilterOperator.EQUAL, token);
Entity tokenEntity = datastore.prepare(searchToken).asSingleEntity();
if (null == tokenEntity) {
log.warn("Token {} not found - error", token);
return null;
}
log.info("Updating token");
tokenEntity.setProperty("accessed", new Date().getTime());
datastore.put(txn, tokenEntity);
txn.commit();
log.info("Token OK");
Entity userEntity = datastore.get((Key) tokenEntity.getProperty("user"));
return (String) userEntity.getProperty("username");
} catch (Exception e) {
log.error("Token error", e);
return null;
} finally {
if (txn.isActive()) {
txn.rollback();
}
}
}
/** @throws Exception */
@Test(expected = IllegalArgumentException.class)
public void getModelMetaWithEntityForIllegalClass() throws Exception {
AaaMeta aaaMeta = new AaaMeta();
Entity entity = new Entity("Aaa");
entity.setProperty(aaaMeta.getClassHierarchyListName(), Arrays.asList(Bbb.class.getName()));
DatastoreUtil.getModelMeta(meta, entity);
}
@Test
public void transactionsOnVariusTypesOfEntities() throws EntityNotFoundException {
Entity person = new Entity("Person", "tom");
datastore.put(person);
// Transaction on root entities
Transaction transaction = datastore.beginTransaction();
Entity tom = datastore.get(person.getKey());
tom.setProperty("age", 40);
datastore.put(tom);
transaction.commit();
// Transaction on child entities
transaction = datastore.beginTransaction();
tom = datastore.get(person.getKey());
// Create a Photo entity that is a child of Person entity named "tom"
Entity photo = new Entity("Photo", tom.getKey());
photo.setProperty("photoUrl", "images/photo");
datastore.put(photo);
transaction.commit();
// Transaction on entities in different entity groups
transaction = datastore.beginTransaction();
Entity photoNotChild = new Entity("Photo");
photoNotChild.setProperty("photoUrl", "images/photo");
datastore.put(photoNotChild);
transaction.commit();
}
