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);
}
}
//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);
}
}
/// <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);
}
}
//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);
}
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);
}
/// <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 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);
}
}
/// <summary>
/// 16 -->> 公司OA平台发出的消息（杨立旭）
/// </summary>
/// <param name="deviceid"></param>
/// <param name="msg"></param>
/// <returns></returns>
public static async Task PushOANotice(string deviceid, string touid, MessageModel model)
{
var currentMethod = "PushOANotice";
var title = "待办任务";// model.SchemeTypeName;
var content = model.Content;
IGtPush push = new IGtPush(HOST, APPKEY, MASTERSECRET);
//var intent = $"intent:#Intent;component=net.cnki.okms/.pages.base.BootActivity;end";
var intent = $"intent:#Intent;component=net.cnki.okms/.pages.base.IndexActivity;S.title={model.Content};S.url={model.DetailUrl};S.levelNoticeTpye=2;end";
var getui = new GeTuiMessage
{
mtype = 16,
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.个推-OA平台类消息[{touid}]推送的消息内容为：{Environment.NewLine}{messageJson}");
try
{
String pushResult = push.pushMessageToSingle(message, target);
LoggerHelper.AndroidPush($"2.个推-OA平台类消息[{touid}]推送的返回结果：{Environment.NewLine}{pushResult}");
}
catch (RequestException e)
{
String requestId = e.RequestId;
//发送失败后的重发
String pushResult = push.pushMessageToSingle(message, target, requestId);
LoggerHelper.AndroidPush($"3.个推-OA平台类消息[{touid}]发生了异常，重发后，服务端返回结果：----------------" + pushResult);
}
}
public void PushMessageToSingle(string ClientID, string AppID, string AppKey, string MasterSecret)
{
try
{
IGtPush push = new IGtPush(HOST, AppKey, MasterSecret);
NotificationTemplate template = NotificationTemplateDemo(AppID, AppKey);
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 = 0;
com.igetui.api.openservice.igetui.Target target = new com.igetui.api.openservice.igetui.Target();
target.appId = AppID;
target.clientId = ClientID;
try
{
String pushResult = push.pushMessageToSingle(message, target);
// System.Console.WriteLine("-----------------------------------------------");
// System.Console.WriteLine("-----------------------------------------------");
// System.Console.WriteLine("----------------服务端返回结果：" + pushResult);
Utils.log("----------------服务端返回结果：" + ClientID + "----" + pushResult);
}
catch (RequestException e)
{
String requestId = e.RequestId;
//发送失败后的重发
String pushResult = push.pushMessageToSingle(message, target, requestId);
// System.Console.WriteLine("-----------------------------------------------3");
// System.Console.WriteLine("-----------------------------------------------");
// System.Console.WriteLine("----------------服务端返回结果：" + pushResult);
}
}
catch (Exception ex)
{
Utils.log("PushMessageToSingle Error:" + ex.Message);
}
}
private static String DeviceToken = ""; //填写IOS系统的DeviceToken
/// <summary>
/// 对单个用户的推送
/// </summary>
/// <returns></returns>
public static string PushMessageToSingle()
{
IGtPush push = new IGtPush(HOST, APPKEY, MASTERSECRET);
//消息模版：网页模板
LinkTemplate template = LinkTemplateDemo();
// 单推消息模型
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;
//target.alias = ALIAS;
try
{
string pushResult = push.pushMessageToSingle(message, target);
return("发送成功" + pushResult);
//System.Console.WriteLine("-----------------------------------------------");
//System.Console.WriteLine("-----------------------------------------------");
//System.Console.WriteLine("----------------服务端返回结果：" + pushResult);
}
catch (RequestException e)
{
string requestId = e.RequestId;
//发送失败后的重发
string pushResult = push.pushMessageToSingle(message, target, requestId);
return("失败重发" + pushResult);
//System.Console.WriteLine("-----------------------------------------------");
//System.Console.WriteLine("-----------------------------------------------");
//System.Console.WriteLine("----------------服务端返回结果：" + pushResult);
}
}
/// <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));
}
//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;
}
/// <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);
}
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);
}
/// <summary>
/// 发送推送[目前仅支持传透和通知，支持Android和IOS]
/// </summary>
/// <param name="condtion"></param>
internal static SendGeTuiPushReplay PushMessage(SendGeTuiPushBySetRequestModel condtion)
{
SendGeTuiPushReplay result = new SendGeTuiPushReplay();
IGtPush push = new IGtPush(HOST, APPKEY, MASTERSECRET);
ListMessage listMessage = new ListMessage()
{
IsOffline = IsOffline,
OfflineExpireTime = OfflineExpireTime,
PushNetWorkType = PushNetWorkType
};
SingleMessage singleMessage = new SingleMessage()
{
IsOffline = IsOffline,
OfflineExpireTime = OfflineExpireTime,
PushNetWorkType = PushNetWorkType
};
TransmissionTemplate tt = TransmissionTemplateDemo(); //传透
NotificationTemplate nt = NotificationTemplateDemo(); //通知
if (condtion.sets.Count > 0)
{
//分离请求中的设备类型
List <GeTuiSetModel> ios = condtion.sets.Where(p => p.deviceType != EnumUserDeviceType.Android).ToList();
List <GeTuiSetModel> android = condtion.sets.Where(p => p.deviceType == EnumUserDeviceType.Android).ToList();
//IOS和安卓分开处理
if (ios.Count > 0)
{
//IOS设备发送
//IOS需使用传透方式来发送
APNTemplate template = new APNTemplate();
APNPayload apnpayload = new APNPayload();
DictionaryAlertMsg alertMsg = new DictionaryAlertMsg();
alertMsg.Body = condtion.msg;
alertMsg.ActionLocKey = "";
alertMsg.LocKey = "";
alertMsg.addLocArg("");
alertMsg.LaunchImage = "";
//IOS8.2支持字段
alertMsg.Title = condtion.title;
alertMsg.TitleLocKey = "";
alertMsg.addTitleLocArg("");
apnpayload.AlertMsg = alertMsg;
apnpayload.Badge = 1;
apnpayload.ContentAvailable = 1;
//apnpayload.Category = "";
apnpayload.Sound = "sms-received1.caf";
apnpayload.addCustomMsg("customInfo", condtion.customInfo);
template.setAPNInfo(apnpayload);
template.AppId = APPID;
template.AppKey = APPKEY;
if (ios.Count > 1)
{
//批量
listMessage.Data = template;
List <string> devicetokenlist = new List <string>();
foreach (GeTuiSetModel set in ios)
{
devicetokenlist.Add(set.clientId);
}
string contentId = push.getAPNContentId(APPID, listMessage);
result.sentResultIos = push.pushAPNMessageToList(APPID, contentId, devicetokenlist);
}
else if (ios.Count == 1)
{
//单个
singleMessage.Data = template;
result.sentResultIos = push.pushAPNMessageToSingle(APPID, ios[0].clientId, singleMessage);
}
}
if (android.Count > 0)
{
switch (condtion.messageType)
{
case EnumPushMessagesType.透传消息:
tt.TransmissionContent = condtion.msg;
listMessage.Data = tt;
singleMessage.Data = tt;
break;
case EnumPushMessagesType.通知:
nt.Title = condtion.title;
nt.Text = condtion.msg;
nt.TransmissionContent = Newtonsoft.Json.JsonConvert.SerializeObject(condtion.customInfo);
listMessage.Data = nt;
singleMessage.Data = nt;
break;
}
//安卓设备发送
if (android.Count > 1)
{
//多个用户
List <Target> ts = new List <Target>();
foreach (GeTuiSetModel set in android)
{
ts.Add(new Target()
{
appId = APPID,
clientId = set.clientId
});
}
string contentId = push.getContentId(listMessage, "ToList_" + DateTime.Now.ToString("yyyyMMddHHmmss"));
result.sentResultAndroid = push.pushMessageToList(contentId, ts);
}
else if (android.Count == 1)
{
//单个用户
Target t = new Target();
t.appId = APPID;
t.clientId = android[0].clientId;
result.sentResultAndroid = push.pushMessageToSingle(singleMessage, t);
}
}
result.ReturnCode = EnumErrorCode.Success;
}
else
{
result.ReturnCode = EnumErrorCode.EmptyDate;
result.ReturnMessage = "没有设置任何的接收者";
SysManagerService.SysSaveSysLog("推送消息：[" + condtion.msg + "]没有设置任何的接收者", EnumSysLogType.警告);
}
return(result);
}
/// <summary>
/// 15 -->> 自建群编辑通知（刘静杰）
/// </summary>
/// <param name="deviceid"></param>
/// <param name="msg"></param>
/// <returns></returns>
public static async Task PushSelfGroupNoticeMore(string deviceid, string touid, SelfGroupNoticeMore model)
{
var currentMethod = "PushSelfGroupNoticeMore";
var title = "群组动态通知";
var content = "群组动态";
title = model.groupname;
if (model.type == 0)
{
content = model.membername + "新加入群组";
}
else if (model.type == 1)
{
content = model.membername + "已被移出群组";
}
else if (model.type == 2)
{
content = model.membername + "退出群组";
}
else if (model.type == 3)
{
content = "群组已经被解散";
}
else if (model.type == 4)
{
content = "修改群组信息动态";
}
IGtPush push = new IGtPush(HOST, APPKEY, MASTERSECRET);
var intent = $"intent:#Intent;component=net.cnki.okms/.pages.base.BootActivity;end";
var getui = new GeTuiMessage
{
mtype = 15,
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);
}
}
/// <summary>
/// 6 - 12 研讨类消息
/// </summary>
/// <param name="deviceid"></param>
/// <param name="msgtype"></param>
/// <param name="msg"></param>
/// <param name="touid"></param>
/// <returns></returns>
public static async Task PushDiscussMessage(string deviceid, int msgtype, string msg, string touid)
{
var currentMethod = "PushDiscussMessage";
object model = null;
var content = "新的研讨消息";
if (msgtype == 6)
{
var m = JsonConvert.DeserializeObject <AddDiscuss>(msg);
content = m.Name + "有新的研讨消息";
model = m;
}
else if (msgtype == 7)
{
var m = JsonConvert.DeserializeObject <DeleteDiscuss>(msg);
content = m.Name + "有新的研讨消息";
model = m;
}
else if (msgtype == 8)
{
var m = JsonConvert.DeserializeObject <ModifyDiscuss>(msg);
content = m.Name + "有新的研讨消息";
model = m;
}
else if (msgtype == 9)
{
var m = JsonConvert.DeserializeObject <FinishDiscuss>(msg);
content = m.Name + "有新的研讨消息";
model = m;
}
else if (msgtype == 10)
{
var m = JsonConvert.DeserializeObject <ActivateDiscuss>(msg);
content = m.Name + "有新的研讨消息";
model = m;
}
else if (msgtype == 11)
{
var m = JsonConvert.DeserializeObject <RemindDiscuss>(msg);
content = m.Name + "有新的研讨消息";
model = m;
}
else if (msgtype == 12)
{
var m = JsonConvert.DeserializeObject <Note>(msg);
content = m.Title + "有新的研讨消息";
model = m;
}
IGtPush push = new IGtPush(HOST, APPKEY, MASTERSECRET);
//消息模版：TransmissionTemplate:透传模板
var intent = $"intent:#Intent;component=net.cnki.okms/.pages.base.BootActivity;end";
var title = "协同研讨";
var getui = new GeTuiMessage
{
mtype = msgtype,
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;
//判断是否客户端是否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 = deviceid;
//target.alias = ALIAS;
var messageJson = JsonConvert.SerializeObject(message);
LoggerHelper.AndroidPush($"1.个推-研讨类消息[{touid}]推送的消息内容为：{Environment.NewLine}{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);
}
}
/// <summary>
/// 1.个推-聊天消息
/// </summary>
/// <param name="deviceid"></param>
/// <param name="msg"></param>
/// <returns></returns>
public static async Task PushMessageToSingle(string touid, string deviceid, Msg msg)
{
var currentMethod = "PushMessageToSingle";
//LoggerHelper.AndroidPush($"0.开始给[{touid}]推送Android消息{Environment.NewLine},cliendid={deviceid}");
IGtPush push = new IGtPush(HOST, APPKEY, MASTERSECRET);
//消息模版：TransmissionTemplate:透传模板
//var intent = $"intent:#Intent;component=net.cnki.okms/.pages.base.BootActivity;end";
var intent = $"intent:#Intent;component=net.cnki.okms/.pages.base.IndexActivity;S.friendId={msg.fromuid};S.friendName={msg.fromrealname};S.isGroup=0;S.levelNoticeTpye=1;end";
var title = msg.fromrealname;
var content = "";
var fromPersonName = "";
if (msg.isgroup == 1)
{
title = msg.torealname;
fromPersonName = msg.fromrealname + ":";
}
content = fromPersonName + msg.msg;
if (msg.msgtype == 1)
{
content = fromPersonName + "[图片]";
}
else if (msg.msgtype == 2)
{
content = fromPersonName + "[文件]";
}
else if (msg.msgtype == 4)
{
content = fromPersonName + "[语音]";
}
else if (msg.msgtype == 5)
{
content = fromPersonName + "[地图签到]";
}
else if (msg.msgtype == 3)
{
content = fromPersonName + "[图片]";
}
var getui = new GeTuiMessage
{
mtype = 1,
mcontent = msg,
};
if (msg.isgroup == 1)
{
intent = $"intent:#Intent;component=net.cnki.okms/.pages.base.IndexActivity;S.friendId={msg.touid};S.friendName={msg.torealname};S.isGroup=1;S.levelNoticeTpye=1;end";
//template = TransmissionTemplate(msg.torealname, msg.msg, intent, JsonConvert.SerializeObject(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;
//判断是否客户端是否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 = deviceid;
//target.alias = ALIAS;
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}");
//_dataService.InsertGeguiLog(msg.fromuid, touid, msg.msgtime, msg.id0, "android", deviceid, messageJson);
}
catch (RequestException e)
{
String requestId = e.RequestId;
//发送失败后的重发
String pushResult = push.pushMessageToSingle(message, target, requestId);
LoggerHelper.AndroidPush($"3.给[{touid}]推送发生了异常，重发后，服务端返回结果{Environment.NewLine}{pushResult}");
}
}
