@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(); }
@Test public void updateFieldInEntity() throws EntityNotFoundException { Entity person = new Entity("Person"); person.setProperty("firstName", "Ivan"); person.setProperty("age", 22l); Key key = datastore.put(person); // Start transaction Transaction transaction = datastore.beginTransaction(); try { Entity result = datastore.get(key); result.setProperty("age", 30l); datastore.put(result); transaction.commit(); } finally { if (transaction.isActive()) { transaction.rollback(); } } Entity result = datastore.get(key); assertThat("Ivan", is(equalTo(result.getProperty("firstName")))); assertThat(30l, is(equalTo(result.getProperty("age")))); }
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(); } } }
@PUT @Consumes(MediaType.APPLICATION_XML) public Response putTaskData(String value) { Response res = null; // add your code here // first check if the Entity exists in the datastore DatastoreService datastore = DatastoreServiceFactory.getDatastoreService(); MemcacheService syncCache = MemcacheServiceFactory.getMemcacheService(); syncCache.setErrorHandler(ErrorHandlers.getConsistentLogAndContinue(Level.INFO)); Key entKey = KeyFactory.createKey("TaskData", keyname); Date date = new Date(); try { // if it is, signal that we updated the entity Entity ts = datastore.get(entKey); ts.setProperty("value", value); ts.setProperty("date", date); datastore.put(ts); res = Response.noContent().build(); } catch (EntityNotFoundException e) { // if it is not, create it and // signal that we created the entity in the datastore Entity taskdata = new Entity("TaskData", keyname); taskdata.setProperty("value", value); taskdata.setProperty("date", date); datastore.put(taskdata); res = Response.created(uriInfo.getAbsolutePath()).build(); } TaskData td = new TaskData(keyname, value, date); syncCache.put(keyname, td); return res; }
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; }
/** * 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; }
@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("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 gets the entity having primary key id. It uses HTTP GET method. * * @param id the primary key of the java bean. * @return The entity with primary key id. * @throws UnauthorizedException */ @ApiMethod( name = "findById", scopes = {Config.EMAIL_SCOPE}, clientIds = {Config.CHROME_CLIENT_ID, Config.WEB_CLIENT_ID, Config.API_EXPLORER_CLIENT_ID}) public ServiceResponse findById(@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(); ServiceResponse res = new ServiceResponse(); try { Entity entity = dsService.get(key); res.set_id(entity.getKey().getId()); res.set_createdAt((Date) entity.getProperty(_createdAt)); res.set_createdBy((String) entity.getProperty(_createdBy)); res.set_upatedAt((Date) entity.getProperty(_updatedAt)); res.set_updatedBy((String) entity.getProperty(_updatedBy)); res.set_status((String) entity.getProperty(_status)); Text dataText = (Text) entity.getProperty(data); res.setData(dataText.getValue()); } catch (com.google.appengine.api.datastore.EntityNotFoundException e) { throw new EntityNotFoundException("Object does not exist."); } return res; }
// Factory methods: public static MemoStorable load(Entity ent) { // long start = System.currentTimeMillis(); byte[] result; Key key = ent.getKey(); int size = 0; long spread = 0; // int count=0; try { Blob blob = (Blob) ent.getProperty("payload"); size = (int) ((Long) ent.getProperty("size") % Integer.MAX_VALUE); spread = ((Long) ent.getProperty("spread")); byte[] data = blob.getBytes(); result = Arrays.copyOf(data, data.length); // count++; while (ent.hasProperty("next")) { // Expensive, should not be used too much! Key next = (Key) ent.getProperty("next"); ent = datastore.get(next); blob = (Blob) ent.getProperty("payload"); data = blob.getBytes(); result = concat(data, result); // Add to front of result, due to // count++; // the storing order } } catch (EntityNotFoundException e) { e.printStackTrace(); return null; } MemoStorable res = _unserialize(result, size); res.spread = spread; res.storedSize = result.length; if (res != null) res.myKey = key; return res; }
private Entity getEntity(BlobKey blobKey) throws FileNotFoundException { DatastoreService datastore = getDatastoreService(); try { return datastore.get(getMetadataKeyForBlobKey(blobKey)); } catch (EntityNotFoundException ex) { throw new FileNotFoundException(); } }
/** * Search and return the entity from datastore. * * @param key : key to find the entity * @return entity */ public static Entity findEntity(Key key) { logger.log(Level.INFO, "Search the entity"); try { return datastore.get(key); } catch (EntityNotFoundException e) { return null; } }
// [START entity_group_1] private static long getEntityGroupVersion(DatastoreService ds, Transaction tx, Key entityKey) { try { return Entities.getVersionProperty(ds.get(tx, Entities.createEntityGroupKey(entityKey))); } catch (EntityNotFoundException e) { // No entity group information, return a value strictly smaller than any // possible version return 0; } }
@Override public Entity get(String key) { Preconditions.checkNotNull(key); try { return service.get(KeyFactory.createKey(kind, escape(key))); } catch (EntityNotFoundException e) { return null; } }
public Config load() { Config cfg = new Config(); try { cfg.entity = service.get(key()); } catch (EntityNotFoundException e) { cfg.entity = new Entity(key()); cfg.reset(); } return cfg; }
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(); } }
public static MemoStorable load(Key key) { MemoStorable res = deletedCache.getIfPresent(key); if (res != null) return res; try { Entity ent = datastore.get(key); return load(ent); } catch (EntityNotFoundException e) { return null; } }
public static Entity getEntity(Key key) { try { // First retrieve the entity Entity ent = ds.get(key); return ent; } catch (EntityNotFoundException e) { return null; } }
@RequestMapping(value = "/mobileform/{id}", method = RequestMethod.GET) public Entity getMobileFormById(@PathVariable String id) throws EntityNotFoundException { UserService userService = UserServiceFactory.getUserService(); User user = userService.getCurrentUser(); if (user != null) { DatastoreService datastore = DatastoreServiceFactory.getDatastoreService(); Key key = KeyFactory.createKey("MobileForm", id); Entity result = datastore.get(key); return result; } else return null; }
public static File getByPathAndUser(String path, Owner owner) throws EntityNotFoundException { DatastoreService ds = DatastoreServiceFactory.getDatastoreService(); Entity e = ds.get(PathHelper.getStorageKey("File", path, owner)); if (e == null) return null; File f = new File(); ReflectionHelper.setPropertiesFromEntity(File.class, f, e); return f; }
@ApiMethod(name = "form.get") public Form getForm(@Named("groupId") Long groupId, @Named("formId") Long formId) throws EntityNotFoundException { // Get the key Key rootKey = KeyFactory.createKey("Root", 1); Key groupKey = KeyFactory.createKey(rootKey, "Group", groupId); Key key = KeyFactory.createKey(groupKey, "Form", formId); Entity entity = dataStore.get(key); return Form.fromEntity(dataStore, entity); }
@ApiMethod(name = "form.list") public List<Form> getForms(@Named("groupId") Long groupId) throws EntityNotFoundException { // Get the key Key rootKey = KeyFactory.createKey("Root", 1); Key groupKey = KeyFactory.createKey(rootKey, "Group", groupId); // Get or create the group Entity group; group = dataStore.get(groupKey); //noinspection unchecked List<Key> keys = (List<Key>) group.getProperty("forms"); keys = firstNonNull(keys, Collections.<Key>emptyList()); List<Form> forms = new ArrayList<>(); for (Key key : keys) { Form f = Form.fromEntity(dataStore, dataStore.get(key)); forms.add(f); } return forms; }
public Key store(Key orig, String type, long storeDate) { // long start = System.currentTimeMillis(); final int MAXSIZE = 1000000; Entity ent; Key next = null; this.storeTime = storeDate; this.nanoTime = System.nanoTime(); byte[] data = this.serialize(); Integer length = data.length; int pointer = 0; // int counter = 0; while (length - pointer >= MAXSIZE) { // Expensive, should not be used too much! ent = new Entity(type + "_fragment"); ent.setUnindexedProperty( "payload", new Blob(Arrays.copyOfRange(data, pointer, pointer + MAXSIZE))); if (next != null) ent.setUnindexedProperty("next", next); datastore.put(ent); // counter++; next = ent.getKey(); pointer += MAXSIZE; } if (orig != null) { System.err.println( "Warning, storing storable twice! Strange, should not happen with our immutable structures."); ent = new Entity(orig); } else { ent = new Entity(type); } ent.setUnindexedProperty("payload", new Blob(Arrays.copyOfRange(data, pointer, length))); if (next != null) ent.setUnindexedProperty("next", next); ent.setProperty("timestamp", this.storeTime); ent.setProperty("size", length); ent.setProperty("spread", this.spread); datastore.put(ent); // counter++; myKey = ent.getKey(); // Try to force index writing try { datastore.get(myKey); } catch (EntityNotFoundException e) { } this.storedSize = length; // System.out.println("Just stored shard of "+length+ " bytes in "+counter+" fragments in // "+(System.currentTimeMillis()-start)+" ms"); return myKey; }
@ApiMethod(name = "group.list") public List<Group> getGroups() throws EntityNotFoundException, IOException { Key rootKey = KeyFactory.createKey("Root", 1); // Get or create the root Entity root; try { root = dataStore.get(rootKey); } catch (EntityNotFoundException e) { // root = new Startup(dataStore).run(false); return Collections.emptyList(); } //noinspection unchecked List<Key> keys = (List<Key>) root.getProperty("groups"); keys = firstNonNull(keys, Collections.<Key>emptyList()); List<Group> groups = new ArrayList<>(); for (Key key : keys) { Group g = Group.fromEntity(dataStore, dataStore.get(key)); groups.add(g); } return groups; }
public AudioClip getAudioClipById(String id) throws BadRequestException { AudioClip audioClip; try { Key audio_key = KeyFactory.stringToKey(id); Entity result = datastore.get(audio_key); audioClip = new AudioClip( id, (String) result.getProperty(TuneInConstants.AUDIO_CLIP_TITLE), (String) result.getProperty(TuneInConstants.AUDIO_CLIP_OWNER_ID), (String) result.getProperty(TuneInConstants.AUDIO_CLIP_AUDIO_ID), (String) result.getProperty(TuneInConstants.AUDIO_CLIP_IMAGE_ID), (Date) result.getProperty(TuneInConstants.AUDIO_CLIP_DATE)); return audioClip; } catch (Exception e) { throw new BadRequestException(); } }
public List<Statistic> getStatisitc(String name, String momin, Date start, int nbrWeek) { TimeZone.setDefault(TimeZone.getTimeZone("GMT")); List<Key> keys = new ArrayList<Key>(); String st = null; Calendar cal = Calendar.getInstance(); cal.setFirstDayOfWeek(Calendar.SUNDAY); cal.setTime(start); for (int i = 0; i < nbrWeek; i++) { st = momin + "$" + name + "$" + cal.get(Calendar.YEAR) + "$" + cal.get(Calendar.WEEK_OF_YEAR); keys.add(KeyFactory.createKey(Statistic.class.getSimpleName(), st)); cal.add(Calendar.DAY_OF_MONTH, 7); } DatastoreService ds = DatastoreServiceFactory.getDatastoreService(); Map<Key, Entity> map = ds.get(keys); return fromEntity(map.values()); }
/** * Gets a persistent record with the devices to be notified using a multicast message. * * @param encodedKey encoded key for the persistent record. */ public static List<String> getMulticast(String encodedKey) { Key key = KeyFactory.stringToKey(encodedKey); Entity entity; Transaction txn = datastore.beginTransaction(); try { entity = datastore.get(key); @SuppressWarnings("unchecked") List<String> devices = (List<String>) entity.getProperty(MULTICAST_REG_IDS_PROPERTY); txn.commit(); return devices; } catch (EntityNotFoundException e) { logger.severe("No entity for key " + key); return Collections.emptyList(); } finally { if (txn.isActive()) { txn.rollback(); } } }
@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"); } }
// for the application @GET @Produces({MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON}) public TaskData getTaskData() { // same code as above method DatastoreService datastore = DatastoreServiceFactory.getDatastoreService(); MemcacheService syncCache = MemcacheServiceFactory.getMemcacheService(); if (syncCache.get(keyname) != null) { TaskData ts = (TaskData) syncCache.get(keyname); return ts; } Key entKey = KeyFactory.createKey("TaskData", keyname); try { Entity ent = datastore.get(entKey); TaskData ts = new TaskData(keyname, (String) ent.getProperty("value"), (Date) ent.getProperty("date")); return ts; } catch (EntityNotFoundException e) { throw new RuntimeException("Get: TaskData with " + keyname + " not found"); } }
public static Entity get( HttpServletRequest request, HttpServletResponse response, String cookie_name) { String key = null; Cookie[] cookies = request.getCookies(); for (int i = 0; cookies != null && i < cookies.length; ++i) if (cookies[i].getName().equals(cookie_name)) { key = cookies[i].getValue(); } DatastoreService ds = DatastoreServiceFactory.getDatastoreService(); Entity entity = null; if (key != null) { try { entity = ds.get(KeyFactory.stringToKey(key)); } catch (EntityNotFoundException e) { entity = null; } } return entity; }