Java Code Examples for com.google.appengine.api.datastore.DatastoreServiceFactory#getDatastoreService()

@Before
public void setUp() throws Exception {
  MockitoAnnotations.initMocks(this);
  helper.setUp();
  datastore = DatastoreServiceFactory.getDatastoreService();

  // Add test data.
  ImmutableList.Builder<Entity> people = ImmutableList.builder();
  for (String name : TEST_NAMES) {
    people.add(createPerson(name));
  }
  datastore.put(people.build());

  // Set up a fake HTTP response.
  responseWriter = new StringWriter();
  when(mockResponse.getWriter()).thenReturn(new PrintWriter(responseWriter));

  servletUnderTest = new ListPeopleServlet();
}
 

@Test
public void kindExample_writesEntity() throws Exception {
  // [START kind_example]
  Entity employee = new Entity("Employee", "asalieri");
  employee.setProperty("firstName", "Antonio");
  employee.setProperty("lastName", "Salieri");
  employee.setProperty("hireDate", new Date());
  employee.setProperty("attendedHrTraining", true);

  DatastoreService datastore = DatastoreServiceFactory.getDatastoreService();
  datastore.put(employee);
  // [END kind_example]

  Entity got = datastore.get(employee.getKey());
  assertWithMessage("got.firstName")
      .that((String) got.getProperty("firstName"))
      .isEqualTo("Antonio");
  assertWithMessage("got.lastName")
      .that((String) got.getProperty("lastName"))
      .isEqualTo("Salieri");
  assertWithMessage("got.hireDate").that((Date) got.getProperty("hireDate")).isNotNull();
  assertWithMessage("got.attendedHrTraining")
      .that((boolean) got.getProperty("attendedHrTraining"))
      .isTrue();
}
 

@Override
public boolean load(String userId, Credential credential) {
  DatastoreService datastore = DatastoreServiceFactory.getDatastoreService();
  Key key = KeyFactory.createKey(KIND, userId);
  try {
    Entity entity = datastore.get(key);
    credential.setAccessToken((String) entity.getProperty("accessToken"));
    credential.setRefreshToken((String) entity.getProperty("refreshToken"));
    credential.setExpirationTimeMilliseconds((Long) entity.getProperty("expirationTimeMillis"));
    return true;
  } catch (EntityNotFoundException exception) {
    return false;
  }
}
 

@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp)
    throws ServletException, IOException {
  resp.setContentType("text/plain");
  DatastoreService datastore = DatastoreServiceFactory.getDatastoreService();

  Key isPopulatedKey = KeyFactory.createKey(IS_POPULATED_ENTITY, IS_POPULATED_KEY_NAME);
  boolean isAlreadyPopulated;
  try {
    datastore.get(isPopulatedKey);
    isAlreadyPopulated = true;
  } catch (EntityNotFoundException expected) {
    isAlreadyPopulated = false;
  }
  if (isAlreadyPopulated) {
    resp.getWriter().println("ok");
    return;
  }

  ImmutableList.Builder<Entity> people = ImmutableList.builder();
  for (String name : US_PRESIDENTS) {
    Entity person = new Entity(PERSON_ENTITY);
    person.setProperty(NAME_PROPERTY, name);
    people.add(person);
  }
  datastore.put(people.build());
  datastore.put(new Entity(isPopulatedKey));
  resp.getWriter().println("ok");
}
 

/**
 * Migrates to the new format using {@link DataStore} of {@link StoredCredential}.
 *
 * @param credentialDataStore credential data store
 * @since 1.16
 */
public final void migrateTo(DataStore<StoredCredential> credentialDataStore) throws IOException {
  DatastoreService service = DatastoreServiceFactory.getDatastoreService();
  PreparedQuery queryResult = service.prepare(new Query(KIND));
  for (Entity entity : queryResult.asIterable()) {
    StoredCredential storedCredential = new StoredCredential().setAccessToken(
        (String) entity.getProperty("accessToken"))
        .setRefreshToken((String) entity.getProperty("refreshToken"))
        .setExpirationTimeMilliseconds((Long) entity.getProperty("expirationTimeMillis"));
    credentialDataStore.set(entity.getKey().getName(), storedCredential);
  }
}
 

public void purgeTestRunRecords() {
    DatastoreService datastoreService = DatastoreServiceFactory. getDatastoreService();
    FilterPredicate testRunFilter = new FilterPredicate(TEST_RUN_ID, FilterOperator.EQUAL, testRunId);
    Query query = new Query(entityName).setFilter(testRunFilter).setKeysOnly();
    for (Entity readRec : datastoreService.prepare(query).asIterable()) {
        datastoreService.delete(readRec.getKey());
    }
}
 

