protected void OnForwardedNotificationCallback(Growl.Connector.Response response, Growl.Connector.CallbackData callbackData)
{
if (this.ForwardedNotificationCallback != null)
{
this.ForwardedNotificationCallback(response, callbackData);
}
}
private static void growl_notification_callback(Growl.Connector.Response response, Growl.Connector.CallbackData callbackData, object state)
{
if ((callbackData.Result == Growl.CoreLibrary.CallbackResult.CLICK) && callbackData.Type.Contains("Cannot hear anything"))
{
OnOperation(Operation.Show);
}
}
void growl_NotificationCallback(Growl.Connector.Response response, Growl.Connector.CallbackData callbackData)
{
CallbackData cd = new CallbackData(callbackData);
OnCallback(cd);
}
/// <summary>
/// Called when a notification that has been forwarded triggers a callback from the forwarded destination.
/// </summary>
/// <param name="response">The <see cref="Response"/> from the forwarded destination</param>
/// <param name="callbackData">The <see cref="CallbackData"/></param>
protected void OnForwardNotificationCallback(Response response, CallbackData callbackData)
{
if (this.ForwardedNotificationCallback != null)
{
this.ForwardedNotificationCallback(response, callbackData);
}
}
void growl_NotificationCallback(Response response, CallbackData callbackData, object state)
{
if (callbackData != null)
{
if (callbackData.Result == Growl.CoreLibrary.CallbackResult.CLICK)
{
string[] data = callbackData.Data.Split(CALLBACK_DATA_SEPARATOR.ToCharArray());
IntPtr hWnd = new IntPtr(Convert.ToInt32(data[0]));
uint msg = Convert.ToUInt32(data[1]);
IntPtr wparam = new IntPtr(Convert.ToInt32(data[2]));
IntPtr lparam = new IntPtr(Convert.ToInt32(data[3]));
Win32.SendMessage(hWnd, msg, wparam, lparam);
}
}
}
/// <summary>
/// Creates a new <see cref="SubscriptionResponse"/> from a base <see cref="Response"/> and a list of headers
/// </summary>
/// <param name="response">The base <see cref="Response"/></param>
/// <param name="headers">The <see cref="HeaderCollection"/> used to populate the response</param>
/// <returns><see cref="SubscriptionResponse"/></returns>
internal static SubscriptionResponse FromResponse(Response response, HeaderCollection headers)
{
SubscriptionResponse sr = null;
if (response.IsOK)
{
int ttl = headers.GetHeaderIntValue(Header.SUBSCRIPTION_TTL, true);
sr = new SubscriptionResponse(ttl);
}
else
{
sr = new SubscriptionResponse(response.ErrorCode, response.ErrorDescription);
sr.ttl = 0;
}
SetInhertiedAttributesFromHeaders(sr, headers);
return sr;
}
private void GrowlOKResponse(Response response, object state)
{
var requestState = state as GrowlRequestState;
if (requestState != null)
{
requestState.Update();
}
}
private void GrowlErrorResponse(Response response, object state)
{
var requestState = state as GrowlRequestState;
if (requestState != null)
{
requestState.Update(response.ErrorCode, response.ErrorDescription);
}
}
private static void ConnectorOnNotificationCallback(Response response, CallbackData callbackData, object state)
{
Process.Start(callbackData.Data);
}
private void growl_NotificationCallback(Response response, CallbackData callbackData, object state)
{
_isNotificationActive = false;
//string text = String.Format("Response Type: {0}\r\nNotification ID: {1}\r\nCallback Data: {2}\r\nCallback Data Type: {3}\r\n", callbackData.Result, callbackData.NotificationID, callbackData.Data, callbackData.Type);
//MessageBox.Show(text, "Callback received", MessageBoxButtons.OK, MessageBoxIcon.Information, MessageBoxDefaultButton.Button1);
}
/// <summary>
/// Creates a new <see cref="Response"/> from a list of headers
/// </summary>
/// <param name="headers">The <see cref="HeaderCollection"/> used to populate the response</param>
/// <returns><see cref="Response"/></returns>
public new static Response FromHeaders(HeaderCollection headers)
{
int errorCode = headers.GetHeaderIntValue(Header.ERROR_CODE, true);
string description = headers.GetHeaderStringValue(Header.ERROR_DESCRIPTION, false);
Response response = new Response(errorCode, description);
SetInhertiedAttributesFromHeaders(response, headers);
return response;
}
void growl_OKResponse(Response response, object state)
{
if (state != null) InvokeWrite(state.ToString());
InvokeWrite("OK - " + response.MachineName);
}
void growl_ErrorResponse(Response response, object state)
{
InvokeWrite("Error - " + response.ErrorCode + " : " + response.ErrorDescription);
}
Response server_RegisterReceived(Growl.Connector.Application application, List<NotificationType> notificationTypes, Growl.Connector.RequestInfo requestInfo)
{
if (requestInfo.PreviousReceivedHeaders.Count < 0) // change to a positive number to forward
{
Forwarder fwd = new Forwarder(password, "127.0.0.1", Growl.Connector.GrowlConnector.TCP_PORT, requestInfo);
fwd.EncryptionAlgorithm = Cryptography.SymmetricAlgorithmType.AES;
fwd.Register(application, notificationTypes.ToArray());
}
Response response = new Response();
return response;
}
Response server_NotifyReceived(Notification notification, Growl.Daemon.CallbackInfo callbackInfo, Growl.Connector.RequestInfo requestInfo)
{
Response response = new Response();
if (callbackInfo != null)
{
if (callbackInfo.ShouldKeepConnectionOpen())
{
response.SetCallbackData(notification.ID, callbackInfo.Context, Growl.CoreLibrary.CallbackResult.CLICK);
// simulate a wait
System.Threading.Thread.Sleep(5000);
}
else
{
string url = callbackInfo.Context.CallbackUrl;
server_ServerMessage(null, Growl.Daemon.GrowlServer.LogMessageType.Information, url);
}
}
//Console.WriteLine("notification response");
return response;
}
static void growl_Response(Response response, object state)
{
if (!silent)
{
if (response.IsOK)
{
r = 0;
Console.WriteLine("Notification sent successfully");
}
else
{
r = response.ErrorCode;
Console.WriteLine(String.Format("Notification failed: {0} - {1}", response.ErrorCode, response.ErrorDescription));
}
}
// signal that a response was received
ewh.Set();
}
void growl_NotificationCallback(Response response, CallbackData callbackContext, object state)
{
switch (callbackContext.Result)
{
case Growl.CoreLibrary.CallbackResult.CLICK:
if (callbackContext.Data == "OPEN_URL")
{
Notification notification = state as Notification;
string url = notification.CustomTextAttributes["url"];
if (url != null && url.Substring(0, 4) == "http")
{
Process.Start(url);
}
}
break;
case Growl.CoreLibrary.CallbackResult.CLOSE:
break;
case Growl.CoreLibrary.CallbackResult.TIMEDOUT:
break;
}
}
private static void growl_Response(Response response, object state)
{
if (!Program.silent)
{
if (response.IsOK)
{
Program.r = 0;
Console.WriteLine("Notification sent successfully");
}
else
{
Program.r = response.ErrorCode;
Console.WriteLine(string.Format("Notification failed: {0} - {1}", (object)response.ErrorCode, (object)response.ErrorDescription));
}
}
Program.ewh.Set();
}
void Forwarder_NotificationCallback(Response response, CallbackData callbackData, object state)
{
this.OnForwardedNotificationCallback(response, callbackData);
}
void growl_ErrorResponse(Response response)
{
Error error = new Error(response.ErrorCode, response.ErrorDescription);
OnError(error);
}
void growl_NotificationCallback(Response response, CallbackData callbackContext, object state)
{
string s = String.Format("CALLBACK RECEIVED: {0} - {1} - {2} - {3}", callbackContext.NotificationID, callbackContext.Data, callbackContext.Type, callbackContext.Result);
InvokeWrite(s);
}
void growl_OKResponse(Response response)
{
OnOK();
}
private static void GrowlNotificationCallback(Response response, CallbackData callbackdata)
{
SaveChangesToFile(String.Format("Response Type: {0}\r\nNotification ID: {1}\r\nCallback Data: {2}\r\nCallback Data Type: {3}\r\n", callbackdata.Result, callbackdata.NotificationID, callbackdata.Data, callbackdata.Type));
}
private void connector_ErrorResponse(Response response)
{
if (m_logger.IsInfoEnabled)
{
m_logger.InfoFormat("Notification response error: {0}/{1} {2}",
response.ErrorCode, response.ErrorDescription, response.InResponseTo);
}
if (m_lastNotification != null && (
response.ErrorCode == 401 || response.ErrorCode == 402 ) ) // Application and/or type not registered
{
// The Sql2Growl service is designed to loop forever :) so if someone deletes our registered
// applications and types we want to register them again.
m_lastNotification.ClearCachedObjects = true;
Notify(m_lastNotification);
}
}
/// <summary>
/// Parses a response message and returns the corresponding <see cref="Response"/> object
/// </summary>
/// <param name="message">The entire GNTP response message</param>
/// <param name="headers">The <see cref="HeaderCollection"/> of parsed header values</param>
/// <returns><see cref="Response"/></returns>
private Response Parse(string message, out HeaderCollection headers)
{
ResponseType responseType = ResponseType.ERROR;
Response response = null;
headers = new HeaderCollection();
byte[] bytes = System.Text.Encoding.UTF8.GetBytes(message);
System.IO.MemoryStream stream = new System.IO.MemoryStream(bytes);
using (stream)
{
GNTPStreamReader reader = new GNTPStreamReader(stream);
using (reader)
{
bool isError = false;
bool isFirstLine = true;
while (!reader.EndOfStream)
{
string line = reader.ReadLine();
if (isFirstLine)
{
Match match = ParseGNTPHeaderLine(line);
if (match.Success)
{
this.version = match.Groups["Version"].Value;
this.directive = match.Groups["Directive"].Value;
if (this.directive.StartsWith("-", StringComparison.InvariantCulture)) this.directive = this.directive.Remove(0, 1);
if (version == GNTP_SUPPORTED_VERSION)
{
if (Enum.IsDefined(typeof(ResponseType), this.directive))
{
responseType = (ResponseType)Enum.Parse(typeof(ResponseType), this.directive, false);
response = new Response();
if (responseType == ResponseType.ERROR) isError = true;
isFirstLine = false;
}
else
{
// invalid directive
response = new Response(ErrorCode.INVALID_REQUEST, "Unrecognized response type");
break;
}
}
else
{
// invalid version
response = new Response(ErrorCode.UNKNOWN_PROTOCOL_VERSION, "Unsupported version");
break;
}
}
else
{
// invalid message header
response = new Response(ErrorCode.UNKNOWN_PROTOCOL, "Unrecognized response");
break;
}
}
else
{
Header header = Header.ParseHeader(line);
headers.AddHeader(header);
}
}
if (response != null)
{
if (isError)
{
int errorCode = headers.GetHeaderIntValue(Header.ERROR_CODE, false);
string errorDescription = headers.GetHeaderStringValue(Header.ERROR_DESCRIPTION, false);
if (errorCode > 0 && errorDescription != null)
response = new Response(errorCode, errorDescription);
else
response = new Response(ErrorCode.INTERNAL_SERVER_ERROR, ErrorDescription.INTERNAL_SERVER_ERROR);
}
else
{
string inResponseTo = headers.GetHeaderStringValue(Header.RESPONSE_ACTION, false);
response.InResponseTo = inResponseTo;
}
response.SetAttributesFromHeaders(headers, (responseType == ResponseType.CALLBACK));
}
else
{
// if we got here, that is bad.
response = new Response(ErrorCode.INTERNAL_SERVER_ERROR, ErrorDescription.INTERNAL_SERVER_ERROR);
}
}
}
return response;
}
/// <summary>
/// Occurs when any of the following network conditions occur:
/// 1. Unable to connect to target host for any reason
/// 2. Write request fails
/// 3. Read request fails
/// </summary>
/// <param name="response">The <see cref="Response"/> that contains information about the failure</param>
/// <param name="state">An optional state object that will be passed into the response events associated with this request</param>
protected override void OnCommunicationFailure(Response response, object state)
{
SubscriptionResponse sr = SubscriptionResponse.FromResponse(response, null);
ResetTimerBasedOnResponse(sr);
this.OnErrorResponse(sr);
}
static void GrowlNotificationCallback(Response response, CallbackData callbackData)
{
//string text = String.Format("Response Type: {0}\r\nNotification ID: {1}\r\nCallback Data: {2}\r\nCallback Data Type: {3}\r\n", callbackData.Result, callbackData.NotificationID, callbackData.Data, callbackData.Type);
//MessageBox.Show(text, "Callback received", MessageBoxButtons.OK, MessageBoxIcon.Information, MessageBoxDefaultButton.Button1);
}
/*
/// <summary>
/// Gets the url-formatted callback data that is to be sent for url callbacks.
/// </summary>
/// <param name="result">The <see cref="CallbackResult"/> indicating the user action</param>
/// <returns>string - querystring/post format</returns>
public string GetUrlCallbackData(CallbackResult result)
{
string data = null;
if (this.Context != null)
{
UrlCallbackTarget target = this.Context.GetUrlCallbackTarget();
if (target != null)
{
data = String.Format("notification-id={0}¬ification-callback-result={1}¬ification-callback-context={2}¬ification-callback-context-type={3}", HttpUtility.UrlEncode(this.notificationID), HttpUtility.UrlEncode(result.ToString()), HttpUtility.UrlEncode(this.Context.Data), HttpUtility.UrlEncode(this.Context.Type));
}
}
return data;
}
* */
/// <summary>
/// Handles the callback from a forwarder.
/// </summary>
/// <param name="response">The <see cref="Response"/> from the forwarder</param>
/// <param name="callbackData">The <see cref="CallbackData"/></param>
public void HandleCallbackFromForwarder(Response response, CallbackData callbackData)
{
this.RequestInfo.SaveHandlingInfo(String.Format("Was responded to on {0} - Action: {1}", response.MachineName, callbackData.Result));
if (this.ForwardedNotificationCallback != null)
{
this.ForwardedNotificationCallback(response, callbackData, this);
}
}
