@Test
public void testDeleteById() {
Event event = genEvent();
dataRepository.save(event);
dataRepository.delete(event.getId());
Assert.assertFalse(dataRepository.exists(event.getId()));
}
void destroyItem(TabItem item) {
int index = 0;
int itemCount = getItemCount();
while (index < itemCount) {
if (items[index] == item) break;
index++;
}
if (index == itemCount) error(SWT.ERROR_ITEM_NOT_REMOVED);
int oldIndex = OS.gtk_notebook_get_current_page(handle);
OS.g_signal_handlers_block_matched(handle, OS.G_SIGNAL_MATCH_DATA, 0, 0, 0, 0, SWITCH_PAGE);
OS.gtk_notebook_remove_page(handle, index);
OS.g_signal_handlers_unblock_matched(handle, OS.G_SIGNAL_MATCH_DATA, 0, 0, 0, 0, SWITCH_PAGE);
System.arraycopy(items, index + 1, items, index, --itemCount - index);
items[itemCount] = null;
if (index == oldIndex) {
int newIndex = OS.gtk_notebook_get_current_page(handle);
if (newIndex != -1) {
Control control = items[newIndex].getControl();
if (control != null && !control.isDisposed()) {
control.setBounds(getClientArea());
control.setVisible(true);
}
Event event = new Event();
event.item = items[newIndex];
sendSelectionEvent(SWT.Selection, event, true);
// the widget could be destroyed at this point
}
}
}
@Test
public void deserializeEventDataAccountEvent() throws IOException {
String json = resource("account_event.json");
Event e = StripeObject.PRETTY_PRINT_GSON.fromJson(json, Event.class);
assertEquals(e.getType(), "account.updated");
}
/** Servlet GET request: handles event requests. */
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
Event event = null;
try {
// Event parm identifies event type from the client
String eventType = Servlets.getParameter(request, P_EVENT);
// Always must have an event type
if (eventType == null) {
Log.warn("Pushlet.doGet(): bad request, no event specified");
response.sendError(HttpServletResponse.SC_BAD_REQUEST, "No eventType specified");
return;
}
// Create Event and set attributes from parameters
event = new Event(eventType);
for (Enumeration e = request.getParameterNames(); e.hasMoreElements(); ) {
String nextAttribute = (String) e.nextElement();
event.setField(nextAttribute, request.getParameter(nextAttribute));
}
} catch (Throwable t) {
// Error creating event
Log.warn("Pushlet: Error creating event in doGet(): ", t);
response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
return;
}
// Handle parsed request
doRequest(event, request, response);
}
public static ProcessDefinition createMilestoneProcessDefinition() {
ProcessDefinition pd =
new ProcessDefinition(
new String[] {
"start-state start",
"fork fork",
"state b",
"milestone-node m",
"state c",
"state d",
"join join",
"end-state end"
},
new String[] {
"start --> fork",
"fork --m--> b",
"fork --d--> d",
"b --> m",
"m --> c",
"c --> join",
"d --> join",
"join --> end"
});
Node d = pd.getNode("d");
Delegation instantiatableDelegate = new Delegation(new MilestoneEvent("m", "../m"));
Event event = new Event(Event.EVENTTYPE_NODE_LEAVE);
d.addEvent(event);
event.addAction(new Action(instantiatableDelegate));
pd.addDefinition(new ContextDefinition());
return pd;
}
/** Obsługa zapytań */
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, IOException {
long start = System.currentTimeMillis();
Document response = createDocument();
Element root = response.createElement("response");
response.appendChild(root);
String action = req.getParameter("action");
if (action == null) {
root.appendChild(createTextNode(response, "status", "err"));
root.appendChild(createTextNode(response, "message", "No action parameter defined"));
} else {
EventManager em = EventManager.getInstance();
Event e = em.getByName(action);
if (e == null) {
root.appendChild(createTextNode(response, "status", "err"));
root.appendChild(createTextNode(response, "message", "No such event (" + action + ")"));
} else {
root.appendChild(e.processEvent(response, req));
}
}
root.appendChild(
createTextNode(
response, "Total_time", String.valueOf(System.currentTimeMillis() - start) + " ms"));
XML2Writer(response, resp.getWriter());
XML2Writer(response, new PrintWriter(System.out));
}
/**
* Updates a single Event.<br>
* Implements the update Event operation of the EventSpot API by calling the ConstantContact
* server side.
*
* @param accessToken Constant Contact OAuth2 access token.
* @param event The event to update.
* @return An {@link Event} containing data as returned by the server on success; <br>
* An exception is thrown otherwise.
* @throws ConstantContactServiceException When something went wrong in the Constant Contact flow
* or an error is returned from server.
*/
@Override
public Event updateEvent(String accessToken, Event event) throws ConstantContactServiceException {
Event updatedEvent = null;
try {
String url =
String.format(
"%1$s%2$s",
Config.Endpoints.BASE_URL, String.format(Config.Endpoints.EVENT_ID, event.getId()));
String json = event.toJSON();
CUrlResponse response = getRestClient().put(url, accessToken, json);
if (response.hasData()) {
updatedEvent = Component.fromJSON(response.getBody(), Event.class);
}
if (response.isError()) {
ConstantContactServiceException constantContactException =
new ConstantContactServiceException(
ConstantContactServiceException.RESPONSE_ERR_SERVICE);
response.getInfo().add(new CUrlRequestError("url", url));
constantContactException.setErrorInfo(response.getInfo());
throw constantContactException;
}
} catch (ConstantContactServiceException e) {
throw new ConstantContactServiceException(e);
} catch (Exception e) {
throw new ConstantContactServiceException(e);
}
return updatedEvent;
}
/**
* Create and write a json-encoded event to the underlying file.
*
* @param eventName Name of the event.
* @param entityType The entity type.
* @param entityId The entity ID.
* @param targetEntityType The target entity type (optional).
* @param targetEntityId The target entity ID (optional).
* @param properties Properties (optional).
* @param eventTime The time of the event (optional).
* @throws IOException
*/
public void createEvent(
String eventName,
String entityType,
String entityId,
String targetEntityType,
String targetEntityId,
Map<String, Object> properties,
DateTime eventTime)
throws IOException {
if (eventTime == null) {
eventTime = new DateTime();
}
Event event =
new Event().event(eventName).entityType(entityType).entityId(entityId).eventTime(eventTime);
if (targetEntityType != null) {
event.targetEntityType(targetEntityType);
}
if (targetEntityId != null) {
event.targetEntityId(targetEntityId);
}
if (properties != null) {
event.properties(properties);
}
out.write(event.toJsonString().getBytes("UTF8"));
out.write('\n');
}
@Override
protected boolean handleEvent(Event evt) {
if (evt.isKeyEvent() && content != null && content.canAcceptKeyboardFocus()) {
if (content.handleEvent(evt)) {
content.requestKeyboardFocus();
return true;
}
}
if (super.handleEvent(evt)) {
return true;
}
switch (evt.getType()) {
case KEY_PRESSED:
case KEY_RELEASED:
{
int keyCode = evt.getKeyCode();
if (keyCode == Event.KEY_LEFT || keyCode == Event.KEY_RIGHT) {
return scrollbarH.handleEvent(evt);
}
if (keyCode == Event.KEY_UP
|| keyCode == Event.KEY_DOWN
|| keyCode == Event.KEY_PRIOR
|| keyCode == Event.KEY_NEXT) {
return scrollbarV.handleEvent(evt);
}
break;
}
case MOUSE_WHEEL:
if (scrollbarV.isVisible()) {
return scrollbarV.handleEvent(evt);
}
return false;
}
return evt.isMouseEvent() && contentArea.isMouseInside(evt);
}
@Override
public boolean perform(Game game, Event event, java.util.Map<Parameter, Set> parameters) {
Set cards = new Set();
for (Player player : parameters.get(Parameter.PLAYER).getAll(Player.class))
cards.addAll(player.getHand(game.actualState).objects);
java.util.Map<Parameter, Set> discardParameters =
new java.util.HashMap<Parameter, Set>();
discardParameters.put(EventType.Parameter.CAUSE, parameters.get(Parameter.CAUSE));
discardParameters.put(EventType.Parameter.CARD, cards);
Event discardEvent =
createEvent(
game,
"Each player discards his or her hand",
EventType.DISCARD_CARDS,
discardParameters);
discardEvent.perform(event, true);
java.util.Map<Parameter, Set> drawParameters = new java.util.HashMap<Parameter, Set>();
drawParameters.put(EventType.Parameter.CAUSE, parameters.get(Parameter.CAUSE));
drawParameters.put(EventType.Parameter.PLAYER, parameters.get(Parameter.PLAYER));
drawParameters.put(EventType.Parameter.NUMBER, new Set(4));
Event drawEvent =
createEvent(game, "and draws four cards.", EventType.DRAW_CARDS, drawParameters);
drawEvent.perform(event, true);
event.setResult(Empty.set);
return true;
}
void populateReminders(Event e) throws RemoteException {
// reminders
Uri remindersUri =
Reminders.CONTENT_URI
.buildUpon()
.appendQueryParameter(ContactsContract.CALLER_IS_SYNCADAPTER, "true")
.build();
@Cleanup
Cursor c =
providerClient.query(
remindersUri,
new String[] {
/* 0 */
Reminders.MINUTES, Reminders.METHOD
},
Reminders.EVENT_ID + "=?",
new String[] {String.valueOf(e.getLocalID())},
null);
while (c != null && c.moveToNext()) {
VAlarm alarm = new VAlarm(new Dur(0, 0, -c.getInt(0), 0));
PropertyList props = alarm.getProperties();
switch (c.getInt(1)) {
/*case Reminders.METHOD_EMAIL:
props.add(Action.EMAIL);
break;*/
default:
props.add(Action.DISPLAY);
props.add(new Description(e.getSummary()));
}
e.addAlarm(alarm);
}
}
/**
* Formats the event using a given pattern. The pattern needs to be compatible with {@link
* AdvancedMessageFormat}.
*
* @param event the event
* @param pattern the pattern (compatible with {@link AdvancedMessageFormat})
* @return the formatted message
*/
public static String format(Event event, String pattern) {
AdvancedMessageFormat format = new AdvancedMessageFormat(pattern);
Map params = new java.util.HashMap(event.getParams());
params.put("source", event.getSource());
params.put("severity", event.getSeverity());
return format.format(params);
}
public static Event getNewReleasedEvent() {
Event event = getNewEvent();
event.setReleased(true);
return event;
}
public Object up(Event evt) {
switch (evt.getType()) {
case Event.MSG:
Message msg = (Message) evt.getArg();
ForkHeader hdr = (ForkHeader) msg.getHeader(id);
if (hdr == null) break;
if (hdr.fork_stack_id == null)
throw new IllegalArgumentException("header has a null fork_stack_id");
Protocol bottom_prot = get(hdr.fork_stack_id);
return bottom_prot != null
? bottom_prot.up(evt)
: this.unknownForkHandler.handleUnknownForkStack(msg, hdr.fork_stack_id);
case Event.VIEW_CHANGE:
for (Protocol bottom : fork_stacks.values()) bottom.up(evt);
break;
case Event.STATE_TRANSFER_OUTPUTSTREAM:
if (!process_state_events) break;
getStateFromMainAndForkChannels(evt);
return null;
case Event.STATE_TRANSFER_INPUTSTREAM:
if (!process_state_events) break;
setStateInMainAndForkChannels((InputStream) evt.getArg());
return null;
}
return up_prot.up(evt);
}
@Test
@Transactional
public void testRemoveContactFromEventMultipleGroups() throws Exception {
groupService.create(group);
groupService.addAggregation(event, group);
Group secondGroup = new Group();
secondGroup.setGroupName("Second Group");
groupService.create(secondGroup);
groupService.addAggregation(event, secondGroup);
Contact newContact = new Contact();
newContact.setFirstName("Fresh Contact");
newContact.setEmail("Fresh email");
contactService.create(newContact);
event = eventService.findById(event.getId());
contactService.attendEvent(newContact, event);
newContact = contactService.findById(newContact.getId());
contactService.unattendEvent(newContact, event);
event = eventService.findById(event.getId());
assertFalse(event.getAttendees().contains(newContact));
newContact = contactService.findById(newContact.getId());
assertFalse(newContact.getAttendedEvents().contains(event));
}
public boolean isCleared() {
if (!clearable) return false;
for (Event event : events) {
if (!event.isCleared()) return false;
}
return true;
}
@Before
public void setup() throws ConstraintViolation, NullDomainReference {
createContacts();
committee = new Committee();
committee.setName("Committee Name");
committeeService.create(committee);
contactService.addContactToCommittee(first, committee);
contactService.addContactToCommittee(second, committee);
organization = new Organization();
organization.setName("Organization Name");
organizationService.create(organization);
contactService.addContactToOrganization(first, organization);
contactService.addContactToOrganization(second, organization);
event = new Event();
event.setName("Event Name");
event.setDateHeld("2015-01-01");
eventService.create(event);
contactService.attendEvent(first, event);
contactService.attendEvent(second, event);
group = new Group();
group.setGroupName("New AlinskyGroup");
}
@Override
public void handleOnset(double time, double salience) {
double roundedTime = Math.round(time * 10000) / 10000.0;
Event e = newEvent(roundedTime, 0);
e.salience = salience;
onsetList.add(e);
}
@Test
public void memoryTest() throws InterruptedException {
final StatefulKnowledgeSession ksession = createKnowledgeSession();
Event myevent = new Event();
ksession.setGlobal("event", myevent);
final Server node1 = new Server(1500, "server1");
new Thread(
new Runnable() {
public void run() {
ksession.fireUntilHalt();
}
})
.start();
serverHandle = ksession.insert(node1);
int memory = 1500;
for (int i = 0; i < 5; i++) {
Thread.sleep(6000);
memory = memory - 200;
node1.setMemory(memory);
ksession.update(serverHandle, node1);
}
ksession.halt();
System.out.println(myevent.getEvents());
}
@Override
public void makeChoices(Game game, Event event, java.util.Map<Parameter, Set> parameters) {
int numberOfCards = 1;
if (parameters.containsKey(Parameter.NUMBER))
numberOfCards = Sum.get(parameters.get(Parameter.NUMBER));
if (numberOfCards < 0) numberOfCards = 0;
java.util.Set<Card> cardsInHand = null;
boolean specificChoices = parameters.containsKey(Parameter.CHOICE);
if (specificChoices) cardsInHand = parameters.get(Parameter.CHOICE).getAll(Card.class);
for (Player player : parameters.get(Parameter.PLAYER).getAll(Player.class)) {
if (!specificChoices)
cardsInHand = new Set(player.getHand(game.actualState).objects).getAll(Card.class);
java.util.Collection<Card> choices =
player.sanitizeAndChoose(
game.actualState,
numberOfCards,
cardsInHand,
PlayerInterface.ChoiceType.OBJECTS,
PlayerInterface.ChooseReason.DISCARD);
if (choices.size() != numberOfCards) event.allChoicesMade = false;
event.putChoices(player, choices);
}
}
@SuppressWarnings("unchecked")
protected void dispatch(Event event) {
// all events go thru this loop
if (LOG.isDebugEnabled()) {
LOG.debug("Dispatching the event " + event.getClass().getName() + "." + event.toString());
}
Class<? extends Enum> type = event.getType().getDeclaringClass();
try {
EventHandler handler = eventDispatchers.get(type);
if (handler != null) {
handler.handle(event);
} else {
throw new Exception("No handler for registered for " + type);
}
} catch (Throwable t) {
// TODO Maybe log the state of the queue
LOG.fatal("Error in dispatcher thread", t);
// If serviceStop is called, we should exit this thread gracefully.
if (exitOnDispatchException
&& (ShutdownHookManager.get().isShutdownInProgress()) == false
&& stopped == false) {
Thread shutDownThread = new Thread(createShutDownThread());
shutDownThread.setName("AsyncDispatcher ShutDown handler");
shutDownThread.start();
}
}
}
/**
* parse the String message
*
* @return SIPHeader (Event object)
* @throws SIPParseException if the message does not respect the spec.
*/
public SIPHeader parse() throws ParseException {
if (debug) dbg_enter("EventParser.parse");
try {
headerName(TokenTypes.EVENT);
this.lexer.SPorHT();
Event event = new Event();
this.lexer.match(TokenTypes.ID);
Token token = lexer.getNextToken();
String value = token.getTokenValue();
event.setEventType(value);
super.parse(event);
this.lexer.SPorHT();
this.lexer.match('\n');
return event;
} catch (ParseException ex) {
throw createParseException(ex.getMessage());
} finally {
if (debug) dbg_leave("EventParser.parse");
}
}
@Override
public View onCreateView(
LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
View rootView = inflater.inflate(R.layout.fragment_globalevent_detail, container, false);
LinearLayout layout = (LinearLayout) rootView.findViewById(R.id.layout);
// Load the GlobalEvent content.
((TextView) rootView.findViewById(R.id.title)).setText(globalEvent.getName());
((TextView) rootView.findViewById(R.id.subtitle)).setText(globalEvent.getTeam());
((TextView) rootView.findViewById(R.id.id_ulg)).setText(globalEvent.getCode());
((TextView) rootView.findViewById(R.id.descriptionContent))
.setText(globalEvent.getDescription());
if (!globalEvent.getEventList().isEmpty())
rootView.findViewById(R.id.eventListTitle).setVisibility(View.VISIBLE);
List<String> ids = new ArrayList<>();
for (Subevent event : globalEvent.getEventList()) {
if (!ids.contains(event.getId())) {
Event e = new Event(rootView.getContext(), event);
e.setMinimalSize();
layout.addView(e);
ids.add(event.getId());
}
}
return rootView;
}
@SuppressWarnings("unchecked")
@Override
public void dispatchEvent(@Nonnull Event<?> event) {
AutowireCapableBeanFactory factory = applicationContext.getAutowireCapableBeanFactory();
List<Event<?>> queue = Lists.<Event<?>>newArrayList(event);
while (!queue.isEmpty()) {
Event<?> evt = queue.remove(0);
for (Class<? extends EventHandler<?>> eventHandler :
handlers.get((Class<? extends Event<?>>) evt.getClass())) {
EventHandler<Event<?>> handler =
(EventHandler<Event<?>>)
factory.autowire(eventHandler, AutowireCapableBeanFactory.AUTOWIRE_BY_TYPE, true);
EventResult result = handler.onEvent(evt);
if (result.isAbort()) {
throw new RuntimeException(
String.format(
"Handler %s aborted event %s with message: %s",
handler, evt, result.getMessage()));
}
queue.addAll(result.getTriggeredEvents());
}
}
}
long /*int*/ menuItemSelected(long /*int*/ widget, ToolItem item) {
Event event = new Event();
switch (item.style) {
case SWT.DROP_DOWN:
/*
* Feature in GTK. The DROP_DOWN item does not
* contain arrow button in the overflow menu. So, it
* is impossible to select the menu of that item.
* The fix is to consider the item selection
* as Arrow click, in order to popup the drop-down.
*/
event.detail = SWT.ARROW;
GtkAllocation allocation = new GtkAllocation();
OS.gtk_widget_get_allocation(widget, allocation);
event.x = allocation.x;
if ((style & SWT.MIRRORED) != 0) event.x = getClientWidth() - allocation.width - event.x;
event.y = allocation.y + allocation.height;
break;
case SWT.RADIO:
if ((style & SWT.NO_RADIO_GROUP) == 0) item.selectRadio();
break;
case SWT.CHECK:
boolean currentSelection = item.getSelection();
item.setSelection(!currentSelection);
}
item.sendSelectionEvent(SWT.Selection, event, false);
return 0;
}
/*
Send out and confirm it has been sent
*/
@RequestMapping(value = path + "send")
@ResponseBody
public Request voteSend(
@RequestParam(value = phoneNumber) String inputNumber,
@RequestParam(value = entityUidParam) String requestUid)
throws URISyntaxException {
User user = userManager.findByInputNumber(inputNumber, null);
USSDMenu menu;
try {
String createdUid = eventRequestBroker.finish(user.getUid(), requestUid, true);
Event vote = eventBroker.load(createdUid);
log.info(
"Vote details confirmed! Closing date and time: "
+ vote.getEventDateTimeAtSAST().format(dateTimeFormat));
menu = new USSDMenu(getMessage(thisSection, "send", promptKey, user), optionsHomeExit(user));
return menuBuilder(menu);
} catch (EventStartTimeNotInFutureException e) {
final String messageKey = USSDSection.VOTES.toKey() + "send.err.past.";
menu = new USSDMenu(getMessage(messageKey + promptKey, user));
menu.setFreeText(false);
menu.addMenuOption(
voteMenus + "send-reset" + entityUidUrlSuffix + requestUid,
getMessage(messageKey + "yes", user));
menu.addMenuOption(backVoteUrl("time", requestUid), getMessage(messageKey + "no", user));
return menuBuilder(menu);
}
}
void setSelection(int index, boolean notify) {
if (index < 0) return;
int oldIndex = OS.gtk_notebook_get_current_page(handle);
if (oldIndex == index) return;
if (oldIndex != -1) {
TabItem item = items[oldIndex];
Control control = item.control;
if (control != null && !control.isDisposed()) {
control.setVisible(false);
}
}
OS.g_signal_handlers_block_matched(handle, OS.G_SIGNAL_MATCH_DATA, 0, 0, 0, 0, SWITCH_PAGE);
OS.gtk_notebook_set_current_page(handle, index);
OS.g_signal_handlers_unblock_matched(handle, OS.G_SIGNAL_MATCH_DATA, 0, 0, 0, 0, SWITCH_PAGE);
int newIndex = OS.gtk_notebook_get_current_page(handle);
if (newIndex != -1) {
TabItem item = items[newIndex];
Control control = item.control;
if (control != null && !control.isDisposed()) {
control.setBounds(getClientArea());
control.setVisible(true);
}
if (notify) {
Event event = new Event();
event.item = item;
sendSelectionEvent(SWT.Selection, event, true);
}
}
}
@RequestMapping(value = path + "change-vote")
@ResponseBody
public Request changeVoteDo(
@RequestParam(value = phoneNumber) String inputNumber,
@RequestParam(value = entityUidParam) String eventUid,
@RequestParam(value = "response") String response)
throws URISyntaxException {
final User user = userManager.findByInputNumber(inputNumber, null);
final Event vote = eventBroker.load(eventUid);
USSDMenu menu;
if (vote.getEventStartDateTime().isBefore(Instant.now())) {
menu = new USSDMenu(getMessage(thisSection, "change", "error", user));
} else {
// todo: replace this hack once responses are handled better
EventRSVPResponse voteResponse =
"abstain".equals(response)
? EventRSVPResponse.MAYBE
: EventRSVPResponse.fromString(response);
eventLogBroker.rsvpForEvent(vote.getUid(), user.getUid(), voteResponse);
menu = new USSDMenu(getMessage(thisSection, "change", "done", response, user));
}
menu.addMenuOption(
voteMenus + "details" + entityUidUrlSuffix + eventUid + "&back=open",
getMessage(thisSection, "change", optionsKey + "back", user));
menu.addMenuOptions(optionsHomeExit(user));
return menuBuilder(menu);
}
/*! This method runs all the time and listens to data from the SK6 and posts the data through
events to the event heap
*/
public void run() {
String data;
String[] tokens;
Integer value;
Event e;
System.out.println("Bluetooth thread, waiting for data");
while (running == true) {
try {
if (inBufReader.ready()) {
data = inBufReader.readLine();
tokens = data.split(",");
e = new Event("Shake");
e.addField("ProxyID", proxyID);
e.setPostValue("TimeToLive", new Integer(50)); // set time to live to 50 msec
e.setPostValue("Sensor", tokens[0]);
for (int i = 1; i < tokens.length; i++) {
if (tokens[i].startsWith("+")) { // eliminate Number format exception
value = new Integer(tokens[i].substring(1));
} else {
value = new Integer(tokens[i]);
}
e.setPostValue("Data" + i, value);
}
eventHeap.putEvent(e);
}
} catch (Exception ex) {
ex.printStackTrace();
}
}
System.out.println("out of run");
}
@Test
public void testFindWithLimitAndSort() {
Event event = genEvent();
event.setEventTime(new Date(1436390151975l));
dataRepository.save(event);
List<Condition> conditions = new LinkedList<Condition>();
conditions.add(new Condition("uid", PhoenixConditionOperator.EQUAL, "TEST_USER"));
Condition c1 = new Condition("event_time", PhoenixConditionOperator.EQUAL, 1436390151975l);
Condition c2 = new Condition("event_time", PhoenixConditionOperator.EQUAL, 1436216440707l);
conditions.add(new Condition(c1, PhoenixConditionOperator.OR, c2));
Query query =
QueryBuilder.newBuilder()
.conditions(conditions)
.sort(new Sort(new Order(Direction.DESC, "receipt_time")))
.limit(1)
.build();
List<Event> list = (List<Event>) dataRepository.find(query);
Assert.assertTrue(!list.isEmpty());
for (Event e : list) {
System.out.println(e);
}
}