public Entity getMarker(String marker) {
    DatastoreService service = DatastoreServiceFactory.getDatastoreService();
    FilterPredicate testRunFilter = new FilterPredicate(TEST_RUN_ID, FilterOperator.EQUAL, testRunId);
    FilterPredicate markerFilter = new FilterPredicate(MARKER, FilterOperator.EQUAL, marker);
    CompositeFilter filter = CompositeFilterOperator.and(testRunFilter, markerFilter);
    Query query = new Query(entityName).setFilter(filter);
    return service.prepare(query).asSingleEntity();
}
 

@Test
public void datastoreServiceFactory_returnsDatastoreService() throws Exception {
  // [START working_with_entities]
  DatastoreService datastore = DatastoreServiceFactory.getDatastoreService();
  // [END working_with_entities]
  assertWithMessage("datastore").that(datastore).isNotNull();
}
 

private void doCleanup() {
  log.log(Level.INFO, "Starting a job to clean up processed notification records");

  DatastoreService datastore = DatastoreServiceFactory.getDatastoreService();

  Calendar cutoffTime = Calendar.getInstance(TimeZone.getTimeZone("UTC"));
  cutoffTime.add(Calendar.HOUR, -HOURS_TO_KEEP_RECORDS_OF_PROCESSED_NOTIFICATIONS);

  Query query = new Query(Worker.PROCESSED_NOTIFICATION_TASKS_ENTITY_KIND)
    .setFilter(new FilterPredicate("processedAt", FilterOperator.LESS_THAN, cutoffTime.getTime()))
    .setKeysOnly();

  PreparedQuery preparedQuery = datastore.prepare(query);

  // Delete in batches
  List<Entity> entitiesToBeDeleted = null;
  do {
    entitiesToBeDeleted = preparedQuery.asList(FetchOptions.Builder.withLimit(5));

    List<Key> keys = new ArrayList<Key>();

    for (Entity entity : entitiesToBeDeleted) {
      keys.add(entity.getKey());
    }

    datastore.delete(keys);
  } while (entitiesToBeDeleted.size() > 0);

  log.log(Level.INFO, "Finished a job to clean up processed notification records");
}
 

@Override
public void init(FilterConfig config) throws ServletException {
  // initialize local copy of datastore session variables

  datastore = DatastoreServiceFactory.getDatastoreService();
  // Delete all sessions unmodified for over two days
  DateTime dt = DateTime.now(DateTimeZone.UTC);
  Query query = new Query(SESSION_KIND).setFilter(new FilterPredicate(
          "lastModified", FilterOperator.LESS_THAN_OR_EQUAL, dt.minusDays(2).toString(DTF)));
  Iterator<Entity> results = datastore.prepare(query).asIterator();
  while (results.hasNext()) {
    Entity stateEntity = results.next();
    datastore.delete(stateEntity.getKey());
  }
}
 

@Before
public void init() {
  action.gcsService = gcsService;
  action.dryRun = false;
  action.datastoreService = DatastoreServiceFactory.getDatastoreService();
  action.fromTime = now.minusMillis(1);
  action.retrier = new Retrier(new FakeSleeper(new FakeClock()), 1);
  action.diffLister = new GcsDiffFileLister();
  action.diffLister.gcsService = gcsService;
  action.diffLister.gcsBucket = GCS_BUCKET;
  action.diffLister.executor = newDirectExecutorService();
}
 

public DatastoreDao() {
  datastore = DatastoreServiceFactory.getDatastoreService(); // Authorized Datastore service
}
 

private Entity getTestDataEntity() throws EntityNotFoundException {
    DatastoreService datastore = DatastoreServiceFactory.getDatastoreService();
    return datastore.get(KeyFactory.createKey(ENTITY_KIND, ENTITY_NAME));
}
 

public DatastoreDao() {
  datastore = DatastoreServiceFactory.getDatastoreService(); // Authorized Datastore service
}
 

@Before
public void setUp() {
	helper.setUp();
	datastore = DatastoreServiceFactory.getDatastoreService();
	stocksRepository = new StocksRepositoryImpl(pseClient, gaClient);
}
 

@Before
public void setUp() {
  helper.setUp();
  datastore = DatastoreServiceFactory.getDatastoreService();
}
 

public DatastoreDao() {
  datastore = DatastoreServiceFactory.getDatastoreService(); // Authorized Datastore service
}
 

@Before
public void setUp() {
  helper.setUp();
  datastore = DatastoreServiceFactory.getDatastoreService();
}
 

/**
 * Default constructor.
 */
public BackendConfigManager() {
  this(DatastoreServiceFactory.getDatastoreService(),
      MemcacheServiceFactory.getMemcacheService());
}
 

public CloudEndpointsConfigManager() {
  this(DatastoreServiceFactory.getDatastoreService(),
      MemcacheServiceFactory.getMemcacheService());
}