Refine search
@Override public void setAuthority(String username, String authority) { Key userKey = KeyFactory.createKey(AUTH_FLOWS_USER_DB_KIND, username); Entity entity; try { entity = datastore.get(userKey); log.debug("got entity of " + username + ": " + entity); } catch (EntityNotFoundException e) { log.error("entity of " + username + " not found"); throw new NoSuchElementException(e.getMessage()); } entity.setProperty(AUTHORITIES_PROP_NAME, authority ); datastore.put( entity ); }
public static Key getPrimaryKeyAsKey(Object pk, ExecutionContext ec, AbstractClassMetaData cmd) { String kind = EntityUtils.determineKind(cmd, ec); if (pk instanceof Key) { return (Key) pk; } else if (long.class.isInstance(pk) || pk instanceof Long) { return KeyFactory.createKey(kind, (Long) pk); } try { return KeyFactory.stringToKey((String) pk); } catch (IllegalArgumentException iae) { return KeyFactory.createKey(kind, (String) pk); } }
@Override public String keyToString(Key key) { return KeyFactory.keyToString(key); }
@Test public void batchGetReturnsOnlyExistingKeysInMap() throws Exception { Key existingKey = KeyFactory.createKey("batch", "existing"); Key nonExistingKey = KeyFactory.createKey("batch", "nonExisting"); service.put(new Entity(existingKey)); Map<Key, Entity> map = service.get(Arrays.asList(existingKey, nonExistingKey)); assertEquals(1, map.size()); assertTrue(map.containsKey(existingKey)); }
Key key = KeyFactory.createKey(KIND, keyString.toString()); Transaction tx = datastore.beginTransaction(); entity = datastore.get(tx, key); number = ((Number)entity.getProperty(PROPERTY)).intValue(); number = number + 1; entity = new Entity(key); number = 1; entity.setProperty(PROPERTY, number); datastore.put(tx, entity); tx.commit();
public static AuthToken getAuthToken(String token) { //todo use MemCache Entity tokenEntity; try { tokenEntity = datastore.get(KeyFactory.createKey(authTokenKind, token)); } catch (EntityNotFoundException e) { return null; } return new AuthToken( token, (Long) tokenEntity.getProperty("account"), (Long) tokenEntity.getProperty("time") ); }
public static void deletePrivateEntity(String entityKind, long entityId) throws LeanException { LeanAccount account = findCurrentAccount(); if (entityId <= 0 || entityKind == null) throw new LeanException(LeanException.Error.EntityNotFound, " Entity 'kind' and 'id' must NOT be null."); Entity entity; try { entity = datastore.get(KeyFactory.createKey(entityKind, entityId)); } catch (EntityNotFoundException e) { throw new LeanException(LeanException.Error.EntityNotFound); } if (account.id != (Long) entity.getProperty("_account")) throw new LeanException(LeanException.Error.NotAuthorized, " Account not authorized to access entity '" + entityKind + "'with ID '" + entityId + "'"); datastore.delete(entity.getKey()); }
protected int[] internalShift(ObjectProvider op, boolean batched, int oldIndex, int amount) throws MappedDatastoreException { if (orderMapping == null) { return null; } DatastoreServiceConfig config = storeMgr.getDefaultDatastoreServiceConfigForReads(); DatastoreService service = DatastoreServiceFactoryInternal.getDatastoreService(config); AbstractClassMetaData acmd = elementCmd; String kind = storeMgr.getIdentifierFactory().newDatastoreContainerIdentifier(acmd).getIdentifierName(); Query q = new Query(kind); ExecutionContext ec = op.getExecutionContext(); Object id = ec.getApiAdapter().getTargetKeyForSingleFieldIdentity(op.getInternalObjectId()); Key key = id instanceof Key ? (Key) id : KeyFactory.stringToKey((String) id); q.setAncestor(key); // create an entity just to capture the name of the index property Entity entity = new Entity(kind); orderMapping.setObject(ec, entity, new int[] {1}, oldIndex); String indexProp = entity.getProperties().keySet().iterator().next(); q.addFilter(indexProp, Query.FilterOperator.GREATER_THAN_OR_EQUAL, oldIndex); for (Entity shiftMe : service.prepare(service.getCurrentTransaction(null), q).asIterable()) { Long pos = (Long) shiftMe.getProperty(indexProp); shiftMe.setProperty(indexProp, pos + amount); EntityUtils.putEntityIntoDatastore(ec, shiftMe); } return null; }
String keyString = KeyFactory.createKeyString(pKey, kind, 1); assertTrue(Base64.isBase64(keyString.getBytes())); Entity entity = new Entity(KeyFactory.stringToKey(keyString)); entity.setProperty("role", "keystring+id"); service.put(entity); assertEquals(1, entity.getKey().getId()); assertEquals(kind, entity.getKey().getKind()); keyString = KeyFactory.createKeyString(pKey, kind, "2"); assertTrue(Base64.isBase64(keyString.getBytes())); entity = new Entity(KeyFactory.stringToKey(keyString)); entity.setProperty("role", "keystring+name"); service.put(entity); assertEquals("2", entity.getKey().getName()); assertEquals(pKey, entity.getParent()); keyString = KeyFactory.createKeyString(kind, 3); assertTrue(Base64.isBase64(keyString.getBytes())); entity = new Entity(KeyFactory.stringToKey(keyString)); entity.setProperty("role", "keystring+id"); service.put(entity); assertEquals(3, entity.getKey().getId()); keyString = KeyFactory.createKeyString(kind, "4"); assertTrue(Base64.isBase64(keyString.getBytes())); entity = new Entity(KeyFactory.stringToKey(keyString)); entity.setProperty("role", "keystring+name"); service.put(entity);
@Test public void testFilterByEntityKey() { Entity parentEntity = createTestEntityWithUniqueMethodNameKey(TEST_ENTITY_KIND, "testFilterByEntityKey"); Key parentKey = parentEntity.getKey(); Key fooKey = KeyFactory.createKey(parentKey, "foo", 1); Entity fooEntity = new Entity(fooKey); service.put(fooEntity); Query query = new Query("foo") .setAncestor(parentKey) .setFilter(new Query.FilterPredicate(Entity.KEY_RESERVED_PROPERTY, EQUAL, fooKey)); PreparedQuery preparedQuery = service.prepare(query); List<Entity> results = preparedQuery.asList(FetchOptions.Builder.withDefaults()); assertEquals(1, results.size()); assertEquals(fooEntity, results.get(0)); }
if (ownerEntity.hasProperty(propName)) { Object value = ownerEntity.getProperty(propName); if (value == null) { return new int[0]; Object keyOrString = apiAdapter.getTargetKeyForSingleFieldIdentity(apiAdapter.getIdForObject(ele)); Key key = keyOrString instanceof Key ? (Key) keyOrString : KeyFactory.stringToKey((String) keyOrString); if (key == null) { throw new NucleusUserException("Collection element does not have a primary key."); int[] indices = new int[keys.size()]; int index = 0; for (Entity e : service.prepare(service.getCurrentTransaction(null), q).asIterable()) { if (keySet.contains(e.getKey())) { Long indexVal = (Long) orderMapping.getObject(ec, e, new int[1]); if (indexVal == null) {
q.setFilter(comp); PreparedQuery pq = datastore.prepare(q); List<Entity> results = pq.asList(FetchOptions.Builder.withLimit(1)); if (results.size() != 1 || !results.get(0).getProperty("name").toString().contains(backupName)) { System.err.println("BuiltinDatatoreToBigqueryIngesterTask: can't find backupName: " + backupName); Object completion = result.getProperty("complete_time"); Object gs_handle_obj = result.getProperty("gs_handle"); if (gs_handle_obj == null) { return null; keyResult = KeyFactory.keyToString(result.getKey());
protected Entity createTestEntity(String kind, long id) { Key key = KeyFactory.createKey(kind, id); Entity entity = new Entity(key); entity.setProperty("text", "Some text."); return entity; }
@Test public void queryingByKindOnlyReturnsEntitiesOfRequestedKind() throws Exception { Key parentKey = createQueryBasicsTestParent("queryingByKindOnlyReturnsEntitiesOfRequestedKind"); Entity person = new Entity(KeyFactory.createKey(parentKey, "Person", 1)); service.put(person); Entity address = new Entity(KeyFactory.createKey(parentKey, "Address", 1)); service.put(address); assertSingleResult(person, new Query("Person").setAncestor(parentKey)); }
if (value != null) { try { key = KeyFactory.stringToKey(value); } catch (IllegalArgumentException iae) { throw new NucleusFatalUserException( if (datastoreEntity.getParent() != null) { key = new Entity(datastoreEntity.getKey().getKind(), value, datastoreEntity.getParent()).getKey(); } else { key = new Entity(datastoreEntity.getKey().getKind(), value).getKey();
@Override public Key createKey(String kind, long id) { return KeyFactory.createKey(kind, id); }
private static Map<String, Object> load() { DatastoreService datastore = DatastoreServiceFactory.getDatastoreService(); Key key = KeyFactory.createKey("_settings", 1); Entity leanEntity; try { leanEntity = datastore.get(key); settings = leanEntity.getProperties(); } catch (EntityNotFoundException e) { settings = new HashMap<String, Object>(); // By default enable all logins on Development server if (ServerUtils.isDevServer()) { settings.put("fbLoginEnable", true); settings.put("fbAppId", "mockFacebookAppId"); settings.put("fbAppSecret", "mockFacebookAppSecret"); settings.put("openIdLoginEnable", true); saveSettings(settings); } } return settings; }
@Test public void testQueryOnSomePropertyWithKeyInDifferentNamespace() { NamespaceManager.set("one"); Key keyInNamespaceOne = KeyFactory.createKey("kind", 1); NamespaceManager.set("two"); Query query = new Query("kind").setFilter(new Query.FilterPredicate("someProperty", EQUAL, keyInNamespaceOne)); PreparedQuery preparedQuery = service.prepare(query); preparedQuery.asSingleEntity(); // should not throw IllegalArgumentException as in previous test preparedQuery.asIterator().hasNext(); // should not throw IllegalArgumentException as in previous test preparedQuery.asList(withDefaults()).size(); // should not throw IllegalArgumentException as in previous test } }