Implement chat.meMessage for /me (closes #5)

v1
Tony Olagbaiye 7 years ago
parent a43417139e
commit 8284713cad

@ -30,6 +30,7 @@ SRCS=slack.c \
api/message/slack-api-message-slackbot-response.c \ api/message/slack-api-message-slackbot-response.c \
api/message/slack-api-message-me-message.c \ api/message/slack-api-message-me-message.c \
api/message/slack-api-message-unimplemented.c \ api/message/slack-api-message-unimplemented.c \
request/slack-request-chat-memessage.c \
request/slack-request-chat-postmessage.c \ request/slack-request-chat-postmessage.c \
request/slack-request-channels-list.c \ request/slack-request-channels-list.c \
request/slack-request-conversations-members.c \ request/slack-request-conversations-members.c \

@ -44,7 +44,7 @@
** TODO [#A] Implement essential api endpoints and events ** TODO [#A] Implement essential api endpoints and events
- [X] +Implement handling api message =message.me_message= (see [[http://github.com/bqv/weechat-slack/issues/5][#5]])+ - [X] +Implement handling api message =message.me_message= (see [[http://github.com/bqv/weechat-slack/issues/5][#5]])+
- [ ] Implement sending request =chat.meMessage= (see [[http://github.com/bqv/weechat-slack/issues/5][#5]]) - [X] +Implement sending request =chat.meMessage= (see [[http://github.com/bqv/weechat-slack/issues/5][#5]])+
- [ ] Implement handling api message =message.thread_broadcast= - [ ] Implement handling api message =message.thread_broadcast=
- [X] +Implement handling api message =message.bot_message= (see [[http://github.com/bqv/weechat-slack/issues/2][#2]])+ - [X] +Implement handling api message =message.bot_message= (see [[http://github.com/bqv/weechat-slack/issues/2][#2]])+
- [ ] Implement handling api message =message.message_changed= - [ ] Implement handling api message =message.message_changed=
@ -62,6 +62,7 @@
- [ ] Complete api event set - [ ] Complete api event set
** TODO [#C] Implement full weechat functionality ** TODO [#C] Implement full weechat functionality
- [ ] Hook buffer closes - [ ] Hook buffer closes
- [ ] Relay compatibility
* Contributing * Contributing

@ -0,0 +1,270 @@
// This Source Code Form is subject to the terms of the Mozilla Public
// License, version 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.
#include <libwebsockets.h>
#include <json.h>
#include <stdlib.h>
#include <string.h>
#include "../weechat-plugin.h"
#include "../slack.h"
#include "../slack-workspace.h"
#include "../slack-request.h"
#include "../slack-user.h"
#include "../request/slack-request-chat-memessage.h"
static const char *const endpoint = "/api/chat.meMessage?"
"token=%s&channel=%s&text=%s&";
static inline int json_valid(json_object *object, struct t_slack_workspace *workspace)
{
if (!object)
{
weechat_printf(
workspace->buffer,
_("%s%s: error sending me-message: unexpected response from server"),
weechat_prefix("error"), SLACK_PLUGIN_NAME);
//__asm__("int3");
return 0;
}
return 1;
}
static const struct lws_protocols protocols[];
static int callback_http(struct lws *wsi, enum lws_callback_reasons reason,
void *user, void *in, size_t len)
{
struct t_slack_request *request = (struct t_slack_request *)user;
struct lws_client_connect_info ccinfo;
int status;
switch (reason)
{
/* because we are protocols[0] ... */
case LWS_CALLBACK_CLIENT_CONNECTION_ERROR:
weechat_printf(
request->workspace->buffer,
_("%s%s: (%d) error connecting to slack: %s"),
weechat_prefix("error"), SLACK_PLUGIN_NAME, request->idx,
in ? (char *)in : "(null)");
weechat_printf(
request->workspace->buffer,
_("%s%s: (%d) reconnecting..."),
weechat_prefix("error"), SLACK_PLUGIN_NAME, request->idx);
memset(&ccinfo, 0, sizeof(ccinfo)); /* otherwise uninitialized garbage */
ccinfo.context = request->context;
ccinfo.ssl_connection = LCCSCF_USE_SSL;
ccinfo.port = 443;
ccinfo.address = "slack.com";
ccinfo.path = request->uri;
ccinfo.host = ccinfo.address;
ccinfo.origin = ccinfo.address;
ccinfo.method = "GET";
ccinfo.protocol = protocols[0].name;
ccinfo.pwsi = &request->client_wsi;
ccinfo.userdata = request;
lws_client_connect_via_info(&ccinfo);
break;
case LWS_CALLBACK_ESTABLISHED_CLIENT_HTTP:
status = lws_http_client_http_response(wsi);
weechat_printf(
request->workspace->buffer,
_("%s%s: (%d) sending me-message... (%d)"),
weechat_prefix("network"), SLACK_PLUGIN_NAME, request->idx,
status);
break;
/* chunks of chunked content, with header removed */
case LWS_CALLBACK_RECEIVE_CLIENT_HTTP_READ:
{
struct t_json_chunk *new_chunk, *last_chunk;
new_chunk = malloc(sizeof(*new_chunk));
new_chunk->data = malloc((1024 * sizeof(char)) + 1);
new_chunk->data[0] = '\0';
new_chunk->next = NULL;
strncat(new_chunk->data, in, (int)len);
if (request->json_chunks)
{
for (last_chunk = request->json_chunks; last_chunk->next;
last_chunk = last_chunk->next);
last_chunk->next = new_chunk;
}
else
{
request->json_chunks = new_chunk;
}
}
return 0; /* don't passthru */
/* uninterpreted http content */
case LWS_CALLBACK_RECEIVE_CLIENT_HTTP:
{
char buffer[1024 + LWS_PRE];
char *px = buffer + LWS_PRE;
int lenx = sizeof(buffer) - LWS_PRE;
if (lws_http_client_read(wsi, &px, &lenx) < 0)
return -1;
}
return 0; /* don't passthru */
case LWS_CALLBACK_COMPLETED_CLIENT_HTTP:
{
int chunk_count, i;
char *json_string;
json_object *response, *ok, *error;
struct t_json_chunk *chunk_ptr;
chunk_count = 0;
if (request->json_chunks)
{
chunk_count++;
for (chunk_ptr = request->json_chunks; chunk_ptr->next;
chunk_ptr = chunk_ptr->next)
{
chunk_count++;
}
}
json_string = malloc((1024 * sizeof(char) * chunk_count) + 1);
json_string[0] = '\0';
chunk_ptr = request->json_chunks;
for (i = 0; i < chunk_count; i++)
{
strncat(json_string, chunk_ptr->data, 1024);
chunk_ptr = chunk_ptr->next;
free(request->json_chunks->data);
free(request->json_chunks);
request->json_chunks = chunk_ptr;
}
weechat_printf(
request->workspace->buffer,
_("%s%s: (%d) got response: %s"),
weechat_prefix("network"), SLACK_PLUGIN_NAME, request->idx,
json_string);
response = json_tokener_parse(json_string);
ok = json_object_object_get(response, "ok");
if (!json_valid(ok, request->workspace))
{
json_object_put(response);
free(json_string);
return 0;
}
if(json_object_get_boolean(ok))
{
/* wait for websocket to catch up */
}
else
{
error = json_object_object_get(response, "error");
if (!json_valid(error, request->workspace))
{
json_object_put(response);
free(json_string);
return 0;
}
weechat_printf(
request->workspace->buffer,
_("%s%s: (%d) failed to send me-message: %s"),
weechat_prefix("error"), SLACK_PLUGIN_NAME, request->idx,
json_object_get_string(error));
}
json_object_put(response);
free(json_string);
}
/* fallthrough */
case LWS_CALLBACK_CLOSED_CLIENT_HTTP:
request->client_wsi = NULL;
/* Does not doing this cause a leak?
lws_cancel_service(lws_get_context(wsi));*/ /* abort poll wait */
break;
default:
break;
}
return lws_callback_http_dummy(wsi, reason, user, in, len);
}
static const struct lws_protocols protocols[] = {
{
"http",
callback_http,
0,
0,
},
{ NULL, NULL, 0, 0 }
};
struct t_slack_request *slack_request_chat_memessage(
struct t_slack_workspace *workspace,
const char *token, const char *channel,
const char *text)
{
struct t_slack_request *request;
struct lws_context_creation_info ctxinfo;
struct lws_client_connect_info ccinfo;
request = slack_request_alloc(workspace);
size_t urilen = snprintf(NULL, 0, endpoint, token, channel, text) + 1;
request->uri = malloc(urilen);
snprintf(request->uri, urilen, endpoint, token, channel, text);
memset(&ctxinfo, 0, sizeof(ctxinfo)); /* otherwise uninitialized garbage */
ctxinfo.options = LWS_SERVER_OPTION_DO_SSL_GLOBAL_INIT;
ctxinfo.port = CONTEXT_PORT_NO_LISTEN; /* we do not run any server */
ctxinfo.protocols = protocols;
request->context = lws_create_context(&ctxinfo);
if (!request->context)
{
weechat_printf(
workspace->buffer,
_("%s%s: (%d) error connecting to slack: lws init failed"),
weechat_prefix("error"), SLACK_PLUGIN_NAME, request->idx);
return NULL;
}
else
{
weechat_printf(
workspace->buffer,
_("%s%s: (%d) contacting slack.com:443"),
weechat_prefix("network"), SLACK_PLUGIN_NAME, request->idx);
}
memset(&ccinfo, 0, sizeof(ccinfo)); /* otherwise uninitialized garbage */
ccinfo.context = request->context;
ccinfo.ssl_connection = LCCSCF_USE_SSL;
ccinfo.port = 443;
ccinfo.address = "slack.com";
ccinfo.path = request->uri;
ccinfo.host = ccinfo.address;
ccinfo.origin = ccinfo.address;
ccinfo.method = "GET";
ccinfo.protocol = protocols[0].name;
ccinfo.pwsi = &request->client_wsi;
ccinfo.userdata = request;
lws_client_connect_via_info(&ccinfo);
return request;
}

@ -0,0 +1,13 @@
// This Source Code Form is subject to the terms of the Mozilla Public
// License, version 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.
#ifndef _SLACK_REQUEST_CHAT_MEMESSAGE_H_
#define _SLACK_REQUEST_CHAT_MEMESSAGE_H_
struct t_slack_request *slack_request_chat_memessage(
struct t_slack_workspace *workspace,
const char *token, const char *channel,
const char *text);
#endif /*SLACK_REQUEST_CHAT_MEMESSAGE_H*/

@ -2,15 +2,20 @@
// License, version 2.0. If a copy of the MPL was not distributed with this // License, version 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/. // file, You can obtain one at http://mozilla.org/MPL/2.0/.
#include <libwebsockets.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#include "weechat-plugin.h" #include "weechat-plugin.h"
#include "slack.h" #include "slack.h"
#include "slack-command.h"
#include "slack-oauth.h" #include "slack-oauth.h"
#include "slack-teaminfo.h" #include "slack-teaminfo.h"
#include "slack-workspace.h" #include "slack-workspace.h"
#include "slack-channel.h"
#include "slack-buffer.h"
#include "slack-message.h"
#include "slack-command.h"
#include "request/slack-request-chat-memessage.h"
void slack_command_display_workspace(struct t_slack_workspace *workspace) void slack_command_display_workspace(struct t_slack_workspace *workspace)
{ {
@ -339,6 +344,68 @@ int slack_command_slack(const void *pointer, void *data,
return WEECHAT_RC_OK; return WEECHAT_RC_OK;
} }
int slack_command_me(const void *pointer, void *data,
struct t_gui_buffer *buffer, int argc,
char **argv, char **argv_eol)
{
struct t_slack_workspace *ptr_workspace = NULL;
struct t_slack_channel *ptr_channel = NULL;
struct t_slack_request *request;
char *text;
/* make C compiler happy */
(void) pointer;
(void) data;
(void) buffer;
(void) argv;
slack_buffer_get_workspace_and_channel(buffer, &ptr_workspace, &ptr_channel);
if (!ptr_workspace)
return WEECHAT_RC_ERROR;
if (!ptr_channel)
{
weechat_printf (
ptr_workspace->buffer,
_("%s%s: \"%s\" command can not be executed on a workspace buffer"),
weechat_prefix("error"), SLACK_PLUGIN_NAME, "me");
return WEECHAT_RC_OK;
}
if (!ptr_workspace->is_connected)
{
weechat_printf(buffer,
_("%s%s: you are not connected to server"),
weechat_prefix("error"), SLACK_PLUGIN_NAME);
return WEECHAT_RC_OK;
}
if (argc > 1)
{
text = malloc(SLACK_MESSAGE_MAX_LENGTH);
if (!text)
{
weechat_printf(buffer,
_("%s%s: error allocating string"),
weechat_prefix("error"), SLACK_PLUGIN_NAME);
return WEECHAT_RC_ERROR;
}
lws_urlencode(text, argv_eol[1], SLACK_MESSAGE_MAX_LENGTH);
request = slack_request_chat_memessage(ptr_workspace,
weechat_config_string(
ptr_workspace->options[SLACK_WORKSPACE_OPTION_TOKEN]),
ptr_channel->id, text);
if (request)
slack_workspace_register_request(ptr_workspace, request);
free(text);
}
return WEECHAT_RC_OK;
}
void slack_command_init() void slack_command_init()
{ {
weechat_hook_command( weechat_hook_command(
@ -357,4 +424,11 @@ void slack_command_init()
" || connect %(slack_workspace)" " || connect %(slack_workspace)"
" || delete %(slack_workspace)", " || delete %(slack_workspace)",
&slack_command_slack, NULL, NULL); &slack_command_slack, NULL, NULL);
weechat_hook_command(
"me",
N_("send a slack action to the current channel"),
N_("<message>"),
N_("message: message to send"),
NULL, &slack_command_me, NULL, NULL);
} }

Loading…
Cancel
Save