@Override
public boolean onMessage(final Message message) {
if (message instanceof ClockMessage) {
final ClockMessage clockMessage = (ClockMessage) message;
MessageScheduler.getInstance().removeClock(clockMessage.getClockId());
if (this.m_cancelTimedPop) {
return false;
}
this.popup();
return false;
} else {
switch (message.getId()) {
case 19301:
{
final UIShowPopupInfosMessage msg = (UIShowPopupInfosMessage) message;
boolean ok = false;
if (this.m_popupDialog == null || this.m_fieldProvider == null) {
MessageScheduler.getInstance().removeAllClocks(this);
return false;
}
if (this.m_fieldProvider instanceof SpellLevel
&& msg.getContent() instanceof SpellLevel) {
final SpellLevel spellLevel1 = (SpellLevel) this.m_fieldProvider;
final SpellLevel spellLevel2 = (SpellLevel) msg.getContent();
ok = (spellLevel1.getSpell().getId() == spellLevel2.getSpell().getId());
} else {
ok = this.m_fieldProvider.equals(msg.getContent());
}
if (ok) {
this.m_cancelTimedPop = !XulorActions.closePopup(null, this.m_popupDialog);
PropertiesProvider.getInstance().removeProperty(this.m_property);
}
return false;
}
case 19300:
{
final UIShowPopupInfosMessage msg = (UIShowPopupInfosMessage) message;
this.m_fieldProvider = msg.getContent();
if (this.m_fieldProvider == null) {
return false;
}
if (msg.getIntValue() > 0) {
this.m_cancelTimedPop = false;
MessageScheduler.getInstance().addClock(this, msg.getIntValue(), -1, 1);
} else {
this.popup();
}
return false;
}
default:
{
return true;
}
}
}
}
public void runHibernate() {
// ############################################################################
Session session = HibernateUtil.getSessionFactory().openSession();
Transaction tx = session.beginTransaction();
Message message = new Message("Hello World");
session.save(message);
tx.commit();
session.close();
// ############################################################################
Session secondSession = HibernateUtil.getSessionFactory().openSession();
Transaction secondTransaction = secondSession.beginTransaction();
List messages = secondSession.createQuery("from Message m order by m.text asc").list();
System.out.println(messages.size() + " message(s) found:");
for (Iterator iter = messages.iterator(); iter.hasNext(); ) {
Message loadedMsg = (Message) iter.next();
System.out.println(loadedMsg.getText());
}
secondTransaction.commit();
secondSession.close();
// ############################################################################
Session thirdSession = HibernateUtil.getSessionFactory().openSession();
Transaction thirdTransaction = thirdSession.beginTransaction();
// message.getId() holds the identifier value of the first message
Message loadedMessage = (Message) thirdSession.get(Message.class, message.getId());
loadedMessage.setText("Greetings Earthling");
loadedMessage.setNextMessage(new Message("Take me to your leader (please)"));
thirdTransaction.commit();
thirdSession.close();
// ############################################################################
// Final unit of work (just repeat the query)
// TODO: You can move this query into the thirdSession before the
// commit, makes more sense!
Session fourthSession = HibernateUtil.getSessionFactory().openSession();
Transaction fourthTransaction = fourthSession.beginTransaction();
messages = fourthSession.createQuery("from Message m order by m.text asc").list();
System.out.println(messages.size() + " message(s) found:");
for (Iterator iter = messages.iterator(); iter.hasNext(); ) {
Message loadedMsg = (Message) iter.next();
System.out.println(loadedMsg.getText());
}
fourthTransaction.commit();
fourthSession.close();
// Shutting down the application
HibernateUtil.shutdown();
}
private void vanish(MessageContext context, String args) {
Message message = context.getMessage();
if (args.isEmpty()) {
return;
}
try {
final int cap = 100;
final int capPages = 10;
String[] vals = args.split(" ");
String userId;
int numMsgs;
if (vals.length == 2) {
User user = findUser(context, vals[0]);
userId = user.getId();
if (user == NO_USER) {
userId = vals[0];
}
numMsgs = Math.max(1, Math.min(cap, Integer.parseInt(vals[1])));
} else if (vals.length == 1) {
userId = "";
numMsgs = Math.max(1, Math.min(cap, Integer.parseInt(vals[0])));
} else {
userId = "";
numMsgs = 10;
}
int limit = numMsgs;
String before = message.getId();
// Limit search to 10 pages (500 msgs)
// Instead of deleting them when we find them, we build a list instead
List<String> messagesToDelete = new ArrayList<>(limit);
for (int k = 0; k < capPages && limit > 0; k++) {
Map<String, String> headers = new HashMap<>();
headers.put(HttpHeaders.CONTENT_TYPE, ContentType.APPLICATION_JSON.getMimeType());
headers.put(HttpHeaders.AUTHORIZATION, apiClient.getToken());
Map<String, Object> queryParams = new HashMap<>();
queryParams.put("limit", 50);
queryParams.put("before", before);
HttpResponse<JsonNode> response =
Unirest.get(ApiConst.CHANNELS_ENDPOINT + message.getChannelId() + "/messages")
.headers(headers)
.queryString(queryParams)
.asJson();
JSONArray ret = response.getBody().getArray();
if (userId.isEmpty()) {
for (int i = 0; i < ret.length() && limit > 0; i++) {
JSONObject msg = ret.getJSONObject(i);
String mid = msg.getString("id");
before = mid;
messagesToDelete.add(mid);
limit--;
}
} else {
for (int i = 0; i < ret.length() && limit > 0; i++) {
JSONObject msg = ret.getJSONObject(i);
String mid = msg.getString("id");
JSONObject msgUsr = msg.getJSONObject("author");
String uid = msgUsr.getString("id");
before = mid;
if (userId.equals(uid)) {
messagesToDelete.add(mid);
limit--;
}
}
}
}
LOGGER.info("Deleting {} messages", messagesToDelete.size());
// Using bulk delete endpoint
apiClient.bulkDeleteMessages(
context.getChannel().getId(),
messagesToDelete.toArray(new String[messagesToDelete.size()]));
} catch (Exception e) {
LOGGER.warn("Unable to get messages", e);
}
}
@Override
public void run() {
sending: // Label so that, if needed, we can completely kill the while loop from inside the
// nested loop.
while (sender.alive) {
Queue<Task> queue = sender.getQueue();
while (sender.alive && !queue.isEmpty()) {
Long messageLimit = sender.api.getMessageLimit(sender.ratelimitIdentifier);
if (messageLimit != null) {
try {
Thread.sleep(messageLimit - System.currentTimeMillis());
} catch (InterruptedException e) {
JDAImpl.LOG.log(e);
}
}
Task task = queue.peek();
Message msg = task.message;
Requester.Response response;
if (sender.api.getTextChannelById(msg.getChannelId()) == null
&& sender.api.getPrivateChannelById(msg.getChannelId()) == null) {
// We no longer have access to the MessageChannel that this message is queued to
// send to. This is most likely because it was deleted.
AsyncMessageSender.stop(sender.api, sender.ratelimitIdentifier);
break sending;
}
if (task.isEdit) {
response =
sender
.api
.getRequester()
.patch(
Requester.DISCORD_API_PREFIX
+ "channels/"
+ msg.getChannelId()
+ "/messages/"
+ msg.getId(),
new JSONObject().put("content", msg.getRawContent()));
} else {
response =
sender
.api
.getRequester()
.post(
Requester.DISCORD_API_PREFIX
+ "channels/"
+ msg.getChannelId()
+ "/messages",
new JSONObject()
.put("content", msg.getRawContent())
.put("tts", msg.isTTS()));
}
if (response.responseText == null) {
JDAImpl.LOG.debug(
"Error sending async-message (returned null-text)... Retrying after 1s");
sender.api.setMessageTimeout(sender.ratelimitIdentifier, 1000);
} else if (!response.isRateLimit()) // success/unrecoverable error
{
queue.poll(); // remove from queue
try {
if (response.isOk()) {
if (task.callback != null)
task.callback.accept(
new EntityBuilder(sender.api).createMessage(response.getObject()));
} else {
// if response didn't have id, sending failed (due to permission/blocked pm,...
JDAImpl.LOG.fatal(
"Could not send/update async message to channel: "
+ msg.getChannelId()
+ ". Discord-response: "
+ response.toString());
if (task.callback != null) task.callback.accept(null);
}
} catch (JSONException ex) {
// could not generate message from json
JDAImpl.LOG.log(ex);
} catch (IllegalArgumentException ex) {
JDAImpl.LOG.log(ex);
}
} else {
sender.api.setMessageTimeout(
sender.ratelimitIdentifier, response.getObject().getLong("retry_after"));
}
if (queue.isEmpty()) {
queue = sender.getQueue();
}
}
sender.waitNew();
}
}
