@Override public List<Integer> years() { List<Integer> years = new ArrayList<Integer>(); Query q = new Query(sitemapEntity.getKind()); q.addSort(sitemapEntity.getCreatedDateProperty(), SortDirection.ASCENDING); List<Entity> e = ds.prepare(q).asList(FetchOptions.Builder.withLimit(1)); int start; if (e.size() == 1) { start = DateUtils.getYear((Date) e.get(0).getProperty(sitemapEntity.getCreatedDateProperty())); } else { return years; } q = new Query(sitemapEntity.getKind()); q.addSort(sitemapEntity.getCreatedDateProperty(), SortDirection.DESCENDING); e = ds.prepare(q).asList(FetchOptions.Builder.withLimit(1)); int end = DateUtils.getYear((Date) e.get(0).getProperty(sitemapEntity.getCreatedDateProperty())); for (int i = start; i <= end; i++) { years.add(i); } return years; }
private void doRecordAction(JsonValues values, PrintWriter writer) { DatastoreService datastore = DatastoreServiceFactory.getDatastoreService(); Gson gson = new Gson(); // First try to see if we've seen this deck before Filter keyFilter = new FilterPredicate( Entity.KEY_RESERVED_PROPERTY, FilterOperator.EQUAL, KeyFactory.createKey("Record", gson.toJson(values.deck))); Query q = new Query("Record").setFilter(keyFilter); PreparedQuery pq = datastore.prepare(q); int count = pq.countEntities(FetchOptions.Builder.withDefaults()); if (count == 0) { // First time we've seen this deck datastore.put(jsonValuesToEntity(values)); } else if (count == 1) { // We've seen this deck before Entity record = pq.asIterable().iterator().next(); String ratingKey = getRatingKey(values); long ratingValue = 1; if (record.hasProperty(ratingKey)) { ratingValue = (long) record.getProperty(ratingKey) + 1; } record.setProperty(ratingKey, ratingValue); datastore.put(record); } else { throw new RuntimeException("deck present in store multiple times!"); } writer.println("SUCCESS!"); }
public static Entity getWeekMeasureForDataChannel( DatastoreService datastore, String dataChannel) { Query query = new Query(Entities.EntityKind.WeekMeasures.getKindName()); query.addFilter("DChoofdmeting", FilterOperator.EQUAL, dataChannel); PreparedQuery prepared = datastore.prepare(query); return prepared.asSingleEntity(); }
@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("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; }
@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; }
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(); } } }
@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 List<AudioClip> getAudioClipsByUser(String userId) throws BadRequestException { List<AudioClip> audioClipList = new ArrayList<AudioClip>(); // verify userId validateUserExistance(userId); // throws bad request exception of user doesn't exist Filter userFilter = new FilterPredicate(TuneInConstants.AUDIO_CLIP_OWNER_ID, FilterOperator.EQUAL, userId); Query q = new Query(TuneInConstants.AUDIO_CLIP_TYPE) .setFilter(userFilter) .addSort(TuneInConstants.AUDIO_CLIP_DATE, SortDirection.ASCENDING); PreparedQuery pq = datastore.prepare(q); AudioClip audioClip; for (Entity result : pq.asIterable()) { audioClip = new AudioClip( KeyFactory.keyToString(result.getKey()), (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)); audioClipList.add(audioClip); } return audioClipList; }
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"); }
@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"); }
@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>"); }
@Override public void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { String userName = req.getParameter("name"); String comment = req.getParameter("comment"); DatastoreService datastore = DatastoreServiceFactory.getDatastoreService(); if (userName != null && comment != null) { Entity commentEntity = new Entity("Comment", guestbookKey); commentEntity.setProperty("name", userName); commentEntity.setProperty("comment", comment); datastore.put(commentEntity); } Query query = new Query("Comment", guestbookKey); List<Entity> comments = datastore.prepare(query).asList(FetchOptions.Builder.withDefaults()); // System.out.println(); req.setAttribute("comments", comments); String url = "/guestBook.jsp"; ServletContext sc = getServletContext(); RequestDispatcher rd = sc.getRequestDispatcher(url); rd.forward(req, resp); }
/** * Finds the {@code TestReport} with the given build type id ordered by build id in the descendant * order. * * @param buildTypeId the build type id. * @param limit the optional fetch limit, by default {@link * com.google.appengine.tck.site.endpoints.TestReport#DEFAULT_FETCH_LIMIT}. * @param reports the reports entry point * @return the matching test reports list or an empty one if none. */ @SuppressWarnings("unchecked") public static List<TestReport> findByBuildTypeIdOrderByBuildIdDesc( String buildTypeId, Optional<Integer> limit, Reports reports) { final MemcacheService memcacheService = reports.getMemcacheService(); List<TestReport> results = (List<TestReport>) memcacheService.get(buildTypeId); if (results == null) { final Filter buildTypeFilter = new Query.FilterPredicate("buildTypeId", FilterOperator.EQUAL, buildTypeId); final Query query = new Query(TEST_REPORT).setFilter(buildTypeFilter).addSort("buildId", DESCENDING); final DatastoreService datastoreService = reports.getDatastoreService(); final PreparedQuery preparedQuery = datastoreService.prepare(query); final List<Entity> entities = preparedQuery.asList(FetchOptions.Builder.withLimit(limit.or(DEFAULT_FETCH_LIMIT))); results = new ArrayList<>(); for (Entity oneEntity : entities) { final TestReport report = from(oneEntity); results.add(report); } memcacheService.put(buildTypeId, results); } return results; }
public List<Entry<String, Entity>> scan( String start, String end, int max, SortDirection direction, boolean keysOnly) { Preconditions.checkNotNull(start); Preconditions.checkNotNull(end); Preconditions.checkArgument(max > -1); if (max == 0) { return Lists.newArrayList(); } Query query = new Query(kind); query.addFilter( "__key__", FilterOperator.GREATER_THAN_OR_EQUAL, KeyFactory.createKey(kind, escape(start))); query.addFilter("__key__", FilterOperator.LESS_THAN, KeyFactory.createKey(kind, escape(end))); query.addSort("__key__", direction); if (keysOnly) { query.setKeysOnly(); } PreparedQuery preparedQuery = service.prepare(query); List<Entry<String, Entity>> result = Lists.newArrayList(); for (Entity entity : preparedQuery.asIterable(FetchOptions.Builder.withLimit(max))) { if (keysOnly) { result.add(Maps.immutableEntry(unescape(entity.getKey().getName()), (Entity) null)); } else { result.add(Maps.immutableEntry(unescape(entity.getKey().getName()), entity)); } } return result; }
public static List<StorageNode> getStorageNodesInFolder(String path, Owner owner) { DatastoreService ds = DatastoreServiceFactory.getDatastoreService(); ArrayList<StorageNode> nodes = new ArrayList<StorageNode>(); String folderPath = PathHelper.getFolderpath(path); // Read folders Query q = new Query("Folder"); q.addFilter("path", FilterOperator.GREATER_THAN_OR_EQUAL, path); q.addFilter("path", FilterOperator.LESS_THAN, path + "\ufffd"); q.addFilter("ownerId", FilterOperator.EQUAL, owner.getId()); PreparedQuery pq = ds.prepare(q); List<Entity> results = pq.asList(FetchOptions.Builder.withLimit(99999)); for (Entity e : results) { Folder f = new Folder(); ReflectionHelper.setPropertiesFromEntity(Folder.class, f, e); log.debug("Folder compare: {} =?= {}", PathHelper.getFolderpath(f.getPath()), folderPath); if (PathHelper.getFolderpath(f.getPath()).equals(folderPath)) { nodes.add(f); } } // Read files Query q2 = new Query("File"); q2.addFilter("path", FilterOperator.GREATER_THAN_OR_EQUAL, path); q2.addFilter("path", FilterOperator.LESS_THAN, path + "\ufffd"); q2.addFilter("ownerId", FilterOperator.EQUAL, owner.getId()); PreparedQuery pq2 = ds.prepare(q); List<Entity> results2 = pq2.asList(FetchOptions.Builder.withLimit(99999)); for (Entity e : results2) { File f = new File(); ReflectionHelper.setPropertiesFromEntity(File.class, f, e); log.debug("File compare: {} =?= {}", PathHelper.getFolderpath(f.getPath()), folderPath); if (PathHelper.getFolderpath(f.getPath()).equals(folderPath)) { nodes.add(f); } } return nodes; }
private void doGetAction(JsonValues values, PrintWriter writer) { DatastoreService datastore = DatastoreServiceFactory.getDatastoreService(); Gson gson = new Gson(); String log = new String(); Filter keyFilter = new FilterPredicate("random", FilterOperator.GREATER_THAN_OR_EQUAL, getRandomLong()); // TODO: fix filtering of expansions /* TreeSet<String> missingExpansions= new TreeSet<String>(); for (Expansion expansion : values.expansions) { if (expansion.present == false) { Filter filter = new FilterPredicate(expansion.name, FilterOperator.NOT_EQUAL, true); keyFilter = CompositeFilterOperator.and(keyFilter, filter); missingExpansions.add(expansion.name); } } writer.println(keyFilter.toString()); */ Query q = new Query("Record").setFilter(keyFilter).addSort("random", SortDirection.ASCENDING); /* q.addSort("random", SortDirection.ASCENDING); for (String missingExpansion : missingExpansions) { q.addSort(missingExpansion, SortDirection.ASCENDING); } */ PreparedQuery pq = datastore.prepare(q); Iterator<Entity> entityIterator = pq.asIterable().iterator(); if (entityIterator.hasNext() == false) { q = new Query("Record").addSort("random", SortDirection.ASCENDING); pq = datastore.prepare(q); entityIterator = pq.asIterable().iterator(); if (entityIterator.hasNext() == false) { throw new RuntimeException("no data in datastore"); } } Entity record = entityIterator.next(); JsonValues resultValues = entityToJsonValues(record); resultValues.debug = log; String result = gson.toJson(resultValues); writer.println(result); }
/** * @param kind * @param ancestor * @return */ public static Iterable<Entity> listChildKeys(String kind, Key ancestor) { logger.log(Level.INFO, "Search entities based on parent"); Query q = new Query(kind); q.setAncestor(ancestor).setKeysOnly(); q.addFilter(Entity.KEY_RESERVED_PROPERTY, FilterOperator.GREATER_THAN, ancestor); PreparedQuery pq = datastore.prepare(q); return pq.asIterable(); }
public static Entity employeeSalaryRecord(String employeeId) { Filter employeeIdFilter = new FilterPredicate("EmployeeId", FilterOperator.EQUAL, employeeId); Query salaryQuery = new Query("Salary").setFilter(employeeIdFilter); PreparedQuery salaryPreparedQueryObject = datastore.prepare(salaryQuery); Entity salaryEntity = salaryPreparedQueryObject.asSingleEntity(); if (salaryEntity != null) return salaryEntity; return null; }
public Entity getEprSpectrEntityById(String loc, String id) { DatastoreService datastoreService = DatastoreServiceFactory.getDatastoreService(); Query query = new Query(loc + EprSpectr.class.getSimpleName()); query = query.addFilter(EprSpectr.ID, Query.FilterOperator.EQUAL, id); for (Entity anekEntity : datastoreService.prepare(query).asIterable()) { return anekEntity; } return null; }
/** * * Search entities based on search criteria * * @param kind * @param searchBy : Searching Criteria (Property) * @param searchFor : Searching Value (Property Value) * @return List all entities of a kind from the cache or datastore (if not in cache) with the * specified properties */ public static Iterable<Entity> listEntities(String kind, String searchBy, String searchFor) { logger.log(Level.INFO, "Search entities based on search criteria"); Query q = new Query(kind); if (searchFor != null && !"".equals(searchFor)) { q.addFilter(searchBy, FilterOperator.EQUAL, searchFor); } PreparedQuery pq = datastore.prepare(q); return pq.asIterable(); }
public void doGet(HttpServletRequest req, HttpServletResponse resp) throws IOException { int count = 0; int i = 0; String ID = req.getParameter("ID"); resp.setCharacterEncoding("UTF-8"); DatastoreService datastore = DatastoreServiceFactory.getDatastoreService(); Query query = new Query("PushInfo").addSort("date", Query.SortDirection.DESCENDING); List<Entity> entities = datastore.prepare(query).asList(FetchOptions.Builder.withLimit(MAXNUM)); resp.getWriter().print("{\"myBikeList\":{\"myBikeBoard\":["); if (entities.isEmpty()) { resp.getWriter().print(ID + "null"); } else { for (Entity entity : entities) { if (ID.equals(entity.getProperty("sellerID").toString())) { count++; } } } entities = datastore.prepare(query).asList(FetchOptions.Builder.withLimit(MAXNUM)); for (Entity entity : entities) { if (ID.equals(entity.getProperty("sellerID").toString())) { i++; String jsonString; OldBookGson myGson = new OldBookGson(); MemberInfo pushInfo = new MemberInfo(); pushInfo.setID(entity.getProperty("ID").toString()); pushInfo.setSellerTitle(entity.getProperty("title").toString()); pushInfo.setNumber(entity.getProperty("number").toString()); jsonString = myGson.toJson(pushInfo); resp.getWriter().print(jsonString); if (i != count) resp.getWriter().print(","); } } resp.getWriter().print("]}}"); }
@SuppressWarnings("unchecked") @Override public void doPost(HttpServletRequest req, HttpServletResponse resp) throws IOException, ServletException { List<String> errors = new ArrayList<String>(); PersistenceManager pm = getPersistenceManager(); String username = req.getParameter("username"); String password = req.getParameter("password"); if (username.isEmpty()) { errors.add("Username is required."); } if (password.isEmpty()) { errors.add("Password is required."); } try { req.setAttribute("errors", errors); List<Admin> us = (List<Admin>) pm.newQuery(Admin.class).execute(); resp.setContentType("text/html"); DatastoreService ds = DatastoreServiceFactory.getDatastoreService(); Query q = new Query("Admin"); q.setFilter( Query.CompositeFilterOperator.and( new Query.FilterPredicate("username", Query.FilterOperator.EQUAL, username), new Query.FilterPredicate("password", Query.FilterOperator.EQUAL, password))); List<Entity> entities = ds.prepare(q).asList(FetchOptions.Builder.withDefaults()); if (entities.size() == 0) { req.getRequestDispatcher("/login.jsp").forward(req, resp); } // if(entities.size()>0){ if (us.size() > 0) { /*for(int i = 0; i < us.size(); i++){ if(us.get(i).getPassword().equals(password) && us.get(i).getUsername().equals(username) && us.get(i).getUser_type() == 0){ resp.sendRedirect("/AdminHome"); } if(us.get(i).getPassword().equals(password) && us.get(i).getUsername().equals(username) && us.get(i).getUser_type() == 1){ resp.sendRedirect("/login.jsp"); } if(us.get(i).getPassword().equals(password) && us.get(i).getUsername().equals(username) && us.get(i).getUser_type() == 2){ resp.sendRedirect("/login.jsp"); } } //resp.sendRedirect("/login.jsp"); * */ // } } } catch (ServletException e) { e.printStackTrace(); } finally { pm.close(); } }
@Override protected void doPut(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { DatastoreService ds = DatastoreServiceFactory.getDatastoreService(); Query q = new Query("Member").addSort("name", SortDirection.DESCENDING); List<Entity> ents = ds.prepare(q).asList(FetchOptions.Builder.withLimit(10)); if (ents.size() < 1) { // 若無紀錄,則先 } }
public void doGet(HttpServletRequest req, HttpServletResponse res) throws IOException { DatastoreService datastore = DatastoreServiceFactory.getDatastoreService(); Key appHubKey = KeyFactory.createKey("AppHub", "apphub"); Query query = new Query("AppHub", appHubKey).addSort("date", Query.SortDirection.DESCENDING); List<Entity> apps = datastore.prepare(query).asList(FetchOptions.Builder.withLimit(25)); Gson gson = new Gson(); String json = gson.toJson(apps); res.getWriter().println(json); }
public static Entity getEntity(Query q) { try { // First retrieve the entity Entity ent = ds.prepare(q).asSingleEntity(); return ent; } catch (Exception e) { return null; } }
@Override public void prepare(int year, int month, int day) { Query q = new Query(sitemapEntity.getKind()); addBetweenFilter( q, sitemapEntity.getCreatedDateProperty(), DateUtils.getBeginningOfDay(year, month, day), DateUtils.getEndOfDay(year, month, day)); PreparedQuery pq = ds.prepare(q); entityIterator = pq.asIterator(); }
/** * This method lists all the entities inserted in datastore. It uses HTTP GET method and paging * support. * * @return A CollectionResponse class containing the list of all entities persisted and a cursor * to the next page. * @throws UnauthorizedException */ @ApiMethod( name = "findAll", scopes = {Config.EMAIL_SCOPE}, clientIds = {Config.CHROME_CLIENT_ID, Config.WEB_CLIENT_ID, Config.API_EXPLORER_CLIENT_ID}) public CollectionResponse<ServiceResponse> findAll( @Named("_name") String _name, @Nullable @Named("cursor") String cursorString, @Nullable @Named("limit") Integer limit, User user) throws UnauthorizedException { if (user == null) { throw new UnauthorizedException("UnauthorizedException # User is Null."); } DatastoreService datastore = DatastoreServiceFactory.getDatastoreService(); if (limit == null) { limit = 10; } FetchOptions fetchOptions = FetchOptions.Builder.withLimit(limit); if (cursorString != null) { fetchOptions.startCursor(Cursor.fromWebSafeString(cursorString)); } Query q = new Query(_name); q.addSort("_updatedAt", SortDirection.DESCENDING); PreparedQuery pq = datastore.prepare(q); QueryResultList<Entity> results = pq.asQueryResultList(fetchOptions); List<ServiceResponse> responses = new ArrayList<ServiceResponse>(); ServiceResponse res = null; for (Entity entity : results) { res = new ServiceResponse(); // TODO add properties from entity to service response 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()); responses.add(res); } cursorString = results.getCursor().toWebSafeString(); return CollectionResponse.<ServiceResponse>builder() .setItems(responses) .setNextPageToken(cursorString) .build(); }
public Serializable getCacheableObject(String feedUri) throws Exception { JSONObject json = new JSONObject(); PreparedQuery pq = datastoreService.prepare(new Query("feeds")); for (Entity entity : pq.asIterable()) { JSONObject item = new JSONObject(); item.put("uri", "/addama/feeds/" + entity.getKey().getName()); item.put("creator", entity.getProperty("creator").toString()); json.append("items", item); } return json.toString(); }
@Override public List<EprSpectrModel> getAllEprSpectrs() { ArrayList<EprSpectrModel> listRet = new ArrayList<EprSpectrModel>(); DatastoreService datastoreService = DatastoreServiceFactory.getDatastoreService(); Query query = new Query(locMain + EprSpectrModel.class.getSimpleName()); for (Entity esrSpecEntity : datastoreService.prepare(query).asIterable()) { EprSpectr anek = new EprSpectr(esrSpecEntity); EprSpectrModel anekModel = anek.getEprSpectrModel(); listRet.add(anekModel); } return listRet; }