public static void PushMessageToSingle(string title, string content, string data, string cid)
{
IGtPush push = new IGtPush(HOST, APPKEY, MASTERSECRET);
//消息模版：TransmissionTemplate:透传模板
var template = NotificationTemplateDemo(title, content, data);
// 单推消息模型
SingleMessage message = new SingleMessage();
message.IsOffline = false; // 用户当前不在线时，是否离线存储,可选
message.OfflineExpireTime = 1000 * 3600 * 12; // 离线有效时间，单位为毫秒，可选
message.Data = template;
//判断是否客户端是否wifi环境下推送，2为4G/3G/2G，1为在WIFI环境下，0为不限制环境
message.PushNetWorkType = 0;
com.igetui.api.openservice.igetui.Target target = new com.igetui.api.openservice.igetui.Target();
target.appId = APPID;
target.clientId = cid;
//target.alias = ALIAS;
try
{
push.pushMessageToSingle(message, target);
}
catch (RequestException e)
{
String requestId = e.RequestId;
//发送失败后的重发
push.pushMessageToSingle(message, target, requestId);
}
}
//PushMessageToSingle接口测试代码
private static void PushMessageToSingle()
{
// 推送主类
IGtPush push = new IGtPush(HOST, APPKEY, MASTERSECRET);
//通知模版：支持TransmissionTemplate、LinkTemplate、NotificationTemplate，此处以TransmissionTemplate为例
TransmissionTemplate template = new TransmissionTemplate();
template.AppId = APPID; // 应用APPID
template.AppKey = APPKEY; // 应用APPKEY
template.TransmissionType = "1"; // 收到消息是否立即启动应用，1为立即启动，2则广播等待客户端自启动
template.TransmissionContent = "您需要透传的内容"; // 需要透传的内容
//iOS推送需要的pushInfo字段
//template.setPushInfo(actionLocKey, badge, message, sound, payload, locKey, locArgs, launchImage);
// 单推消息模型
SingleMessage message = new SingleMessage();
message.IsOffline = true; // 用户当前不在线时，是否离线存储,可选
message.OfflineExpireTime = 1000 * 3600 * 12; // 离线有效时间，单位为毫秒，可选
message.Data = template;
com.igetui.api.openservice.igetui.Target target = new com.igetui.api.openservice.igetui.Target();
target.appId = APPID;
target.clientId = CLIENTID;
String pushResult = push.pushMessageToSingle(message, target);
System.Console.WriteLine("-----------PushMessageToSingle--------------" + pushResult);
}
/// <summary>
/// PushMessageToSingle接口测试代码
/// </summary>
/// <param name="PaltForm">平台类型 1:苹果 2:安卓</param>
/// <param name="clientId"></param>
/// <param name="NoticeTitle">通知标题</param>
/// <param name="NoticeContent">通知内容</param>
/// <param name="custom_content">自定义内容</param>
/// <returns></returns>
public static string PushMessageToSingle(int PaltForm, string clientId, string NoticeTitle, string NoticeContent, string custom_content)
{
CLIENTID = clientId;
// 推送主类
IGtPush push = new IGtPush(HOST, APPKEY, MASTERSECRET);
/*消息模版：
* 1.TransmissionTemplate:透传模板
* 2.LinkTemplate:通知链接模板
* 3.NotificationTemplate：通知透传模板
* 4.NotyPopLoadTemplate：通知弹框下载模板
*/
//数据经SDK传给您的客户端，由您写代码决定如何处理展现给用户
//TransmissionTemplate template = TransmissionTemplateDemo(PaltForm, NoticeTitle, NoticeContent, custom_content);
//LinkTemplate template = LinkTemplateDemo(NoticeTitle, NoticeContent);
//NotyPopLoadTemplate template = NotyPopLoadTemplateDemo(NoticeTitle, NoticeContent);
//在通知栏显示一条含图标、标题等的通知，用户点击后激活您的应用
NotificationTemplate template = NotificationTemplateDemo(PaltForm, NoticeTitle, NoticeContent, custom_content);
SingleMessage message = new SingleMessage();
message.IsOffline = false; // 用户当前不在线时，是否离线存储,可选
message.OfflineExpireTime = 1000 * 3600 * 12; // 离线有效时间，单位为毫秒，可选
message.Data = template;
com.igetui.api.openservice.igetui.Target target = new com.igetui.api.openservice.igetui.Target();
target.appId = APPID;
target.clientId = CLIENTID;
String pushResult = push.pushMessageToSingle(message, target);
return(pushResult);
}
public static string GeTuiMsg(string msgTitle, string msgBody, string appid, string appkey, string mastersecret, string clientId, DateTime?msgPostTime)
{
var HOST = "http://sdk.open.api.igexin.com/apiex.htm";
var push = new IGtPush(HOST, appkey, mastersecret);
// 定义"AppMessage"类型消息对象，设置消息内容模板、发送的目标App列表、是否支持离线发送、以及离线消息有效期(单位毫秒)
var batch = new BatchImpl(appkey, push);
//var message = new AppMessage();
var message = new SingleMessage();
//var template = NotificationTemplateDemo(msgTitle, msgBody, appid, appkey, msgPostTime);
var template = TransmissionContent(msgTitle, msgBody, appid, appkey);
message.IsOffline = true; // 用户当前不在线时，是否离线存储,可选
message.OfflineExpireTime = 1000 * 3600 * 12; // 离线有效时间，单位为毫秒，可选
message.Data = template;
message.PushNetWorkType = 0;
var targetTrans = new Target
{
appId = appid,
clientId = clientId
};
batch.add(message, targetTrans);
try
{
return(batch.submit());
}
catch
{
return(batch.retry());
}
}
public string pushAPNMessageToSingle(string appId, string deviceToken, SingleMessage message)
{
if (deviceToken == null || deviceToken.Length != 64)
{
throw new Exception("deviceToken " + deviceToken + " length must be 64");
}
return(httpPostJSON(new Dictionary <string, object>
{
{
"action",
"apnPushToSingleAction"
},
{
nameof(appId),
appId
},
{
"appkey",
appKey
},
{
"DT",
deviceToken
},
{
"PI",
Convert.ToBase64String(message.Data.getPushInfo().ToByteArray())
}
}));
}
public override string Push()
{
string pushResult;
var message = new SingleMessage
{
Data = GeTui.ToTemplate(PhoneType, TemplateType),
IsOffline = true, // 用户当前不在线时，是否离线存储,可选
OfflineExpireTime = 1000 * 3600 * 12, // 离线有效时间，单位为毫秒，可选
PushNetWorkType = 0 //判断是否客户端是否wifi环境下推送，1为在WIFI环境下，0为不限制网络环境。
};
var target = new Target
{
appId = ConfigSettings.AppId,
clientId = GeTui.ClientId
};
try
{
pushResult = pushMessageToSingle(message, target);
}
catch (RequestException ex)
{
var requestId = ex.RequestId;
pushResult = pushMessageToSingle(message, target, requestId);//发送失败后的重发
}
return(pushResult);
}
private static string HOST = "http://sdk.open.api.igexin.com/apiex.htm"; //HOST：OpenService接口地址
//PushMessageToSingle接口测试代码
public static string PushMessageToSingle(string cid, string title, string messageText)
{
// 推送主类
IGtPush push = new IGtPush(HOST, APPKEY, MASTERSECRET);
/*消息模版：
* 1.TransmissionTemplate:透传模板
* 2.LinkTemplate:通知链接模板
* 3.NotificationTemplate：通知透传模板
* 4.NotyPopLoadTemplate：通知弹框下载模板
*/
//TransmissionTemplate template = TransmissionTemplateDemo();
NotificationTemplate template = NotificationTemplateDemo(title, messageText);
//LinkTemplate template = LinkTemplateDemo();
//NotyPopLoadTemplate template = NotyPopLoadTemplateDemo();
// 单推消息模型
SingleMessage message = new SingleMessage();
message.IsOffline = false; // 用户当前不在线时，是否离线存储,可选
message.OfflineExpireTime = 1000 * 3600 * 12; // 离线有效时间，单位为毫秒，可选
message.Data = template;
com.igetui.api.openservice.igetui.Target target = new com.igetui.api.openservice.igetui.Target();
target.appId = APPID;
target.clientId = cid;
string pushResult = push.pushMessageToSingle(message, target);
return(pushResult);
}
//private static String DeviceToken = ""; //填写IOS系统的DeviceToken
/// <summary>
/// 单个消息推送
/// </summary>
/// <param name="TransmissionType">应用启动类型，1：强制应用启动 2：等待应用启动</param>
/// <param name="TransmissionContent">透传内容</param>
/// <param name="beginTime">设置通知定时展示时间，结束时间与开始时间相差需大于6分钟，消息推送后，客户端将在指定时间差内展示消息（误差6分钟）</param>
/// <param name="endTime">设置通知定时展示时间，结束时间与开始时间相差需大于6分钟，消息推送后，客户端将在指定时间差内展示消息（误差6分钟）</param>
/// <param name="CLIENTID">个推clientId</param>
public static void PushMessageToSingle(string TransmissionType, string TransmissionTitle, string TransmissionContent, string beginTime, string endTime, string CLIENTID)
{
IGtPush push = new IGtPush(HOST, APPKEY, MASTERSECRET);
//消息模版：TransmissionTemplate:透传模板
TransmissionTemplate template = TransmissionTemplate(TransmissionType, TransmissionTitle, TransmissionContent, beginTime, endTime);
// 单推消息模型
SingleMessage message = new SingleMessage();
message.IsOffline = true; // 用户当前不在线时，是否离线存储,可选
message.OfflineExpireTime = 1000 * 3600 * 12; // 离线有效时间，单位为毫秒，可选
message.Data = template;
//判断是否客户端是否wifi环境下推送，2为4G/3G/2G，1为在WIFI环境下，0为不限制环境
//message.PushNetWorkType = 1;
com.igetui.api.openservice.igetui.Target target = new com.igetui.api.openservice.igetui.Target();
target.appId = APPID;
target.clientId = CLIENTID;
//target.alias = ALIAS;
try
{
String pushResult = push.pushMessageToSingle(message, target);
}
catch (RequestException e)
{
String requestId = e.RequestId;
//发送失败后的重发
String pushResult = push.pushMessageToSingle(message, target, requestId);
}
}
public override string Push()
{
var message = new SingleMessage
{
Data = GeTui.ToTemplate(PhoneType, TemplateType),
IsOffline = true, // 用户当前不在线时，是否离线存储,可选
OfflineExpireTime = 1000 * 3600 * 12, // 离线有效时间，单位为毫秒，可选
PushNetWorkType = 0 //判断是否客户端是否wifi环境下推送，1为在WIFI环境下，0为不限制网络环境。
};
var batch = new BatchImpl(ConfigSettings.AppKey, this);
foreach (var cid in GeTui.ClientId.Split(','))
{
var target = new Target
{
appId = ConfigSettings.AppId,
clientId = cid
};
batch.add(message, target);
}
try
{
return(batch.submit());
}
catch (Exception)
{
return(batch.retry());
}
}
/// <summary>
/// ios个推离线通知
/// </summary>
/// <param name="title"></param>
/// <param name="content"></param>
/// <param name="token"></param>
/// <param name="data"></param>
/// <returns></returns>
public static string APNsPushToSingle(string title, string content, string token, object data)
{
APNTemplate template = new APNTemplate();
APNPayload apnpayload = new APNPayload();
DictionaryAlertMsg alertMsg = new DictionaryAlertMsg();
alertMsg.Body = content; //通知文本消息字符串
alertMsg.ActionLocKey = "";
alertMsg.LocKey = "";
alertMsg.addLocArg("");
alertMsg.LaunchImage = ""; //指定启动界面图片名
//IOS8.2支持字段
alertMsg.Title = title; //通知标题
alertMsg.TitleLocKey = "";
alertMsg.addTitleLocArg("");
apnpayload.AlertMsg = alertMsg;
//apnpayload.Badge = 1;//应用icon上显示的数字
apnpayload.ContentAvailable = 1; //推送直接带有透传数据
apnpayload.Category = "";
apnpayload.Sound = ""; //通知铃声文件名
apnpayload.addCustomMsg("data", data); //增加自定义的数据
template.setAPNInfo(apnpayload);
IGtPush push = new IGtPush(HOST, APPKEY, MASTERSECRET);
/*单个用户推送接口*/
SingleMessage Singlemessage = new SingleMessage();
Singlemessage.Data = template;
String pushResult = push.pushAPNMessageToSingle(APPID, token, Singlemessage);
Console.Out.WriteLine(pushResult);
return(pushResult);
}
//pushMessageToSingle接口测试代码
public String pushMessageToSingle(SingleMessage message, com.igetui.api.openservice.igetui.Target target)
{
Dictionary <string, object> param = new Dictionary <string, object>();
/*---以下代码用于设定接口相应参数---*/
param.Add("action", "pushMessageToSingleAction");
param.Add("appkey", appKey);
param.Add("appId", target.appId);
this.appId = target.appId;
param.Add("clientId", target.clientId);
//param.Add("time", "2012-12-31 12:24:23"); //当前请求时间，可选
//param.Add("expire", 3600); //消息超时时间，单位为秒，可选
param.Add("isOffline", message.IsOffline); //是否离线
param.Add("offlineExpireTime", message.OfflineExpireTime); //离线有效时间，单位为毫秒
param.Add("transmissionContent", message.Data.getTransmissionContent()); //您需要透传的内容
param.Add("type", 2); //默认都为消息
param.Add("pushType", message.Data.getPushType()); //TransmissionMsg, LinkMsg, NotifyMsg
//Transparent.Builder builder = getTransparentBuilder();
param.Add("clientData", Convert.ToBase64String(message.Data.getTransparent().ToByteArray()));
// post数据
String Result = httpPostJSON(param);
System.Console.WriteLine("--------pushMessageToSingle result------------" + Result);
return(Result);
}
public string add(SingleMessage message, Target target)
{
if (seqId >= 5000)
{
throw new Exception("Can not add over 5000 message once! Please call submit() first.");
}
innerMsgList.Add(SingleBatchItem.CreateBuilder().SetSeqId(seqId).SetData(createPostParams(message, target))
.Build());
++seqId;
return(string.Concat(seqId));
}
//PushMessageToSingle接口测试代码
//public static void PushMessageToSingle()
//{
// // 推送主类
// IGtPush push = new IGtPush(HOST, APPKEY, MASTERSECRET);
// /*消息模版：
// 1.TransmissionTemplate:透传模板
// 2.LinkTemplate:通知链接模板
// 3.NotificationTemplate：通知透传模板
// 4.NotyPopLoadTemplate：通知弹框下载模板
// */
// TransmissionTemplate template = TransmissionTemplateDemo();
// //NotificationTemplate template = NotificationTemplateDemo();
// //LinkTemplate template = LinkTemplateDemo();
// //NotyPopLoadTemplate template = NotyPopLoadTemplateDemo();
// // 单推消息模型
// SingleMessage message = new SingleMessage();
// message.IsOffline = true; // 用户当前不在线时，是否离线存储,可选
// message.OfflineExpireTime = 1000 * 3600 * 12; // 离线有效时间，单位为毫秒，可选
// message.Data = template;
// //message.PushNetWorkType = 1; //判断是否客户端是否wifi环境下推送，1为在WIFI环境下，0为非WIFI环境
// com.igetui.api.openservice.igetui.Target target = new com.igetui.api.openservice.igetui.Target();
// target.appId = APPID;
// target.clientId = CLIENTID;
// //target.alias = ALIAS;
// try
// {
// String pushResult = push.pushMessageToSingle(message, target);
// System.Console.WriteLine("-----------------------------------------------");
// System.Console.WriteLine("-----------------------------------------------");
// System.Console.WriteLine("----------------服务端返回结果：" + pushResult);
// }
// catch (RequestException e)
// {
// String requestId = e.RequestId;
// String pushResult = push.pushMessageToSingle(message, target, requestId);
// System.Console.WriteLine("-----------------------------------------------");
// System.Console.WriteLine("-----------------------------------------------");
// System.Console.WriteLine("----------------服务端返回结果：" + pushResult);
// }
//}
public static void PushMessageToSingleBatch()
{
// 推送主类
IGtPush push = new IGtPush(HOST, APPKEY, MASTERSECRET);
IBatch Batch = push.getBatch();
/*消息模版：
* 1.TransmissionTemplate:透传模板
* 2.LinkTemplate:通知链接模板
* 3.NotificationTemplate：通知透传模板
* 4.NotyPopLoadTemplate：通知弹框下载模板
*/
//TransmissionTemplate template = TransmissionTemplateDemo();
NotificationTemplate template = NotificationTemplateDemo();
template.Title = "程序推送";
template.Text = "这是推送的内容";
//LinkTemplate template = LinkTemplateDemo();
//NotyPopLoadTemplate template = NotyPopLoadTemplateDemo();
// 单推消息模型
SingleMessage message = new SingleMessage();
message.IsOffline = true; // 用户当前不在线时，是否离线存储,可选
message.OfflineExpireTime = 1000 * 3600 * 12; // 离线有效时间，单位为毫秒，可选
message.Data = template;
//message.PushNetWorkType = 1; //判断是否客户端是否wifi环境下推送，1为在WIFI环境下，0为非WIFI环境
com.igetui.api.openservice.igetui.Target target = new com.igetui.api.openservice.igetui.Target();
target.appId = APPID;
target.clientId = CLIENTID;
Batch.add(message, target);
try
{
String pushResult = Batch.submit();
System.Console.WriteLine("-----------------------------------------------");
System.Console.WriteLine("-----------------------------------------------");
System.Console.WriteLine("----------------服务端返回结果：" + pushResult);
}
catch (Exception e)
{
String pushResult = Batch.retry();
System.Console.WriteLine("-----------------------------------------------");
System.Console.WriteLine("-----------------------------------------------");
System.Console.WriteLine("----------------服务端返回结果：" + pushResult);
}
}
public string sendMessageFromDistribution(Stream s)
{
StreamReader reader = new StreamReader(s);
string requestRetrunReasonString = reader.ReadToEnd();
SingleMessage request = JsonConvert.DeserializeObject <SingleMessage>(requestRetrunReasonString);
Distribution distribution = new Distribution();
string result = distribution.sendMessageFromDistribution(request);
return(result);
}
/// <summary>
/// This example uses the Grpc operations on the stats service client. The Grpc methods allow specifying
/// Grpc Headers and are tightly coupled with the Grpc interfaces.
/// </summary>
private static async Task GrpcOperations(EchoService.EchoServiceClient client)
{
// Unary operation
{
SingleMessage unaryResponse = await client.EchoUnary(new SingleMessage { Message = "hi there" }, default);
Console.WriteLine($"EchoUnary: {unaryResponse.Message}");
}
// Client streaming
{
AsyncClientStreamingCall <SingleMessage, MultiMessage> call = client.EchoClientStreaming(default);
/// <summary>
/// 2 群组动态
/// </summary>
/// <param name="deviceid"></param>
/// <param name="msg"></param>
/// <returns></returns>
public static async Task PushGroupDynamic(string deviceid, string touid, string msg)
{
var currentMethod = "PushGroupDynamic";
var title = "群组动态通知";
var content = "新的群组动态";
var model = JsonConvert.DeserializeObject <AppGroupDynamic>(msg);
title = model.GroupName;
IGtPush push = new IGtPush(HOST, APPKEY, MASTERSECRET);
//消息模版：TransmissionTemplate:透传模板
var intent = $"intent:#Intent;component=net.cnki.okms/.pages.base.BootActivity;end";
var getui = new GeTuiMessage
{
mtype = 2,
mcontent = model,
};
TransmissionTemplate template = TransmissionTemplate(title, content, intent, JsonConvert.SerializeObject(getui));
// 单推消息模型
SingleMessage message = new SingleMessage();
message.IsOffline = true; // 用户当前不在线时，是否离线存储,可选
message.OfflineExpireTime = 1000 * 3600 * 12; // 离线有效时间，单位为毫秒，可选
message.Data = template;
com.igetui.api.openservice.igetui.Target target = new com.igetui.api.openservice.igetui.Target();
target.appId = APPID;
target.clientId = deviceid;
var messageJson = JsonConvert.SerializeObject(message);
LoggerHelper.AndroidPush($"1.个推-群组动态类消息[{touid}]推送的消息内容为：{Environment.NewLine}{messageJson}");
try
{
String pushResult = push.pushMessageToSingle(message, target);
LoggerHelper.AndroidPush($"2.个推-群组动态类消息[{touid}]推送的返回结果：{Environment.NewLine}{pushResult}");
}
catch (RequestException e)
{
String requestId = e.RequestId;
//发送失败后的重发
String pushResult = push.pushMessageToSingle(message, target, requestId);
LoggerHelper.AndroidPush($"3.个推-群组动态类消息[{touid}]发生了异常，重发后，服务端返回结果：----------------" + pushResult);
}
}
// Token: 0x060004A6 RID: 1190 RVA: 0x00009978 File Offset: 0x00007B78
public string add(SingleMessage message, igetui.Target target)
{
if (seqId >= 5000)
{
throw new Exception("Can not add over 5000 message once! Please call submit() first.");
}
string data = createPostParams(message, target);
SingleBatchItem item = SingleBatchItem.CreateBuilder().SetSeqId(seqId).SetData(data).Build();
innerMsgList.Add(item);
seqId++;
return(string.Concat(seqId) ?? "");
}
// Token: 0x060004A7 RID: 1191 RVA: 0x000099F8 File Offset: 0x00007BF8
public string createPostParams(SingleMessage message, igetui.Target target)
{
return(JsonConvert.SerializeObject(new Dictionary <string, object>
{
{
"action",
"pushMessageToSingleAction"
},
{
"appkey",
APPKEY
},
{
"clientData",
Convert.ToBase64String(message.Data.getTransparent().ToByteArray())
},
{
"transmissionContent",
message.Data.getTransmissionContent()
},
{
"isOffline",
message.IsOffline
},
{
"offlineExpireTime",
message.OfflineExpireTime
},
{
"appId",
target.appId
},
{
"clientId",
target.clientId
},
{
"type",
2
},
{
"pushType",
message.Data.getPushType()
},
{
"version",
"3.0.0.0"
}
}));
}
/// <summary>
/// 推送单个用户
/// </summary>
/// <param name="template">模板内容</param>
public string PushSingle(ITemplate template)
{
IGtPush push = new IGtPush("", APPKEY, MASTERSECRET);
SingleMessage message = new SingleMessage();
message.IsOffline = true; // 用户当前不在线时，是否离线存储,可选
message.OfflineExpireTime = 1000 * 3600 * 12; // 离线有效时间，单位为毫秒，可选
message.Data = template;
//message.PushNetWorkType = 1; //判断是否客户端是否wifi环境下推送，1为在WIFI环境下，0为非WIFI环境
Target target = new Target();
target.appId = APPID;
target.clientId = CLIENTID[0];
return(push.pushMessageToSingle(message, target));
}
public void TestVec4()
{
var r = new DefaultSerializer<SingleMessage<Vector4>>(this.messageRegistry, this.typeRegistry,4);
using (var buf = new ThreadSafeWriteQueue(1024))
{
var orig = new SingleMessage<Vector4> { MessageId = r.MessageId, A = new Vector4(1.1f, 2.2f, 3.3f,( 4.4f)) };
r.Serialize(buf, orig);
SingleMessage<Vector4> message = new SingleMessage<Vector4>();
r.Deserialize(buf, buf.ReadMessage(), message);
Assert.AreEqual(orig.MessageId, message.MessageId);
Assert.AreEqual(orig.A, message.A);
}
}
public string createPostParams(SingleMessage message, com.igetui.api.openservice.igetui.Target target)
{
Dictionary <string, object> dictionary = new Dictionary <string, object>();
dictionary.Add("action", "pushMessageToSingleAction");
dictionary.Add("appkey", this.APPKEY);
dictionary.Add("clientData", Convert.ToBase64String(message.Data.getTransparent().ToByteArray()));
dictionary.Add("transmissionContent", message.Data.getTransmissionContent());
dictionary.Add("isOffline", message.IsOffline);
dictionary.Add("offlineExpireTime", message.OfflineExpireTime);
dictionary.Add("appId", target.appId);
dictionary.Add("clientId", target.clientId);
dictionary.Add("type", 2);
dictionary.Add("pushType", message.Data.getPushType());
dictionary.Add("version", "3.0.0.0");
return(JsonConvert.SerializeObject(dictionary));
}
/// <summary>
/// Get messageHistory of specific chat
/// </summary>
/// <param name="token"></param>
/// <param name="jobject"></param>
/// <returns></returns>
public object GetMessageHistory(string token, JObject jobject)
{
long chatId;
try
{
chatId = jobject.ToObject <ChatIdParam>().ChatId;
if (chatId == 0)
{
throw new Exception();
}
}
catch (Exception e)
{
_response.Status = 40003;
_response.Result = "Invalid params. long ChatId is needed";
return(_response);
}
string userName = _validator.GetUserName(token);
if (_validator.CheckUser(userName))
{
MessageList messageList = new MessageList();
foreach (var message in _repository.GetMessageHistory(chatId))
{
SingleMessage singleMessage = new SingleMessage();
singleMessage.Id = message.Id;
singleMessage.ChatId = message.ChatId;
singleMessage.UserName = message.UserName;
singleMessage.Time = message.Time;
singleMessage.Text = message.Text;
messageList.Messages.Add(singleMessage);
}
_response.Status = 20000;
_response.Result = messageList;
}
else
{
_response.Status = 40002;
_response.Result = "Validation failed!!!";
}
return(_response);
}
public IActionResult Post([FromBody] SingleMessage message, [FromServices] SMSArbiter arbiter)
{
try
{
if (message.Body.MessageId == Guid.Empty)
{
Guid messageId = Guid.NewGuid();
message.Body.MessageId = messageId;
}
arbiter.StorePendingMessage(message);
arbiter._queue.Post(message);
return(Ok(message.Body.MessageId));
}
catch
{
return(StatusCode(StatusCodes.Status500InternalServerError));
}
}
//PushMessageToSingle接口测试代码
private static string PushMessageToSingle(string strAdvice, string clientID)
{
// 推送主类
IGtPush push = new IGtPush(HOST, APPKEY, MASTERSECRET);
// LinkTemplate template = LinkTemplateDemo(strAdvice);
NotificationTemplate notificationTemplate = NotificationTemplateDemo(strAdvice);
SingleMessage message = new SingleMessage();
// 用户当前不在线时，是否离线存储,可选
message.IsOffline = false;
// 离线有效时间，单位为毫秒，可选
message.OfflineExpireTime = 1000 * 3600 * 12;
message.Data = notificationTemplate;
com.igetui.api.openservice.igetui.Target target = new com.igetui.api.openservice.igetui.Target();
target.appId = APPID;
target.clientId = clientID;
String pushResult = push.pushMessageToSingle(message, target);
return pushResult;
}
private static bool PushMsgToSingleDevice(string clientid, ITemplate msgTemplate)
{
bool result = false;
try
{
IGtPush gtPush = new IGtPush(Push.HOST, Push.APPKEY, Push.MASTERSECRET);
IBatch batch = gtPush.getBatch();
SingleMessage singleMessage = new SingleMessage();
singleMessage.IsOffline = true;
singleMessage.OfflineExpireTime = 2073600000L;
singleMessage.Data = msgTemplate;
Target target = new Target();
target.appId = Push.APPID;
target.clientId = clientid;
batch.add(singleMessage, target);
try
{
Push.errorMsg = batch.submit();
JsonData jsonData = MyCommon.JsonStrToObj(Push.errorMsg);
string jsonObjValue = MyCommon.getJsonObjValue(jsonData, "result");
if (jsonObjValue.ToLower() == "ok")
{
result = true;
}
}
catch (Exception ex)
{
Push.errorMsg = batch.retry();
JsonData jsonData2 = MyCommon.JsonStrToObj(Push.errorMsg);
string jsonObjValue2 = MyCommon.getJsonObjValue(jsonData2, "result");
if (jsonObjValue2.ToLower() == "ok")
{
result = true;
}
Push.errorMsg += ex.Message;
}
}
catch (Exception ex2)
{
Push.errorMsg += ex2.Message;
}
return(result);
}
/// <summary>
/// 18.个推-工作交办 todolist（群组日程、待办）消息通知（刘静杰）
/// </summary>
/// <param name="deviceid"></param>
/// <param name="touid"></param>
/// <param name="msg"></param>
/// <returns></returns>
public static async Task PushToDoMessage(string deviceid, string touid, ScheduleModel msg)
{
var currentMethod = "PushToDoMessage";
IGtPush push = new IGtPush(HOST, APPKEY, MASTERSECRET);
var intent = $"intent:#Intent;component=net.cnki.okms/.pages.base.BootActivity;end";
var title = "待办任务";
var content = msg.title;
var getui = new GeTuiMessage
{
mtype = 18,
mcontent = msg,
};
TransmissionTemplate template = TransmissionTemplate(title, content, intent, JsonConvert.SerializeObject(getui));
// 单推消息模型
SingleMessage message = new SingleMessage();
message.IsOffline = true; // 用户当前不在线时，是否离线存储,可选
message.OfflineExpireTime = 1000 * 3600 * 12; // 离线有效时间，单位为毫秒，可选
message.Data = template;
com.igetui.api.openservice.igetui.Target target = new com.igetui.api.openservice.igetui.Target();
target.appId = APPID;
target.clientId = deviceid;
var messageJson = JsonConvert.SerializeObject(message);
LoggerHelper.AndroidPush($"1.(个推-待办任务)给[{touid}]推送的内容：" + messageJson);
try
{
String pushResult = push.pushMessageToSingle(message, target);
LoggerHelper.AndroidPush($"2.(个推-待办任务)给[{touid}]返回结果：" + pushResult);
}
catch (RequestException e)
{
String requestId = e.RequestId;
//发送失败后的重发
String pushResult = push.pushMessageToSingle(message, target, requestId);
LoggerHelper.AndroidPush($"3.(个推-待办任务)给[{touid}]发生了异常，重发后，服务端返回结果：----------------" + pushResult);
}
}
public async Task <ActionResult> Create(MessageCreateViewModel messageVM)
{
if (ModelState.IsValid)
{
var message = new SingleMessage {
id = db.SingleMessages.Count(), MessageText = messageVM.MessageText, TimeOfMessage = DateTime.Now
};
var userId = User.Identity.GetUserId();
var messageBoard = new MessageBoard {
MessageID = db.MessageBoards.Count(), SingleMessage = message, RecieverID = messageVM.RecieverID, SenderID = userId, ProfileLinkerID = messageVM.LinkerId
};
db.MessageBoards.Add(messageBoard);
await db.SaveChangesAsync();
return(RedirectToAction("MessagesForUser", "MessageBoards", new { id = messageVM.RecieverID }));
}
return(View());
}
/// <summary>
/// 给单个用户发送推送(DEMO)
/// </summary>
private static void PushMessageToSingle()
{
IGtPush push = new IGtPush(HOST, APPKEY, MASTERSECRET);
TransmissionTemplate template = TransmissionTemplateDemo();
template.TransmissionContent = "测试";
// 单推消息模型
SingleMessage message = new SingleMessage();
message.IsOffline = true; // 用户当前不在线时，是否离线存储,可选
message.OfflineExpireTime = 1000 * 3600 * 12; // 离线有效时间，单位为毫秒，可选
message.Data = template;
message.PushNetWorkType = 0; //判断是否客户端是否wifi环境下推送，1为在WIFI环境下，0为非WIFI环境
com.igetui.api.openservice.igetui.Target target = new com.igetui.api.openservice.igetui.Target();
target.appId = APPID;
target.clientId = CLIENTID;
String pushResult = push.pushMessageToSingle(message, target);
}
static void apnPush(int PaltForm, string clientId, string NoticeTitle, string NoticeContent, string custom_content)
{
//APN高级推送
IGtPush push = new IGtPush(HOST, APPKEY, MASTERSECRET);
APNTemplate template = new APNTemplate();
APNPayload apnpayload = new APNPayload();
DictionaryAlertMsg alertMsg = new DictionaryAlertMsg();
alertMsg.Body = NoticeContent;
alertMsg.ActionLocKey = "";
alertMsg.LocKey = "";
alertMsg.addLocArg("");
alertMsg.LaunchImage = "";
//IOS8.2支持字段
alertMsg.Title = NoticeTitle;
alertMsg.TitleLocKey = "";
alertMsg.addTitleLocArg("");
apnpayload.AlertMsg = alertMsg;
apnpayload.Badge = 10;
apnpayload.ContentAvailable = 1;
apnpayload.Category = "";
apnpayload.Sound = "";
apnpayload.addCustomMsg("", "");
template.setAPNInfo(apnpayload);
/*单个用户推送接口*/
SingleMessage Singlemessage = new SingleMessage();
Singlemessage.Data = template;
String pushResult = push.pushAPNMessageToSingle(APPID, DeviceToken, Singlemessage);
/*多个用户推送接口*/
//ListMessage listmessage = new ListMessage();
//listmessage.Data = template;
//String contentId = push.getAPNContentId(APPID, listmessage);
////Console.Out.WriteLine(contentId);
//List<String> devicetokenlist = new List<string>();
//devicetokenlist.Add(DeviceToken);
//String ret = push.pushAPNMessageToList(APPID, contentId, devicetokenlist);
//Console.Out.WriteLine(ret);
}
public SendAppMessageResultModel SendAppMessage(SendAppContentModel sendAppMessageModel)
{
IGtPush push = new IGtPush(Host, Appkey, Mastersecret);
Target target = new Target();
target.appId = Appid;
target.clientId = sendAppMessageModel.ClientId;
ITemplate template = null;
if (sendAppMessageModel.ClientType == "A")
{
//template = NotificationTemplateDemo(sendAppMessageModel.Title, sendAppMessageModel.Text,
// sendAppMessageModel.Content);
template = TransmissionTemplateDemo(sendAppMessageModel.Title, sendAppMessageModel.Text,
sendAppMessageModel.Content);
}
else
{
template = TransmissionTemplateIOS(sendAppMessageModel.Title, sendAppMessageModel.Content,
sendAppMessageModel.Text);
}
// 单推消息模型
SingleMessage message = new SingleMessage();
message.IsOffline = true; // 用户当前不在线时，是否离线存储,可选
message.OfflineExpireTime = 1000 * 3600 * 12; // 离线有效时间，单位为毫秒，可选
message.Data = template;
//判断是否客户端是否wifi环境下推送，2为4G/3G/2G，1为在WIFI环境下，0为不限制环境
//message.PushNetWorkType = 1;
string pushResult = push.pushMessageToSingle(message, target);
SendAppMessageResultModel result = JsonConvert.DeserializeObject <SendAppMessageResultModel>(pushResult);
result.ResultInfo = pushResult;
return(result);
}
public void PushMessageToSingle()
{
IGtPush push = new IGtPush(HOST, APPKEY, MASTERSECRET);
//消息模版：TransmissionTemplate:透传模板
NotificationTemplate template = NotificationTemplateDemo();
// 单推消息模型
SingleMessage message = new SingleMessage();
message.IsOffline = true; // 用户当前不在线时，是否离线存储,可选
message.OfflineExpireTime = 1000 * 3600 * 12; // 离线有效时间，单位为毫秒，可选
message.Data = template;
//判断是否客户端是否wifi环境下推送，2为4G/3G/2G，1为在WIFI环境下，0为不限制环境
//message.PushNetWorkType = 1;
com.igetui.api.openservice.igetui.Target target = new com.igetui.api.openservice.igetui.Target();
target.appId = APPID;
target.clientId = CLIENTID;
//target.alias = ALIAS;
try
{
String pushResult = push.pushMessageToSingle(message, target);
System.Console.WriteLine("-----------------------------------------------");
System.Console.WriteLine("-----------------------------------------------");
System.Console.WriteLine("----------------服务端返回结果：" + pushResult);
}
catch (RequestException e)
{
String requestId = e.RequestId;
//发送失败后的重发
String pushResult = push.pushMessageToSingle(message, target, requestId);
System.Console.WriteLine("-----------------------------------------------");
System.Console.WriteLine("-----------------------------------------------");
System.Console.WriteLine("----------------服务端返回结果：" + pushResult);
}
}
//pushMessageToSingle接口测试代码
public String pushMessageToSingle(SingleMessage message, com.igetui.api.openservice.igetui.Target target)
{
Dictionary<string, object> param = new Dictionary<string, object>();
/*---以下代码用于设定接口相应参数---*/
param.Add("action", "pushMessageToSingleAction");
param.Add("appkey", appKey);
param.Add("appId", target.appId);
this.appId = target.appId;
param.Add("clientId", target.clientId);
//param.Add("time", "2012-12-31 12:24:23"); //当前请求时间，可选
//param.Add("expire", 3600); //消息超时时间，单位为秒，可选
param.Add("isOffline", message.IsOffline); //是否离线
param.Add("offlineExpireTime", message.OfflineExpireTime); //离线有效时间，单位为毫秒
param.Add("transmissionContent", message.Data.getTransmissionContent()); //您需要透传的内容
param.Add("type", 2); //默认都为消息
param.Add("pushType", message.Data.getPushType()); //TransmissionMsg, LinkMsg, NotifyMsg
//Transparent.Builder builder = getTransparentBuilder();
param.Add("clientData", Convert.ToBase64String(message.Data.getTransparent().ToByteArray()));
// post数据
String Result = httpPostJSON(param);
System.Console.WriteLine("--------pushMessageToSingle result------------" + Result);
return Result;
}
//PushMessageToSingle接口测试代码
private static void PushMessageToSingle()
{
// 推送主类
IGtPush push = new IGtPush(HOST, APPKEY, MASTERSECRET);
//通知模版：支持TransmissionTemplate、LinkTemplate、NotificationTemplate，此处以TransmissionTemplate为例
TransmissionTemplate template = new TransmissionTemplate();
template.AppId = APPID; // 应用APPID
template.AppKey = APPKEY; // 应用APPKEY
template.TransmissionType = "1"; // 收到消息是否立即启动应用，1为立即启动，2则广播等待客户端自启动
template.TransmissionContent = "您需要透传的内容"; // 需要透传的内容
//iOS推送需要的pushInfo字段
//template.setPushInfo(actionLocKey, badge, message, sound, payload, locKey, locArgs, launchImage);
// 单推消息模型
SingleMessage message = new SingleMessage();
message.IsOffline = true; // 用户当前不在线时，是否离线存储,可选
message.OfflineExpireTime = 1000 * 3600 * 12; // 离线有效时间，单位为毫秒，可选
message.Data = template;
com.igetui.api.openservice.igetui.Target target = new com.igetui.api.openservice.igetui.Target();
target.appId = APPID;
target.clientId = CLIENTID;
String pushResult = push.pushMessageToSingle(message, target);
System.Console.WriteLine("-----------PushMessageToSingle--------------" + pushResult);
}
