@ApiMethod(name = "group.save", httpMethod = ApiMethod.HttpMethod.POST)
public void setSaveGroup(@Named("groupId") Long groupId, Group data) throws IOException {
// Get the key
Key rootKey = KeyFactory.createKey("Root", 1);
Key groupKey = KeyFactory.createKey(rootKey, "Group", groupId);
// Get or create the group
Entity group;
try {
group = dataStore.get(groupKey);
//noinspection unchecked
List<Key> keys = (List<Key>) group.getProperty("forms");
keys = firstNonNull(keys, Collections.<Key>emptyList());
// Erase all the previous data
dataStore.delete(keys);
} catch (EntityNotFoundException e) {
logger.fine("Creating new group");
}
// Saves the new data
JsonNode json = NewData.mapper().convertValue(data, JsonNode.class);
NewData newData = new NewData(dataStore, json);
newData.run(true);
}
@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;
}
/**
* Delete list of entities given their keys
*
* @param keys
*/
public static void deleteEntity(final List<Key> keys) {
datastore.delete(
new Iterable<Key>() {
public Iterator<Key> iterator() {
return keys.iterator();
}
});
}
public static boolean deleteEntity(Key key) {
try {
ds.delete(key);
return true;
} catch (Exception e) {
return false;
}
}
public static boolean dropEntity(String id) {
Entity entity = getEntity(id);
if (entity != null) {
// log.warning("drop :"+id+ " : "+ entity.getKey());
datastore.delete(entity.getKey());
syncCache.delete(id);
return true;
}
return false;
}
/**
* Deletes a persistent record with the devices to be notified using a multicast message.
*
* @param encodedKey encoded key for the persistent record.
*/
public static void deleteMulticast(String encodedKey) {
Transaction txn = datastore.beginTransaction();
try {
Key key = KeyFactory.stringToKey(encodedKey);
datastore.delete(key);
txn.commit();
} finally {
if (txn.isActive()) {
txn.rollback();
}
}
}
public Object process() throws xMethodException {
boolean valid = true;
String why = "";
String id = this.getArguments("id");
try {
DatastoreService ds = DatastoreServiceFactory.getDatastoreService();
ds.delete(KeyFactory.stringToKey(id));
} catch (Exception e) {
}
setReturnArguments("valid", String.valueOf(valid));
setReturnArguments("why", why);
return getServiceContext().doNextProcess();
}
public void deleteAudioClip(String audioClipId) throws BadRequestException {
AudioClip audioClip = getAudioClipById(audioClipId);
datastore.delete(KeyFactory.stringToKey(audioClipId));
// task queue to delete the associated audio and image blobs
Queue queue = QueueFactory.getDefaultQueue();
queue.add(
TaskOptions.Builder.withUrl("/rest/users/" + audioClip.getOwnerId() + "/audioClips/audio")
.method(TaskOptions.Method.DELETE)
.param("blobkey", audioClip.getAudioId()));
queue.add(
TaskOptions.Builder.withUrl("/rest/users/" + audioClip.getOwnerId() + "/audioClips/image")
.method(TaskOptions.Method.DELETE)
.param("blobkey", audioClip.getImageId()));
}
public void doPost(HttpServletRequest req, HttpServletResponse resp) throws IOException {
Transaction tx = datastore.beginTransaction();
try {
Key playerKey = KeyFactory.createKey("JoinGameKey", "PlayerList");
Query query = new Query("JoinGame", playerKey);
List<Entity> playerList =
datastore.prepare(query).asList(FetchOptions.Builder.withLimit(100));
for (Entity e : playerList) datastore.delete(e.getKey());
tx.commit();
} catch (Exception e) {
if (tx.isActive()) tx.rollback();
ExceptionStringify es = new ExceptionStringify(e);
resp.getWriter().print(es.run());
}
resp.getWriter().println("{'result':'Deleted players'}");
}
/**
* This method removes the entity with primary key id. It uses HTTP DELETE method.
*
* @param id the primary key of the entity to be deleted.
* @throws UnauthorizedException
*/
@ApiMethod(
name = "remove",
scopes = {Config.EMAIL_SCOPE},
clientIds = {Config.CHROME_CLIENT_ID, Config.WEB_CLIENT_ID, Config.API_EXPLORER_CLIENT_ID})
public ServiceResponse remove(@Named("_name") String _name, @Named("_id") Long _id, User user)
throws UnauthorizedException {
if (user == null) {
throw new UnauthorizedException("UnauthorizedException # User is Null.");
}
Key key = KeyFactory.createKey(_name, _id);
DatastoreService dsService = DatastoreServiceFactory.getDatastoreService();
dsService.delete(key);
ServiceResponse res = new ServiceResponse();
res.set_id(_id);
return res;
}
/**
* Unregisters a device.
*
* @param regId device's registration id.
*/
public static void unregister(String regId) {
logger.info("Unregistering " + regId);
Transaction txn = datastore.beginTransaction();
try {
Entity entity = findDeviceByRegId(regId);
if (entity == null) {
logger.warning("Device " + regId + " already unregistered");
} else {
Key key = entity.getKey();
datastore.delete(key);
}
txn.commit();
} finally {
if (txn.isActive()) {
txn.rollback();
}
}
}
@ApiMethod(name = "clearTasks")
public void clearTasks() {
DatastoreService datastoreService = DatastoreServiceFactory.getDatastoreService();
Transaction txn = datastoreService.beginTransaction();
try {
Key taskBeanParentKey = KeyFactory.createKey("TaskBeanParent", "todo.txt");
Query query = new Query(taskBeanParentKey);
List<Entity> results =
datastoreService.prepare(query).asList(FetchOptions.Builder.withDefaults());
for (Entity result : results) {
datastoreService.delete(result.getKey());
}
txn.commit();
} finally {
if (txn.isActive()) {
txn.rollback();
}
}
}
public void delete(Key key) {
if (deletedCache.getIfPresent(key) != null) return;
if (myKey.equals(key)) {
deletedCache.put(key, this);
}
try {
Entity ent = datastore.get(key);
if (ent.hasProperty("next")) {
delete((Key) ent.getProperty("next")); // recurse
}
datastore.delete(key);
try {
datastore.get(myKey);
} catch (EntityNotFoundException e) {
}
} catch (Exception e) {
// e.printStackTrace();
}
}
@DELETE
public void deleteIt() {
// delete an entity from the datastore
// just print a message upon exception (don't throw)
DatastoreService datastore = DatastoreServiceFactory.getDatastoreService();
MemcacheService syncCache = MemcacheServiceFactory.getMemcacheService();
if (syncCache.get(keyname) != null) {
syncCache.delete(keyname);
}
Key entKey = KeyFactory.createKey("TaskData", keyname);
try {
Entity ent = datastore.get(entKey);
datastore.delete(entKey);
System.err.println("TaskData deleted in Datastore");
} catch (EntityNotFoundException e) {
System.err.println("TaskData not found in Datastore");
}
}
private void remove(String encoded, HttpServletResponse response) throws IOException {
BlobstoreService blobstore = BlobstoreServiceFactory.getBlobstoreService();
DatastoreService datastore = DS.get();
Key key = KeyFactory.stringToKey(encoded);
Transaction tr = datastore.beginTransaction();
try {
Entity blog = datastore.get(key);
datastore.delete(key);
response.setContentType("text/plain");
PrintWriter writer = response.getWriter();
writer.println("Deleted blog: " + blog.getProperty("Subject"));
tr.commit();
} catch (EntityNotFoundException ex) {
throw new IOException(ex);
} finally {
if (tr.isActive()) {
tr.rollback();
}
}
}
/**
* One specialty compared to the other stores is that the incoming entity is never null. The user
* of this persistence needs therefore to somehow determine if the entity is persistent or not,
* e.g. through the lack of a particular attribute. It also means that the return value of the
* function is slightly less meaningful, since the entity is manipulated in place. Exception:
* returning null will still delete the entity.
*/
@Override
public Entity mutate(String key, Function<? super Entity, ? extends Entity> mutator) {
Preconditions.checkNotNull(key);
Preconditions.checkNotNull(mutator);
Key dbKey = KeyFactory.createKey(kind, escape(key));
Exception lastException = null;
for (int i = 0; i < NUM_RETRIES; i++) {
Transaction t = service.beginTransaction();
boolean success = false;
Entity entity;
try {
entity = service.get(t, dbKey);
} catch (EntityNotFoundException e) {
entity = new Entity(kind, escape(key));
}
Entity data = mutator.apply(entity);
try {
if (data != null) {
service.put(t, data);
} else {
service.delete(t, dbKey);
}
t.commit();
success = true;
} catch (ConcurrentModificationException e) {
success = false;
lastException = e;
} catch (DatastoreFailureException e) {
success = false;
lastException = e;
} finally {
if (!success) {
t.rollback();
} else {
return data;
}
}
}
throw new StoreException("Could not store data for key " + key, lastException);
}
public static void delete(String path, Owner owner) {
DatastoreService ds = DatastoreServiceFactory.getDatastoreService();
Key k = PathHelper.getStorageKey("File", path, owner);
ds.delete(k);
}
/**
* Delete the entity from persistent store represented by the key
*
* @param key : key to delete the entity from the persistent store
*/
public static void deleteEntity(Key key) {
logger.log(Level.INFO, "Deleting entity");
datastore.delete(key);
}
public void doGet(HttpServletRequest req, HttpServletResponse resp) throws IOException {
Action ac = null;
try {
ac = Action.valueOf(req.getParameter("action"));
} catch (Exception e) {
resp.sendError(
400, "'action' parameter required, can be " + Arrays.toString(Action.values()));
return;
}
// okay, we now know what we want to do
switch (ac) {
case submit:
// 1st: validate inputs
String email = req.getParameter("email");
String url = req.getParameter("url");
String intervalStr = req.getParameter("interval");
if (!Utils.isValidEmailAddress(email)) {
resp.sendError(HttpServletResponse.SC_BAD_REQUEST, "invalid 'email' parameter");
return;
}
if (!Utils.isValidUrl(url)) {
resp.sendError(HttpServletResponse.SC_BAD_REQUEST, "invalid 'url' parameter");
return;
}
if (!Utils.isValidInterval(intervalStr, intervals)) {
resp.sendError(
HttpServletResponse.SC_BAD_REQUEST,
"invalid 'interval' parameter, can be " + intervals.toString());
return;
}
// 2nd: put our task in the data store, but not enable it yet
Entity job = new Entity("Job");
job.setProperty("url", url);
job.setProperty("intervalSeconds", Integer.parseInt(intervalStr));
job.setProperty("email", email);
job.setProperty("enabled", false);
String id = UUID.randomUUID().toString();
job.setProperty("id", id);
datastore.put(job);
log.info(
"New request: url="
+ url
+ ",email="
+ email
+ ",interval="
+ intervalStr
+ ",id="
+ id);
// 3rd: send email to admin asking to confirm
String confirmUrl = "http://" + Utils.HOSTNAME + "/pmc?action=enable&id=" + id;
Utils.sendMail(
email,
"Hello.\n\nThis is the \"Poor Man's cron service\" at "
+ Utils.HOSTNAME
+ ".\nI have been asked (probably by you) to send a request to the URL "
+ url
+ " every "
+ intervalStr
+ " seconds.\nIf you think that's okay, please visit the following URL: "
+ confirmUrl
+ "\n\nBest, PMC");
// 4th: display some message on response stream.
resp.getWriter()
.write(
"Okay, I have received your job. Please check your eMail for further instructions. ");
resp.getWriter().close();
break;
case enable:
String enableid = req.getParameter("id");
// 1st: validate inputs
if (!Utils.isValidId(enableid)) {
resp.sendError(
HttpServletResponse.SC_BAD_REQUEST, "invalid 'id' parameter, should be a UUID");
return;
}
// 2nd: look if we know a job with that id
List<Entity> jobs =
datastore
.prepare(
new Query("Job")
.setFilter(new FilterPredicate("id", FilterOperator.EQUAL, enableid)))
.asList(withLimit(1));
if (jobs.size() < 1) {
resp.sendError(HttpServletResponse.SC_BAD_REQUEST, "invalid 'id' parameter");
return;
}
// 3rd: set job to be enabled
Entity enableJob = jobs.get(0);
enableJob.setProperty("enabled", true);
datastore.put(enableJob);
log.info("Enabled: id=" + enableid);
// 4th: send confirmation mail
String deleteLink = "http://" + Utils.HOSTNAME + "/pmc?action=delete&id=" + enableid;
String viewLink = "http://" + Utils.HOSTNAME + "/pmc?action=view&id=" + enableid;
Utils.sendMail(
(String) enableJob.getProperty("email"),
"Hello again!\n\nThis is the \"Poor Man's cron service\" at "
+ Utils.HOSTNAME
+ ".\nI have enabled your job to send a request to the URL "
+ enableJob.getProperty("url")
+ " every "
+ enableJob.getProperty("intervalSeconds")
+ " seconds.\nIf you want to see how your job is doing, and what your URL has to say, visit this page: "
+ viewLink
+ "\n\nIf you want to cancel this job again, please click on the following link: "
+ deleteLink
+ "\n\nIt would be advisable to keep this message, as it would otherwise be hard to stop me from accessing your URL.\n\nBest, PMC");
// 5th: display some message on response stream.
resp.getWriter()
.write(
"Okay, I have enabled your job. Please check your eMail for further instructions. ");
resp.getWriter().close();
break;
case view:
// TODO: implement me, pleaaase
resp.getWriter().write("Not Implemented Yet.");
resp.getWriter().close();
break;
case delete:
String deleteid = req.getParameter("id");
// 1st: validate inputs
if (!Utils.isValidId(deleteid)) {
resp.sendError(
HttpServletResponse.SC_BAD_REQUEST, "invalid 'id' parameter, should be a UUID");
return;
}
// 2nd: look if we know a job with that id
List<Entity> jobsd =
datastore
.prepare(
new Query("Job")
.setFilter(new FilterPredicate("id", FilterOperator.EQUAL, deleteid)))
.asList(withLimit(1));
if (jobsd.size() < 1) {
resp.sendError(HttpServletResponse.SC_BAD_REQUEST, "invalid 'id' parameter");
return;
}
// 3rd: delete job
datastore.delete(jobsd.get(0).getKey());
log.info("Deleted: id=" + deleteid);
// 4th: display some message on response stream.
resp.getWriter().write("Okay, I have deleted your job. Bye! ");
resp.getWriter().close();
break;
}
}
