//public string GetJsonString(object data)
//{
// JavaScriptSerializer js = new JavaScriptSerializer();
// var jsonString = js.Serialize(data);
// //解码Unicode，也可以通过设置App.Config（Web.Config）设置来做，这里只是暂时弥补一下，用到的地方不多
// MatchEvaluator evaluator = new MatchEvaluator(DecodeUnicode);
// var json = Regex.Replace(jsonString, @"\\u[0123456789abcdef]{4}", evaluator);//或：[\\u007f-\\uffff]，\对应为\u000a，但一般情况下会保持\
// return json;
//}
/// <summary>
/// 将对象转为JSON字符串
/// </summary>
/// <param name="data">需要生成JSON字符串的数据</param>
/// <param name="jsonSetting">JSON输出设置</param>
/// <returns></returns>
public string GetJsonString(object data, JsonSetting jsonSetting = null)
{
JavaScriptSerializer jsSerializer = new JavaScriptSerializer();
jsSerializer.RegisterConverters(new JavaScriptConverter[]
{
new WeixinJsonConventer(data.GetType(), jsonSetting),
new ExpandoJsonConverter()
});
var jsonString = jsSerializer.Serialize(data);
//解码Unicode，也可以通过设置App.Config（Web.Config）设置来做，这里只是暂时弥补一下，用到的地方不多
MatchEvaluator evaluator = new MatchEvaluator(DecodeUnicode);
var json = Regex.Replace(jsonString, @"\\u[0123456789abcdef]{4}", evaluator);//或：[\\u007f-\\uffff]，\对应为\u000a，但一般情况下会保持\
return json;
}
/// <summary>
///
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="requestPolicy"></param>
/// <param name="data"></param>
/// <param name="sendType"></param>
/// <param name="timeOut"></param>
/// <param name="checkValidationResult"></param>
/// <param name="jsonSetting"></param>
/// <returns></returns>
public static T Send <T>(
Com.Alibaba.Entities.Request.RequestPolicy requestPolicy,
object data,
CommonJsonSendType sendType = CommonJsonSendType.POST,
int timeOut = Config.TIME_OUT,
bool checkValidationResult = false,
JsonSetting jsonSetting = null)
{
T result = default(T);
try
{
var accessToken = requestPolicy.AccessToken;
var appendixDictPara = new Dictionary <string, object>();
var url = new StringBuilder();
url.Append(requestPolicy.SessionType == SessionType.Sandbox ? Com.Alibaba.Config.RequestUriRootSandbox.UriSchemaFill(requestPolicy.RequestSchema) : Com.Alibaba.Config.RequestUriRoot.UriSchemaFill(requestPolicy.RequestSchema));
url.Append($"/{requestPolicy.ApiRoot}/{requestPolicy.Protocol.ToString()}/{requestPolicy.ApiVersion}/{requestPolicy.ApiNamespace}/{requestPolicy.ApiName}/{requestPolicy.ClientId}");
var urlPath = $"{requestPolicy.Protocol.ToString()}/{requestPolicy.ApiVersion}/{requestPolicy.ApiNamespace}/{requestPolicy.ApiName}/{requestPolicy.ClientId}";
if (requestPolicy.ValidateSignature)
{
var dictPara = ArrangeParameter(data);
if (!string.IsNullOrEmpty(accessToken))
{
dictPara.Add("access_token", accessToken);
}
byte[] sign = Com.Alibaba.Helpers.SignatureHelper.HmacSha1(urlPath, dictPara, requestPolicy.ClientSecret);
String signStr = Com.Alibaba.Helpers.SignatureHelper.ToHex(sign);
appendixDictPara.Add("_aop_signature", signStr);
}
result = Com.Alibaba.CommonAPIs.CommonJsonSend.Send <T>(accessToken, url.ToString(), data, sendType, timeOut, checkValidationResult, jsonSetting, appendixDictPara);
}
catch (Exception)
{
throw;
}
return(result);
}
public static WorkJsonResult CreateMember(string accessTokenOrAppKey, MemberCreateRequest memberCreateRequest, int timeOut = Config.TIME_OUT)
{
return(ApiHandlerWapper.TryCommonApi(accessToken =>
{
var url = Config.ApiWorkHost + "/cgi-bin/user/create?access_token={0}";
JsonSetting jsonSetting = new JsonSetting(true);
return CommonJsonSend.Send <WorkJsonResult>(accessToken, url, memberCreateRequest, CommonJsonSendType.POST, timeOut, jsonSetting: jsonSetting);
/*
* 返回结果：
* {
* "errcode": 0,
* "errmsg": "created"
* }
*/
}, accessTokenOrAppKey));
}
public static async Task <CreateDepartmentResult> CreateDepartmentAsync(string accessTokenOrAppKey, string name, long parentId, int order = 1, long?id = null, int timeOut = Config.TIME_OUT)
{
return(await ApiHandlerWapper.TryCommonApiAsync(async accessToken =>
{
var url = string.Format(Config.ApiWorkHost + "/cgi-bin/department/create?access_token={0}", accessToken.AsUrlData());
var data = new
{
name = name,
parentid = parentId,
order = order,
id = id
};
JsonSetting jsonSetting = new JsonSetting(true);
return await Senparc.Weixin.CommonAPIs.CommonJsonSend.SendAsync <CreateDepartmentResult>(null, url, data, CommonJsonSendType.POST, timeOut, jsonSetting: jsonSetting);
}, accessTokenOrAppKey));
}
public static ListResultJson List(string accessTokenOrAppId, uint msg_data_id, uint?index, uint begin, uint count, uint type, int timeOut = Config.TIME_OUT)
{
//返回JSON：
/*
* {
* "errcode": 0,
* "errmsg": "ok",
* "comment": [
* {
* "user_comment_id": 9,
* "create_time": 1521255525,
* "content": "如果有什么大考验的话可能会发现自己啥都没改都白扯了吧",
* "comment_type": 0,
* "openid": "oufSm0Xw0nhuha_nWD6AfiZ3rgvA",
* "reply" :
* {
* "content" : "CONTENT",
* "create_time" : 1521265525
* }
*
* }
* ],
* "total": 1
* }
*/
return(ApiHandlerWapper.TryCommonApi(accessToken =>
{
var urlFormat = Config.ApiMpHost + "/cgi-bin/comment/list?access_token={0}";
var data = new
{
msg_data_id = msg_data_id,
index = index,
begin = begin,
count = count,
type = type
};
JsonSetting jsonSetting = new JsonSetting(ignoreNulls: true);
return CommonJsonSend.Send <ListResultJson>(accessToken, urlFormat, data, timeOut: timeOut, jsonSetting: jsonSetting);
}, accessTokenOrAppId));
}
public static async Task <WorkJsonResult> UpdateMemberAsync(string accessTokenOrAppKey, MemberUpdateRequest memberUpdateRequest, int timeOut = Config.TIME_OUT)
{
return(await ApiHandlerWapper.TryCommonApiAsync(async accessToken =>
{
var url = Config.ApiWorkHost + "/cgi-bin/user/update?access_token={0}";
JsonSetting jsonSetting = new JsonSetting(true);
return await Senparc.Weixin.CommonAPIs.CommonJsonSend.SendAsync <WorkJsonResult>(accessToken, url, memberUpdateRequest, CommonJsonSendType.POST, timeOut, jsonSetting: jsonSetting);
}
/*
* 返回结果：
* {
* "errcode": 0,
* "errmsg": "updated"
* }
*/
, accessTokenOrAppKey));
}
public static WorkJsonResult UpdateDepartment(string accessTokenOrAppKey, long id, string name, long parentId, int order = 1, int timeOut = Config.TIME_OUT)
{
return(ApiHandlerWapper.TryCommonApi(accessToken =>
{
var url = string.Format(Config.ApiWorkHost + "/cgi-bin/department/update?access_token={0}", accessToken.AsUrlData());
var data = new
{
id = id,
name = name,
parentid = parentId,
order = order
};
JsonSetting jsonSetting = new JsonSetting(true);
return Senparc.Weixin.CommonAPIs.CommonJsonSend.Send <WorkJsonResult>(null, url, data, CommonJsonSendType.POST, timeOut, jsonSetting: jsonSetting);
}, accessTokenOrAppKey));
}
/// <summary>
/// 【异步方法】更新部门【QY移植修改】
/// </summary>
/// <param name="accessTokenOrAppKey">调用接口凭证</param>
/// <param name="id">部门id</param>
/// <param name="name">更新的部门名称。长度限制为0~64个字符。修改部门名称时指定该参数</param>
/// <param name="parentId">父亲部门id。根部门id为1 </param>
/// <param name="order">在父部门中的次序。从1开始，数字越大排序越靠后</param>
/// <param name="timeOut">代理请求超时时间（毫秒）</param>
/// <returns></returns>
public static async Task <WorkJsonResult> UpdateDepartmentAsync(string accessTokenOrAppKey, string id, string name, int parentId, int order = 1, int timeOut = Config.TIME_OUT)
{
return(await ApiHandlerWapper.TryCommonApiAsync(async accessToken =>
{
var url = string.Format("https://qyapi.weixin.qq.com/cgi-bin/department/update?access_token={0}", accessToken.AsUrlData());
var data = new
{
id = id,
name = name,
parentid = parentId,
order = order
};
JsonSetting jsonSetting = new JsonSetting(true);
return await Senparc.Weixin.CommonAPIs.CommonJsonSend.SendAsync <WorkJsonResult>(null, url, data, CommonJsonSendType.POST, timeOut, jsonSetting: jsonSetting);
}, accessTokenOrAppKey));
}
/// <summary>
/// 创建部门【QY移植修改】
/// 系统应用须拥有父部门的管理权限。
/// 注意，部门的最大层级为15层；部门总数不能超过3万个；每个部门下的节点不能超过3万个。建议保证创建的部门和对应部门成员是串行化处理。
/// </summary>
/// <param name="accessTokenOrAppKey">调用接口凭证</param>
/// <param name="name">部门名称。长度限制为1~64个字节，字符不能包括\:?”<>｜</param>
/// <param name="parentId">父亲部门id。根部门id为1 </param>
/// <param name="order">在父部门中的次序。从1开始，数字越大排序越靠后</param>
/// <param name="id">部门ID。用指定部门ID新建部门，不指定此参数时，则自动生成</param>
/// <param name="timeOut">代理请求超时时间（毫秒）</param>
/// <returns></returns>
public static CreateDepartmentResult CreateDepartment(string accessTokenOrAppKey, string name, int parentId, int order = 1, int?id = null, int timeOut = Config.TIME_OUT)
{
return(ApiHandlerWapper.TryCommonApi(accessToken =>
{
var url = string.Format("https://qyapi.weixin.qq.com/cgi-bin/department/create?access_token={0}", accessToken.AsUrlData());
var data = new
{
name = name,
parentid = parentId,
order = order,
id = id
};
JsonSetting jsonSetting = new JsonSetting(true);
return Senparc.Weixin.CommonAPIs.CommonJsonSend.Send <CreateDepartmentResult>(null, url, data, CommonJsonSendType.POST, timeOut, jsonSetting: jsonSetting);
}, accessTokenOrAppKey));
}
public static async Task <WorkJsonResult> SetAuthConfigAsync(string suiteAccessToken, string authCode, int[] appid = null, int?auth_type = null, int timeOut = 10000)
{
return(await ApiHandlerWapper.TryCommonApiAsync(async accessToken =>
{
var url = string.Format(Config.ApiWorkHost + "/cgi-bin/service/set_session_info?suite_access_token={0}", suiteAccessToken.AsUrlData());
var data = new
{
pre_auth_code = authCode,
session_info = new
{
appid = appid,
auth_type = auth_type
}
};
JsonSetting jsonSetting = new JsonSetting(true);
return await Senparc.Weixin.CommonAPIs.CommonJsonSend.SendAsync <WorkJsonResult>(null, url, data, CommonJsonSendType.POST, timeOut, jsonSetting: jsonSetting);
}, suiteAccessToken));
}
/// <summary>
/// 设置授权配置【QY移植修改】
/// </summary>
/// <param name="suiteAccessToken"></param>
/// <param name="authCode">预授权码</param>
/// <param name="appid">允许进行授权的应用id，如1、2、3， 不填或者填空数组都表示允许授权套件内所有应用 </param>
/// <param name="auth_type">授权类型：0 正式授权， 1 测试授权， 默认值为0 </param>
/// <param name="timeOut"></param>
/// <returns></returns>
public static WorkJsonResult SetAuthConfig(string suiteAccessToken, string authCode, int[] appid = null, int?auth_type = null, int timeOut = 10000)
{
return(ApiHandlerWapper.TryCommonApi(accessToken =>
{
var url = string.Format("https://qyapi.weixin.qq.com/cgi-bin/service/set_session_info?suite_access_token={0}", suiteAccessToken.AsUrlData());
var data = new
{
pre_auth_code = authCode,
session_info = new
{
appid = appid,
auth_type = auth_type
}
};
JsonSetting jsonSetting = new JsonSetting(true);
return Senparc.Weixin.CommonAPIs.CommonJsonSend.Send <WorkJsonResult>(null, url, data, CommonJsonSendType.POST, timeOut, jsonSetting: jsonSetting);
}, suiteAccessToken));
}
/// <summary>
/// 【异步方法】发送文本信息【QY移植修改】
/// </summary>
/// <param name="accessToken">调用接口凭证</param>
/// <param name="toUser">UserID列表（消息接收者，多个接收者用‘|’分隔）。特殊情况：指定为@all，则向关注该企业应用的全部成员发送</param>
/// <param name="toParty">PartyID列表，多个接受者用‘|’分隔。当touser为@all时忽略本参数</param>
/// <param name="toTag">TagID列表，多个接受者用‘|’分隔。当touser为@all时忽略本参数</param>
/// <param name="agentId">企业应用的id，可在应用的设置页面查看</param>
/// <param name="content">消息内容</param>
/// <param name="safe">表示是否是保密消息，0表示否，1表示是，默认0</param>
/// <param name="timeOut">代理请求超时时间（毫秒）</param>
/// <returns></returns>
public static async Task <MassResult> SendTextAsync(string accessToken, string agentId, string content, string toUser = null, string toParty = null, string toTag = null, int safe = 0, int timeOut = Config.TIME_OUT)
{
var data = new
{
touser = toUser,
toparty = toParty,
totag = toTag,
msgtype = "text",
agentid = agentId,
text = new
{
content = content
},
safe = safe
};
JsonSetting jsonSetting = new JsonSetting(true);
return(await Senparc.Weixin.CommonAPIs.CommonJsonSend.SendAsync <MassResult>(accessToken, URL_FORMAT, data, CommonJsonSendType.POST, timeOut, jsonSetting : jsonSetting));
}
/// <summary>
/// 客服输入状态
/// </summary>
/// <param name="accessTokenOrAppId"></param>
/// <param name="touser">普通用户（openid）</param>
/// <param name="typingStatus">"Typing"：对用户下发“正在输入"状态 "CancelTyping"：取消对用户的”正在输入"状态</param>
/// <param name="businessId">添加 businessId 参数，则发送到子商户</param>
/// <param name="timeOut"></param>
/// <returns></returns>
public static WxJsonResult GetTypingStatus(string accessTokenOrAppId, string touser, string typingStatus, string businessId = null, int timeOut = Config.TIME_OUT)
{
return(WxOpenApiHandlerWapper.TryCommonApi(accessToken =>
{
var urlFormat = GetTypingUrlFormat(businessId);
var data = new
{
touser = touser,
command = typingStatus,
businessid = businessId
};
var jsonSetting = new JsonSetting()
{
IgnoreNulls = true
};
return CommonJsonSend.Send <WxJsonResult>(accessToken, urlFormat, data, timeOut: timeOut, jsonSetting: jsonSetting);
}, accessTokenOrAppId));
}
/// <summary>
/// 【异步方法】客服输入状态
/// </summary>
/// <param name="accessTokenOrAppId"></param>
/// <param name="touser">普通用户（openid）</param>
/// <param name="typingStatus">"Typing"：对用户下发“正在输入"状态 "CancelTyping"：取消对用户的”正在输入"状态</param>
/// <param name="businessId">添加 businessId 参数，则发送到子商户</param>
/// <param name="timeOut"></param>
/// <returns></returns>
public static async Task <WxJsonResult> GetTypingStatusAsync(string accessTokenOrAppId, string touser, string typingStatus, string businessId = null, int timeOut = Config.TIME_OUT)
{
return(await WxOpenApiHandlerWapper.TryCommonApiAsync(async accessToken =>
{
var urlFormat = GetTypingUrlFormat(businessId);
var data = new
{
touser = touser,
command = typingStatus,
businessid = businessId
};
var jsonSetting = new JsonSetting()
{
IgnoreNulls = true
};
return await CommonJsonSend.SendAsync <WxJsonResult>(accessToken, urlFormat, data, timeOut: timeOut, jsonSetting: jsonSetting).ConfigureAwait(false);
}, accessTokenOrAppId));
}
/// <summary>
/// 向需要AccessToken的API发送消息的公共方法
/// </summary>
/// <param name="accessToken">这里的AccessToken是通用接口的AccessToken，非OAuth的。如果不需要，可以为null，此时urlFormat不要提供{0}参数</param>
/// <param name="urlFormat"></param>
/// <param name="data">如果是Get方式，可以为null。在POST方式中将被转为JSON字符串提交</param>
/// <param name="sendType">发送类型，POST或GET，默认为POST</param>
/// <param name="timeOut">代理请求超时时间（毫秒）</param>
/// <param name="checkValidationResult">验证服务器证书回调自动验证</param>
/// <param name="jsonSetting">JSON字符串生成设置</param>
/// <returns></returns>
public static async Task <T> SendAsync <T>(string accessToken, string urlFormat, object data, CommonJsonSendType sendType = CommonJsonSendType.POST, int timeOut = Config.TIME_OUT, bool checkValidationResult = false,
JsonSetting jsonSetting = null
)
{
try
{
var url = string.IsNullOrEmpty(accessToken) ? urlFormat : string.Format(urlFormat, accessToken.AsUrlData());
switch (sendType)
{
case CommonJsonSendType.GET:
return(await Get.GetJsonAsync <T>(url));
case CommonJsonSendType.POST:
SerializerHelper serializerHelper = new SerializerHelper();
var jsonString = serializerHelper.GetJsonString(data, jsonSetting);
using (MemoryStream ms = new MemoryStream())
{
var bytes = Encoding.UTF8.GetBytes(jsonString);
await ms.WriteAsync(bytes, 0, bytes.Length);
ms.Seek(0, SeekOrigin.Begin);
return
(await
Post.PostGetJsonAsync <T>(url, null, ms, timeOut : timeOut,
checkValidationResult : checkValidationResult));
}
default:
throw new ArgumentOutOfRangeException("sendType");
}
}
catch (ErrorJsonResultException ex)
{
ex.Url = urlFormat;
throw;
}
}
///// <summary>
///// 此接口已取消，微信直接提供了十四种色值供选择，详见：http://mp.weixin.qq.com/wiki/8/b7e310e7943f7763450eced91fa793b0.html#.E5.8D.A1.E5.88.B8.E5.9F.BA.E7.A1.80.E4.BF.A1.E6.81.AF.E5.AD.97.E6.AE.B5.EF.BC.88.E9.87.8D.E8.A6.81.EF.BC.89
///// 获取颜色列表接口
///// </summary>
///// <param name="accessTokenOrAppId"></param>
///// <param name="timeOut">代理请求超时时间（毫秒）</param>
///// <returns></returns>
/// <summary>
/// 生成卡券二维码
/// 获取二维码ticket 后，开发者可用ticket 换取二维码图片。换取指引参考：http://mp.weixin.qq.com/wiki/index.php?title=生成带参数的二维码
/// </summary>
/// <param name="accessTokenOrAppId"></param>
/// <param name="cardId">卡券ID</param>
/// <param name="code">指定卡券code 码，只能被领一次。use_custom_code 字段为true 的卡券必须填写，非自定义code 不必填写。</param>
/// <param name="openId">指定领取者的openid，只有该用户能领取。bind_openid 字段为true 的卡券必须填写，非自定义openid 不必填写。</param>
/// <param name="expireSeconds">指定二维码的有效时间，范围是60 ~ 1800 秒。不填默认为永久有效。</param>
/// <param name="isUniqueCode">指定下发二维码，生成的二维码随机分配一个code，领取后不可再次扫描。填写true 或false。默认false。</param>
/// <param name="balance">红包余额，以分为单位。红包类型必填（LUCKY_MONEY），其他卡券类型不填。</param>
/// <param name="outer_id">自定义应用场景ID（v13.7.3起支持）</param>
/// <param name="timeOut">代理请求超时时间（毫秒）</param>
/// <returns></returns>
public static CreateQRResultJson CreateQR(string accessTokenOrAppId, string cardId, string code = null,
string openId = null, string expireSeconds = null,
bool isUniqueCode = false, string balance = null, string outer_id = null,
int timeOut = Config.TIME_OUT)
{
return(ApiHandlerWapper.TryCommonApi(accessToken =>
{
var urlFormat = string.Format("https://api.weixin.qq.com/card/qrcode/create?access_token={0}", accessToken.AsUrlData());
var data = new
{
action_name = "QR_CARD",
action_info = new
{
card = new
{
card_id = cardId,
code = code,
openid = openId,
expire_seconds = expireSeconds,
is_unique_code = false,
balance = balance
}
}
};
//var jsonSettingne = new JsonSetting(true);
var jsonSetting = new JsonSetting(true, null,
new List <Type>()
{
//typeof (Modify_Msg_Operation),
//typeof (CardCreateInfo),
data.action_info.card.GetType() //过滤Modify_Msg_Operation主要起作用的是这个
});
return CommonJsonSend.Send <CreateQRResultJson>(null, urlFormat, data, timeOut: timeOut, jsonSetting: jsonSetting);
}, accessTokenOrAppId));
}
/// <summary>
/// 发送图片消息【QY移植修改】
/// </summary>
/// <param name="accessToken">调用接口凭证</param>
/// <param name="toUser">UserID列表（消息接收者，多个接收者用‘|’分隔）。特殊情况：指定为@all，则向关注该企业应用的全部成员发送</param>
/// <param name="toParty">PartyID列表，多个接受者用‘|’分隔。当touser为@all时忽略本参数</param>
/// <param name="toTag"></param>
/// <param name="agentId">企业应用的id，可在应用的设置页面查看</param>
/// <param name="mediaId">媒体资源文件ID</param>
/// <param name="safe">表示是否是保密消息，0表示否，1表示是，默认0</param>
/// <param name="timeOut">代理请求超时时间（毫秒）</param>
/// <returns></returns>
public static MassResult SendImage(string accessToken, string agentId, string mediaId,
string toUser = null, string toParty = null, string toTag = null, int safe = 0,
int timeOut = Config.TIME_OUT)
{
var data = new
{
touser = toUser,
toparty = toParty,
totag = toTag,
msgtype = "image",
agentid = agentId,
image = new
{
media_id = mediaId
},
safe = safe
};
JsonSetting jsonSetting = new JsonSetting(true);
return(Senparc.Weixin.CommonAPIs.CommonJsonSend.Send <MassResult>(accessToken, URL_FORMAT, data, CommonJsonSendType.POST, timeOut, jsonSetting: jsonSetting));
}
/// <summary>
/// 获取小程序页面的小程序码
/// </summary>
/// <param name="accessTokenOrAppId">AccessToken或AppId（推荐使用AppId，需要先注册）</param>
/// <param name="stream">储存小程序码的流</param>
/// <param name="path">不能为空，最大长度 128 字节（如：pages/index?query=1。注：pages/index 需要在 app.json 的 pages 中定义）</param>
/// <param name="width">小程序码的宽度</param>
/// <param name="auto_color">自动配置线条颜色，如果颜色依然是黑色，则说明不建议配置主色调</param>
/// <param name="lineColor">auth_color 为 false 时生效，使用 rgb 设置颜色 例如 {"r":"xxx","g":"xxx","b":"xxx"}</param>
/// <param name="isHyaline">是否需要透明底色， is_hyaline 为true时，生成透明底色的小程序码，默认为 false</param>
/// <param name="timeOut">请求超时时间</param>
/// <returns></returns>
public static WxJsonResult GetWxaCode(string accessTokenOrAppId, Stream stream, string path,
int width = 430, bool auto_color = false, LineColor lineColor = null, bool isHyaline = false, int timeOut = Config.TIME_OUT)
{
return(ApiHandlerWapper.TryCommonApi(accessToken =>
{
string urlFormat = Config.ApiMpHost + "/wxa/getwxacode?access_token={0}";
var url = string.Format(urlFormat, accessToken);
if (auto_color && lineColor == null)
{
lineColor = new LineColor();//提供默认值
}
var data = new { path = path, width = width, line_color = lineColor, is_hyaline = isHyaline };
JsonSetting jsonSetting = new JsonSetting(true);
Post.Download(url, SerializerHelper.GetJsonString(data, jsonSetting), stream);
return new WxJsonResult()
{
errcode = ReturnCode.请求成功
};
}, accessTokenOrAppId));
}
public static async Task <MassResult> SendMarkdownAsync(string accessTokenOrAppKey, string agentId, string content,
string toUser = null, string toParty = null, string toTag = null, int timeOut = Config.TIME_OUT)
{
return(await ApiHandlerWapper.TryCommonApiAsync(async accessToken =>
{
var data = new
{
touser = toUser,
toparty = toParty,
totag = toTag,
msgtype = "markdown",
agentid = agentId,
markdown = new
{
content
}
};
JsonSetting jsonSetting = new JsonSetting(true);
return await Senparc.Weixin.CommonAPIs.CommonJsonSend.SendAsync <MassResult>(accessToken, _urlFormat, data, CommonJsonSendType.POST, timeOut).ConfigureAwait(false);
}, accessTokenOrAppKey).ConfigureAwait(false));
}
public void ExportIterativeRepositoryToJson()
{
// arrange
var key = Constants.Json.Key;
var setting = new JsonSetting {
Location = _path, Name = "iterative-test-repo.json"
};
var testRepo = new IterativeTestRepository {
MyProperty = 4711
};
var rand = new Random();
for (int i = 0; i < 10; i++)
{
testRepo.Add(rand.NextDouble());
}
// act & assert export
var result = _io.Exporter(key)
.Setup(setting)
.Build(new RepositoryView <double>().From(testRepo))
.Export();
Assert.IsNotNull(result, $"{key} export failed");
// act & assert import
var importedRepo = _io.Importer(key)
.Setup(setting)
.Import()
.As <RepositoryView <double> >()
.To <IterativeTestRepository>();
Assert.AreEqual(testRepo.MyProperty, importedRepo.MyProperty, $"{key} import failed");
Log.Info($"{key} success", this);
}
/// <summary>
/// 【异步方法】发送图片消息【QY移植修改】
/// </summary>
/// <param name="accessTokenOrAppKey">调用接口凭证（AccessToken）或AppKey（根据AccessTokenContainer.BuildingKey(corpId, corpSecret)方法获得）</param>
/// <param name="toUser">UserID列表（消息接收者，多个接收者用‘|’分隔）。特殊情况：指定为@all，则向关注该企业应用的全部成员发送</param>
/// <param name="toParty">PartyID列表，多个接受者用‘|’分隔。当touser为@all时忽略本参数</param>
/// <param name="toTag"></param>
/// <param name="agentId">企业应用的id，可在应用的设置页面查看</param>
/// <param name="mediaId">媒体资源文件ID</param>
/// <param name="safe">表示是否是保密消息，0表示否，1表示是，默认0</param>
/// <param name="timeOut">代理请求超时时间（毫秒）</param>
/// <returns></returns>
public static async Task <MassResult> SendImageAsync(string accessTokenOrAppKey, string agentId, string mediaId, string toUser = null, string toParty = null, string toTag = null, int safe = 0,
int timeOut = Config.TIME_OUT)
{
return(await ApiHandlerWapper.TryCommonApiAsync(async accessToken =>
{
var data = new
{
touser = toUser,
toparty = toParty,
totag = toTag,
msgtype = "image",
agentid = agentId,
image = new
{
media_id = mediaId
},
safe = safe
};
JsonSetting jsonSetting = new JsonSetting(true);
return await Senparc.Weixin.CommonAPIs.CommonJsonSend.SendAsync <MassResult>(accessToken, URL_FORMAT, data, CommonJsonSendType.POST, timeOut, jsonSetting: jsonSetting);
}, accessTokenOrAppKey));
}
/// <summary>
/// 【异步方法】创建成员(mobile/weixinid/email三者不能同时为空)【QY移植修改】
/// 文档：http://work.weixin.qq.com/api/doc#10018
/// </summary>
/// <param name="accessTokenOrAppKey">调用接口凭证</param>
/// <param name="userId">员工UserID。必须企业内唯一</param>
/// <param name="name">成员名称。长度为1~64个字符</param>
/// <param name="englishName">（非必须）英文名。长度为1-64个字节。第三方暂不支持</param>
/// <param name="department">成员所属部门id列表。注意，每个部门的直属员工上限为1000个</param>
/// <param name="order">部门内的排序值，默认为0。数量必须和department一致，数值越大排序越前面。第三方暂不支持</param>
/// <param name="position">职位信息。长度为0~64个字符</param>
/// <param name="mobile">手机号码。必须企业内唯一</param>
/// <param name="telephone">座机。长度0-64个字节。第三方暂不支持</param>
/// <param name="email">邮箱。长度为0~64个字符。必须企业内唯一</param>
/// <param name="gender">性别。gender=0表示男，=1表示女。默认gender=0（QY由此说明，Work无）</param>
/// <param name="avatarMediaid"></param>
/// <param name="extattr">扩展属性。扩展属性需要在WEB管理端创建后才生效，否则忽略未知属性的赋值</param>
/// <param name="isLeader">（非必填）上级字段，标识是否为上级（1为是，0为否）。第三方暂不支持</param>
/// <param name="enable">（非必填）</param>
/// <param name="timeOut">代理请求超时时间（毫秒）</param>
/// accessToken、userId和name为必须的参数，其余参数不是必须的，可以传入null
/// <returns></returns>
public static async Task <WorkJsonResult> CreateMemberAsync(string accessTokenOrAppKey, string userId, string name,
string mobile,
string englishName = null,
int[] department = null, int[] order = null, string gender = null,
string position = null, string email = null, string telephone = null, string avatarMediaid = null,
int?isLeader = null, int?enable = null,
Extattr extattr = null, int timeOut = Config.TIME_OUT)
{
return(await ApiHandlerWapper.TryCommonApiAsync(async accessToken =>
{
var url = "https://qyapi.weixin.qq.com/cgi-bin/user/create?access_token={0}";
var data = new
{
userid = userId,
name = name,
english_name = englishName,
mobile = mobile,
department = department,
order = order,
position = position,
gender = gender,
email = email,
telephone = telephone,
isleader = isLeader,
avatar_mediaid = avatarMediaid,
enable = enable,
extattr = extattr
};
JsonSetting jsonSetting = new JsonSetting(true);
return await Senparc.Weixin.CommonAPIs.CommonJsonSend.SendAsync <WorkJsonResult>(accessToken, url, data, CommonJsonSendType.POST, timeOut, jsonSetting: jsonSetting);
}, accessTokenOrAppKey));
}
/// <summary>
/// 【异步方法】发送视频消息【QY移植修改】
/// </summary>
/// <param name="accessToken">调用接口凭证</param>
/// <param name="toUser">UserID列表（消息接收者，多个接收者用‘|’分隔）。特殊情况：指定为@all，则向关注该企业应用的全部成员发送</param>
/// <param name="toParty">PartyID列表，多个接受者用‘|’分隔。当touser为@all时忽略本参数</param>
/// <param name="toTag">TagID列表，多个接受者用‘|’分隔。当touser为@all时忽略本参数</param>
/// <param name="agentId">企业应用的id，可在应用的设置页面查看</param>
/// <param name="mediaId">媒体资源文件ID</param>
/// <param name="title">视频消息的标题</param>
/// <param name="description">视频消息的描述</param>
/// <param name="safe">表示是否是保密消息，0表示否，1表示是，默认0</param>
/// <param name="timeOut">代理请求超时时间（毫秒）</param>
/// <returns></returns>
public static async Task <MassResult> SendVideoAsync(string accessToken, string agentId, string mediaId,
string toUser = null, string toParty = null, string toTag = null,
string title = null, string description = null, int safe = 0, int timeOut = Config.TIME_OUT)
{
var data = new
{
touser = toUser,
toparty = toParty,
totag = toTag,
msgtype = "video",
agentid = agentId,
video = new
{
media_id = mediaId,
title = title,
description = description,
},
safe = safe
};
JsonSetting jsonSetting = new JsonSetting(true);
return(await Senparc.Weixin.CommonAPIs.CommonJsonSend.SendAsync <MassResult>(accessToken, URL_FORMAT, data, CommonJsonSendType.POST, timeOut, jsonSetting : jsonSetting));
}
/// <summary>
/// 【异步方法】获取小程序页面的小程序码 不受限制
/// </summary>
/// <param name="accessTokenOrAppId">AccessToken或AppId（推荐使用AppId，需要先注册）</param>
/// <param name="stream">储存小程序码的流</param>
/// <param name="scene">最大32个可见字符，只支持数字，大小写英文以及部分特殊字符：!#$&'()*+,/:;=?@-._~，其它字符请自行编码为合法字符（因不支持%，中文无法使用 urlencode 处理，请使用其他编码方式）</param>
/// <param name="page">必须是已经发布的小程序页面，例如 "pages/index/index" ,根路径前不要填加'/',不能携带参数（参数请放在scene字段里），如果不填写这个字段，默认跳主页面</param>
/// <param name="width">小程序码的宽度</param>
/// <param name="auto_color">自动配置线条颜色，如果颜色依然是黑色，则说明不建议配置主色调</param>
/// <param name="lineColor">auth_color 为 false 时生效，使用 rgb 设置颜色 例如 {"r":"xxx","g":"xxx","b":"xxx"}</param>
/// <param name="timeOut">请求超时时间</param>
/// <returns></returns>
public static async Task <WxJsonResult> GetWxaCodeUnlimitAsync(string accessTokenOrAppId, Stream stream,
string scene, string page, int width = 430, bool auto_color = false, LineColor lineColor = null,
int timeOut = Config.TIME_OUT)
{
return(await ApiHandlerWapper.TryCommonApiAsync(async accessToken =>
{
string urlFormat = Config.ApiMpHost + "/wxa/getwxacodeunlimit?access_token={0}";
var url = string.Format(urlFormat, accessToken);
if (auto_color && lineColor == null)
{
lineColor = new LineColor();//提供默认值
}
var data = new { scene = scene, page = page, width = width, line_color = lineColor };
JsonSetting jsonSetting = new JsonSetting(true);
await Post.DownloadAsync(url, SerializerHelper.GetJsonString(data, jsonSetting), stream);
return new WxJsonResult()
{
errcode = ReturnCode.请求成功
};
}, accessTokenOrAppId));
}
///
/// 发送卡券 查看card_ext字段详情及签名规则，特别注意客服消息接口投放卡券仅支持非自定义Code码的卡券。
///
public static WxJsonResult SendCard(string accessTokenOrAppId, string openId, string cardId, CardExt cardExt, int timeOut = Config.TIME_OUT)
{
return(ApiHandlerWapper.TryCommonApi(accessToken =>
{
var data = new
{
touser = openId,
msgtype = "wxcard",
wxcard = new
{
card_id = cardId,
card_ext = cardExt
}
};
JsonSetting jsonSetting = new JsonSetting
{
TypesToIgnore = new List <Type> {
typeof(CardExt)
}
};
return CommonJsonSend.Send(accessToken, URL_FORMAT, data, timeOut: timeOut, jsonSetting: jsonSetting);
}, accessTokenOrAppId));
}
public DevModule(IJatuhTempoBusiness jatuhTempoBusiness, ISettingClientBusiness settingClientBusiness, ISPTPDDetailBusiness sPTPDDetailBusiness, IUserActivityBusiness userActivityBusiness, IUserSettingColumnBusiness userSettingColumnBusiness, IUserTransactionBusiness userTransactionBusiness, IUserTransactionDetailBusiness userTransactionDetailBusiness)
{
_jatuhTempoBusiness = jatuhTempoBusiness;
_settingClientBusiness = settingClientBusiness;
_sPTPDDetailBusiness = sPTPDDetailBusiness;
_userActivityBusiness = userActivityBusiness;
_userSettingColumnBusiness = userSettingColumnBusiness;
_userTransactionBusiness = userTransactionBusiness;
_userTransactionDetailBusiness = userTransactionDetailBusiness;
Get["/testConnection"] = parameter =>
{
var jsonBody = string.Empty;
try
{
List <ExceptionPort> listPort = new List <ExceptionPort>();
listPort = _settingClientBusiness.RetrievePortException();
log.Debug("Get list port");
jsonBody = JsonConvert.SerializeObject(listPort);
log.Debug("Connection Success");
return(Response.AsJson(new { value = "OK", body = jsonBody }));
}
catch (Exception ex)
{
return(Response.AsJson(new { value = "Error : " + ex.Message, body = jsonBody }));
}
};
Get["/dev/getAllUser"] = parameter =>
{
log.Debug("Start:/dev/getAllUser");
List <string> lstUsr = new List <string>();
try
{
lstUsr = _userSettingColumnBusiness.RetrieveAllUser();
log.Debug("Get User Success");
}
catch (Exception ex)
{
//log.Debug( "Get User Failed : " + ex.Message );
log.Fatal("Error:/dev/getAllUser", ex);
return(Response.AsJson(new { code = HttpStatusCode.NotFound, message = "Data Not Found", body = string.Empty }));
}
var jsonBody = JsonConvert.SerializeObject(lstUsr);
return(Response.AsJson(new { code = HttpStatusCode.OK, message = "Ok", body = jsonBody }));
};
Get["/dev/getSerialKeyIsExist"] = parameter =>
{
log.Debug("Start:/dev/getSerialKeyIsExist");
try
{
string body = Nancy.IO.RequestStream.FromStream(Request.Body).AsString();
bool isFound = _userSettingColumnBusiness.IsSerialFound(body);
if (isFound)
{
log.Debug("Serial is found");
return(Response.AsJson(new { code = HttpStatusCode.OK, message = "Found", body = "True" }));
}
else
{
log.Debug("Serial not found");
return(Response.AsJson(new { code = HttpStatusCode.OK, message = "Not", body = "False" }));
}
}
catch (Exception ex)
{
//log.Debug( "Get User Failed : " + ex.Message );
log.Fatal("Error:/dev/getSerialKeyIsExist", ex);
return(Response.AsJson(new { code = HttpStatusCode.NotFound, message = "Data Not Found", body = string.Empty }));
}
};
Get["/dev/GetUrlApi"] = parameter =>
{
log.Debug("Start:/dev/GetUrlApi");
string urlApi = string.Empty;
urlApi = _userActivityBusiness.GetUrlApi();
try
{
var jsonBody = JsonConvert.SerializeObject(urlApi);
return(Response.AsJson(new { code = HttpStatusCode.OK, message = "Ok", body = jsonBody }));
}
catch (Exception ex)
{
return(Response.AsJson(new { code = HttpStatusCode.InternalServerError, message = $"Error, {ex.Message}", body = string.Empty }));
}
};
Get["/dev/GetTarifPajak"] = parameter =>
{
log.Debug("Start:/dev/GetTarifPajak");
List <JenisPajak> lstPajak = new List <JenisPajak>();
try
{
//Get All Tarif Pajak
lstPajak = _userSettingColumnBusiness.RetrieveTarifAll();
log.Debug("Get tarif pajak success");
}
catch (Exception ex)
{
log.Fatal("Error:/dev/GetTarifPajak", ex);
return(Response.AsJson(new { code = HttpStatusCode.NotFound, message = "Data Not Found", body = string.Empty }));
}
var jsonBody = JsonConvert.SerializeObject(lstPajak);
return(Response.AsJson(new { code = HttpStatusCode.OK, message = "OK", body = jsonBody }));
};
Post["/dev/postLastErrorDate"] = parameter =>
{
try
{
log.Info("Start : /dev/postLastErrorDate");
string ip = Request.UserHostAddress;
string body = Nancy.IO.RequestStream.FromStream(Request.Body).AsString();
log.Info("Deserialize object from json body");
var setting = JsonConvert.DeserializeObject <string>(body);
//Get Last Error Date By status_error
LastErrorResponse resp = new LastErrorResponse();
resp.TanggalError = DateTime.Now.Date;
resp.TanggalError = _userActivityBusiness.GetLastErrorDate(setting);
var jsonBody = JsonConvert.SerializeObject(resp);
log.Info("End : /dev/postLastErrorDate");
return(Response.AsJson(new { code = HttpStatusCode.OK, body = jsonBody }));
}
catch (Exception ex)
{
log.Fatal("Error : /dev/postLastErrorDate", ex);
return(Response.AsJson(new { code = HttpStatusCode.InternalServerError, message = $"Error, {ex.Message}" }));
throw;
}
};
Post["/dev/postSettingClient"] = parameter =>
{
try
{
log.Info("Start : /dev/postSettingClient");
log.Info($"incoming request from IP:{this.Request.UserHostAddress}");
string body = Nancy.IO.RequestStream.FromStream(Request.Body).AsString();
log.Info("Deserialize object from json body");
JsonSetting setting = JsonConvert.DeserializeObject <JsonSetting>(body);
#region Inserting Data Setting Client
log.Info("Inserting data setting client");
string username = string.Empty;
foreach (var item in setting.list_user)
{
_settingClientBusiness.InsertUserClient(item.userName, item.idMachine, item.guid, item.phone, item.mail, item.port);
username = item.userName;
}
foreach (var item in setting.list_nop)
{
_settingClientBusiness.InsertUserNop(username, item.nop, item.jenisPajak);
}
foreach (var item in setting.settings)
{
_settingClientBusiness.InsertUserSettingColumn(username, item.nop, item.column_name, item.column_text);
}
#endregion
//insert xmlcontent
_settingClientBusiness.InsertXmlFile(username, "setUpload.xml", setting.xml_content, setting.jenFile, setting.separator);
log.Info("End : /dev/postSettingClient");
return(Response.AsJson(new { code = HttpStatusCode.OK }));
}
catch (System.Exception ex)
{
log.Fatal("Error : /dev/postSettingClient", ex);
return(Response.AsJson(new { code = HttpStatusCode.InternalServerError, message = $"Error, {ex.Message}" }));
throw;
}
};
Post["/dev/postSettingClientWithParam"] = parameter =>
{
try
{
log.Info("Start : /dev/postSettingClientWithParam");
log.Info($"incoming request from IP:{this.Request.UserHostAddress}");
var body = Nancy.IO.RequestStream.FromStream(Request.Body).AsString();
log.Info("Deserialize object from json body");
User user = JsonConvert.DeserializeObject <User>(body);
//Retrieve Data User Setting
if (user != null)
{
log.Info("Checking user exist");
UserClient userClient = _settingClientBusiness.RetrieveUserClient(user.userName, user.idMachine, user.guid).FirstOrDefault();
if (userClient != null)
{
log.Info("Retrieve data setting client from database");
List <UserSettingColumn> listSettingColumn = _userSettingColumnBusiness.RetrieveSettingColumnByUsername(userClient.Username);
log.Info("Serialize data to json");
var jsonBody = JsonConvert.SerializeObject(listSettingColumn);
log.Info("End : /dev/postSettingClientWithParam");
return(Response.AsJson(new { code = HttpStatusCode.OK, message = "Success", body = jsonBody }));
}
else
{
log.Info("End : /dev/postSettingClientWithParam");
return(Response.AsJson(new { code = HttpStatusCode.NotFound, message = "Data Not Found", body = string.Empty }));
}
}
else
{
log.Info("End : /dev/postSettingClientWithParam");
return(Response.AsJson(new { code = HttpStatusCode.Unauthorized, message = "Failed", body = string.Empty }));
}
}
catch (Exception ex)
{
log.Fatal("Error : /dev/postSettingClientWithParam", ex);
return(Response.AsJson(new { code = HttpStatusCode.BadRequest, message = $"Error, {ex.Message}", body = string.Empty }));
}
};
Post["/dev/postTransactionClient"] = parameter =>
{
try
{
log.Info("Start : /dev/postTransactionClient");
string ip = this.Request.UserHostAddress;
log.Info($"incoming request from IP:{ip}");
string body = Nancy.IO.RequestStream.FromStream(Request.Body).AsString();
JsonData jsonData = JsonConvert.DeserializeObject <JsonData>(body);
string username = string.Empty;
string CultureInfos = string.Empty;
username = jsonData.datauser.FirstOrDefault().username;
string bulan = jsonData.masapajak.FirstOrDefault().bulan;
string tahun = jsonData.masapajak.FirstOrDefault().tahun;
CultureInfos = jsonData.items.CultureInfos;
log.Info("generating file json to xml");
DataTable dtTransaksi = new DataTable();
DataTable dtLampiran = new DataTable();
dtTransaksi.CaseSensitive = false;
dtLampiran.CaseSensitive = false;
if (jsonData.items.dtLampiran != null && jsonData.items.dtLampiran.Rows.Count > 0)
{
dtTransaksi = jsonData.items.dtPajak;
}
else
{
log.Info("Data tidak ditemukan ............");
return(Response.AsJson(new { code = HttpStatusCode.NotFound, message = $"Error, {"Data tidak ditemukan."}" }));
}
if (jsonData.items.dtLampiran != null && jsonData.items.dtLampiran.Rows.Count > 0)
{
dtLampiran = jsonData.items.dtLampiran;
}
else
{
dtLampiran = dtTransaksi.Copy();
}
List <UserSettingColumn> lstColumnName = new List <UserSettingColumn>();
lstColumnName = _settingClientBusiness.RetrieveUserSettingColumn(username, dtLampiran.Rows[0]["NOP"].ToString());
string teksTanggal = lstColumnName.Where(m => m.Column_Name.ToUpper().Equals("TGL_TRANSAKSI")).Select(m => m.Column_Text).FirstOrDefault();
if (string.IsNullOrEmpty(teksTanggal))
{
teksTanggal = "TGL_TRANSAKSI";
}
#region Delete Null Rows in First column
DataView dv = dtTransaksi.AsDataView();
dv.RowFilter = teksTanggal + " IS NOT NULL";
dtTransaksi = dv.ToTable();
dv = new DataView();
dv = dtLampiran.AsDataView();
dv.RowFilter = teksTanggal + " IS NOT NULL";
dtLampiran = dv.ToTable();
#endregion
string nop = string.Empty;
bool isFromDatabase = false;
DataColumnCollection col = dtLampiran.Columns;
List <string> lstDistNopLampiran = null;
if (col.Contains("NOP_LAMPIRAN"))
{
lstDistNopLampiran = dtLampiran.AsEnumerable().Select(r => r.Field <string>("NOP_LAMPIRAN")).Distinct().ToList();
isFromDatabase = true;
dtLampiran.Columns["NOP"].ColumnName = "NOP_ALIAS";
dtLampiran.Columns["NOP_LAMPIRAN"].ColumnName = "NOP";
}
else
{
lstDistNopLampiran = dtLampiran.AsEnumerable().Select(r => r.Field <string>("NOP").Trim()).Distinct().ToList();
}
if (lstDistNopLampiran == null || lstDistNopLampiran.Count <= 0)
{
log.Info("List Nop tidak ditemukan ............");
return(Response.AsJson(new { code = HttpStatusCode.NotFound, message = $"Error, List Nop tidak ditemukan." }));
}
List <string> lstNopBlokir = new List <string>();
foreach (var itemNopLampiran in lstDistNopLampiran)
{
nop = itemNopLampiran;
string queryPajak = string.Empty;
//Validate Query
if (isFromDatabase)
{
List <BusinessLogic.queryData> queryLst = _userSettingColumnBusiness.RetrieveQueryPajak(username, nop);
if (queryLst != null && queryLst.Count > 0)
{
bool isQueryValid = true;
string queryPajakFromXml = Regex.Replace(jsonData.items.lstQuery.FirstOrDefault().queryPajak, @"\s+", string.Empty);
string queryPajakFromDB = Regex.Replace(queryLst.FirstOrDefault().queryPajak, @"\s+", string.Empty);
queryPajak = jsonData.items.lstQuery.FirstOrDefault().queryPajak;
string queryLampiranFromXml = Regex.Replace(jsonData.items.lstQuery.FirstOrDefault().queryLampiran, @"\s+", string.Empty);
string queryLampiranFromDB = Regex.Replace(queryLst.FirstOrDefault().queryLampiran, @"\s+", string.Empty);
if (!string.Equals(queryPajakFromDB, queryPajakFromXml, StringComparison.OrdinalIgnoreCase))
{
isQueryValid = false;
}
if (!string.Equals(queryLampiranFromXml, queryLampiranFromDB, StringComparison.OrdinalIgnoreCase))
{
isQueryValid = false;
}
if (!isQueryValid)
{
//insert tanggal_error into user_temp_error
DateTime dtmlastTime = dtTransaksi.AsEnumerable().Select(x => x.Field <DateTime>("TGL_TRANSAKSI")).FirstOrDefault();
_userActivityBusiness.InsertUserActivity(username, ip, DateTime.Now, true, "Query tidak sesuai");
log.Info("Query tidak sesuai, mohon periksa kembali. ............");
return(Response.AsJson(new { code = HttpStatusCode.InternalServerError, message = $"Error, Query tidak sesuai, mohon periksa kembali." }));
}
}
else
{
log.Info("Query pada username dan nop tersebut tidak ditemukan ............");
return(Response.AsJson(new { code = HttpStatusCode.NotFound, message = $"Error, Query pada username dan nop tersebut tidak ditemukan." }));
}
}
List <Transaction> lstTransaksi = new List <Transaction>();
//Get nama kolom tanggal transaksi
List <UserSettingColumn> lstKolomName = new List <UserSettingColumn>();
string namaKolomTanggal = string.Empty;
if (!isFromDatabase)
{
lstKolomName = _userSettingColumnBusiness.RetrieveColumnByUserNop(username, nop);
}
else
{
DataColumnCollection colTrans = dtTransaksi.Columns;
foreach (var itemKolom in colTrans)
{
UserSettingColumn userKolom = new UserSettingColumn();
userKolom.Username = username;
userKolom.Nop = nop;
userKolom.Column_Name = itemKolom.ToString();
userKolom.Column_Text = itemKolom.ToString();
lstKolomName.Add(userKolom);
}
}
namaKolomTanggal = lstKolomName.Where(m => m.Column_Name.ToUpper().Contains("TGL_TRANSAKSI")).Select(m => m.Column_Text.ToUpper()).FirstOrDefault();
List <string> namaKolomNilai = lstKolomName.Where(m => m.Column_Name.ToUpper().Contains("PAJAK")).Select(m => m.Column_Text.ToUpper()).ToList();
DataView dvTrans = dtTransaksi.DefaultView;
dvTrans.RowFilter = "NOP=" + nop;
dvTrans.Sort = namaKolomTanggal;
DataTable dtSortTransaction = dvTrans.ToTable();
DateTime tglOld = new DateTime();
double nilaiOld = 0;
bool isNopBlokir = false;
DataRow last = dtSortTransaction.Rows[dtSortTransaction.Rows.Count - 1];
string oldNop = string.Empty;
int oldMP = 0;
int oldThn = 0;
bool isOnDetail = false;
foreach (DataRow dRow in dtSortTransaction.Rows)
{
DateTime tanggal = dRow[namaKolomTanggal].AsDateTime();
int mp = tanggal.Month;
int thn = tanggal.Year;
//check sptpd is generate
if (string.Compare(oldNop, dRow["NOP"].ToString()) != 0)
{
if (oldMP != mp)
{
if (oldThn != thn)
{
isOnDetail = _sPTPDDetailBusiness.isSptpdDetailByNop(dRow["NOP"].ToString(), mp, thn);
}
}
oldNop = dRow["NOP"].ToString();
oldMP = mp;
oldThn = thn;
}
else
{
oldNop = dRow["NOP"].ToString();
oldMP = mp;
oldThn = thn;
}
if (isOnDetail)
{
lstNopBlokir.Add(dRow["NOP"].ToString());
isNopBlokir = true;
break;
}
double nilaiPajak = 0;
try
{
for (int iNilai = 0; iNilai < namaKolomNilai.Count; iNilai++)
{
if (string.Compare(namaKolomNilai[iNilai].ToString(), "-") != 0)
{
nilaiPajak += dRow[namaKolomNilai[iNilai]].AsDouble();
}
}
}
catch (Exception ex)
{
throw ex;
}
if (tglOld.Year == 1)
{
tglOld = tanggal;
nilaiOld = nilaiPajak;
if (dRow == last)
{
Transaction itemTrans = new Transaction();
itemTrans = new Transaction();
itemTrans.tanggal = tglOld;
itemTrans.total = nilaiOld;
lstTransaksi.Add(itemTrans);
break;
}
}
else
{
if (tglOld.Date == tanggal.Date)
{
if (dRow == last)
{
nilaiOld += nilaiPajak;
Transaction itemTrans = new Transaction();
itemTrans = new Transaction();
itemTrans.tanggal = tglOld;
itemTrans.total = nilaiOld;
lstTransaksi.Add(itemTrans);
break;
}
nilaiOld += nilaiPajak;
}
else
{
Transaction itemTrans = new Transaction();
itemTrans.tanggal = tglOld;
itemTrans.total = nilaiOld;
lstTransaksi.Add(itemTrans);
tglOld = tanggal.Date;
nilaiOld = nilaiPajak;
if (dRow == last)
{
itemTrans = new Transaction();
itemTrans.tanggal = tglOld;
itemTrans.total = nilaiOld;
lstTransaksi.Add(itemTrans);
}
}
}
}
if (isNopBlokir)
{
continue;
}
log.Info("inserting data to user transaction");
//cek transaction isExist
IEnumerable <UserTransaction> lstTransExist = new List <UserTransaction>();
lstTransExist = _userTransactionBusiness.RetrieveUserTransactionByMonth(username, lstTransaksi.FirstOrDefault().tanggal.Month, lstTransaksi.FirstOrDefault().tanggal.Year);
//insert into user_transaction
foreach (var item in lstTransaksi)
{
bool isExist = lstTransExist.Where(m => string.Compare(m.Tanggal.ToString("dd-MM-yyyy"), item.tanggal.ToString("dd-MM-yyyy")) == 0 &&
m.Nop.Equals(nop)).ToList().Count > 0;
try
{
if (isExist)
{
log.Info("update data from user " + username);
_userTransactionBusiness.UpdatePajakUserTransaction(username, nop, item.tanggal, item.total);
}
else
{
log.Info("insert data from user " + username);
_userTransactionBusiness.InsertUserTransaction(username, item.tanggal, item.total, ip, string.Empty, false, nop);
}
}
catch (Exception ex)
{
log.Info("insert or update error : " + ex.Message);
}
}
log.Info("inserting data to user transaction detail");
//insert into user_transaction_detail
string dir = System.IO.Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "transaction.xml");
//Replace nama kolom untuk no_invoice dan tgl_transaksi
if (!isFromDatabase)
{
List <UserSettingColumn> lstSetCol = _settingClientBusiness.RetrieveUserSettingColumn(username, nop);
string noInvoice = lstSetCol.Where(x => x.Column_Name.ToUpper().Equals("NO_INVOICE")).Select(x => x.Column_Text.ToUpper()).FirstOrDefault();
string tglTransaksi = lstSetCol.Where(x => x.Column_Name.ToUpper().Equals("TGL_TRANSAKSI")).Select(x => x.Column_Text.ToUpper()).FirstOrDefault();
dtLampiran.Columns[noInvoice].ColumnName = "NO_INVOICE";
dtLampiran.Columns[tglTransaksi].ColumnName = "TGL_TRANSAKSI";
}
string colTglName = "TGL_TRANSAKSI";
//Pecah dan simpan sesuai tanggal transaksi
#region Old Code
//string[] arrSelect = queryPajak.ToUpper().Split(new string[] { "FROM" }, StringSplitOptions.None);
//string[] arrSplit = arrSelect[0].Split(',');
//string dbColDateName = string.Empty;
//if (isFromDatabase)
//{
// foreach (string item in arrSplit)
// {
// if (item.Contains("TGL_TRANSAKSI"))
// {
// dbColDateName = item;
// break;
// }
// }
//}
//else
//{
// dbColDateName = namaKolomTanggal;
//}
//string[] arrTglName = dbColDateName.Replace("SELECT ", string.Empty).Split(' ');
//string colTglName = string.Empty;
//if (arrTglName.Count() > 1)
// colTglName = arrTglName[arrTglName.Count() - 2];
//else
// colTglName = arrTglName[0];
//if (string.IsNullOrEmpty(colTglName))
//{
// if (string.IsNullOrEmpty(queryPajak))
// colTglName = "TGL_TRANSAKSI";
//}
#endregion
//DataView dvTrans = new DataView(dtLampiran);
//dvTrans.RowFilter = $"NOP={nop}";
//DataTable dtDistDate = dvTrans.ToTable(true, colTglName);
DataTable dtTransByNop = dtLampiran.AsEnumerable().Where(m => m.Field <string>("NOP").Equals(nop)).CopyToDataTable();
DataTable dtDistDate = new DataTable();
dtDistDate.Columns.Add(colTglName, typeof(DateTime));
if (dtTransByNop.Columns[colTglName].DataType != typeof(DateTime))
{
DataTable copyTransTable = dtTransByNop.Clone();
copyTransTable.Columns[colTglName].DataType = typeof(DateTime);
foreach (DataRow item in dtTransByNop.Rows)
{
DataRow nRowTransTable = copyTransTable.NewRow();
nRowTransTable.ItemArray = item.ItemArray;
copyTransTable.Rows.Add(nRowTransTable);
}
dtTransByNop = copyTransTable;
}
DateTime oldDate = DateTime.MinValue;
foreach (DataRow item in dtTransByNop.Rows)
{
//if (Convert.ToInt32(item["NO"]) == 1168)
//{
//}
DateTime newDate = Convert.ToDateTime(item["TGL_TRANSAKSI"]).Date;
if (string.Compare(oldDate.ToString("dd-MM-yyyy"), newDate.ToString("dd-MM-yyyy")) != 0)
{
DataRow newRow = dtDistDate.NewRow();
newRow[colTglName] = newDate;
dtDistDate.Rows.Add(newRow);
oldDate = newDate;
}
}
foreach (DataRow dRow in dtDistDate.Rows)
{
DataSet ds = new DataSet();
DateTime tglTrans = DateTime.MinValue;
try
{
tglTrans = Convert.ToDateTime(dRow[colTglName], new CultureInfo(CultureInfos));
}
catch (Exception ex)
{
log.Info("Date format error......" + ex.Message);
}
DataView vw = dtTransByNop.AsDataView();
string startDate = tglTrans.ToString("MM/dd/yyyy 00:00:00", new CultureInfo("en-US"));
string endDate = tglTrans.ToString("MM/dd/yyyy 23:59:59", new CultureInfo("en-US"));
string filter = string.Format(colTglName + " >= #{0}# AND " + colTglName + "<=#{1}#",
startDate, endDate);
vw.RowFilter = filter;
ds.Tables.Add(vw.ToTable());
ds.WriteXml(dir);
string xmlString = System.IO.File.ReadAllText(dir);
string nopDetail = string.Empty;
//Cek username, nop, bulan and tahun is exist
bool isDetailExist = false;
try
{
//todo delete 1 row below List<UserTransactionDetail> lstDetail = UserTransactionDetailBusiness.RetrieveUserDetailTransactionByDateTransaction(nop, tglTrans).ToList();
List <UserTransactionDetail> lstDetail = null;
if (lstDetail != null && lstDetail.Count > 0)
{
isDetailExist = true;
}
//Delete if username, nop, bulan and tahun is exist
if (isDetailExist)
{
_userTransactionDetailBusiness.DeleteUserDetailTransaction(nop, tglTrans);
}
// insert Trasaction Detail
_userTransactionDetailBusiness.InsertUserTransactionDetail(username, dir, bulan.AsInt32(), tahun.AsInt32(), tglTrans, ip, xmlString, nop);
}
catch (Exception ex)
{
return(Response.AsJson(new { code = HttpStatusCode.MethodNotAllowed, message = "Insert trasanction detail gagal, " + ex.Message }));
}
}
}
log.Info("End : /dev/postTransactionClient");
if (lstNopBlokir != null && lstNopBlokir.Count > 0)
{
string nopBlokir = string.Empty;
foreach (var itemBlokir in lstNopBlokir)
{
nopBlokir += itemBlokir + ",";
}
nopBlokir = nopBlokir.Remove(nopBlokir.Length - 1);
return(Response.AsJson(new { code = HttpStatusCode.MethodNotAllowed, message = "nop (" + nopBlokir + ") pada masapajak tersebut, sudah tergenerate." }));
}
else
{
try
{
var connection = SignalR.Utilities.ConnectionMap.GetConnectionMap(username);
if (connection.Value.IsRequesting)
{
connection.Value.IsRequesting = false;
}
}
catch
{
}
return(Response.AsJson(new { code = HttpStatusCode.OK, message = "Transaksi berhasil tersimpan" }));
}
}
catch (System.Exception ex)
{
log.Fatal("Error: /dev/postTransactionClient", ex);
return(Response.AsJson(new { code = HttpStatusCode.InternalServerError, message = $"Error, {ex.Message}" }));
//throw;
}
};
Post["/dev/postUserActivity"] = parameter =>
{
try
{
log.Info("Start : /dev/postUserActivity");
string ip = this.Request.UserHostAddress;
log.Info($"incoming request from IP:{ip}");
string body = Nancy.IO.RequestStream.FromStream(Request.Body).AsString();
log.Info("Deserializing Object ............");
UserActivity userActivity = JsonConvert.DeserializeObject <UserActivity>(body);
DateTime dateNow = DateTime.Now;
DateTime tglClient = DateTime.MinValue;
try
{
tglClient = Convert.ToDateTime(userActivity.ActivityDate, new CultureInfo(userActivity.CultureInfos));
}
catch (Exception ex)
{
log.Info("Date format error......" + ex.Message);
}
tglClient = Convert.ToDateTime(tglClient, new CultureInfo("en-US"));
if (userActivity != null)
{
log.Info("Inserting user activity ............");
bool status = false;
if (string.Compare(userActivity.StatusError, "1") == 0)
{
status = true;
}
try
{
string ipClient = userActivity.IPClient;
if (string.IsNullOrEmpty(userActivity.IPClient))
{
ipClient = ip;
}
_userActivityBusiness.InsertUserActivity(userActivity.Username, ipClient, dateNow, status, userActivity.Keterangan);
var jsonBody = JsonConvert.SerializeObject(dateNow, Formatting.None, new IsoDateTimeConverter()
{
DateTimeFormat = "yyyy-MM-dd hh:mm:ss"
});
log.Info("End : /dev/postUserActivity");
return(Response.AsJson(new { code = HttpStatusCode.OK, message = "User Activity Berhasil tersimpan.", body = jsonBody }));
}
catch (Exception ex)
{
log.Fatal("Error : /dev/postUserActivity", ex);
return(Response.AsJson(new { code = HttpStatusCode.InternalServerError, message = $"Error, {ex.Message}" }));
}
}
else
{
log.Info("End : /dev/postUserActivity");
return(Response.AsJson(new { code = HttpStatusCode.Unauthorized, message = "Failed while deserializing object, data not found", body = string.Empty }));
}
}
catch (Exception ex)
{
log.Fatal("Error : /dev/postUserActivity", ex);
return(Response.AsJson(new { code = HttpStatusCode.InternalServerError, message = $"Error, {ex.Message}" }));
}
};
Post["/dev/RetrieveCpuId"] = Parameter =>
{
try
{
log.Info("Start : /dev/RetrieveCpuId");
string username = string.Empty;
string cpuId = string.Empty;
string body = Nancy.IO.RequestStream.FromStream(Request.Body).AsString();
log.Info("Deserializing Object ............");
string[] arrStr = body.Split(',');
if (arrStr.Count() > 0)
{
for (int iArr = 0; iArr < arrStr.Count(); iArr++)
{
username += "'" + arrStr[iArr] + "',";
}
username = username.Remove(username.Length - 1);
}
List <UserClient> lstUsr = _settingClientBusiness.RetrieveUserClient(username);
if (lstUsr != null && lstUsr.Count > 0)
{
cpuId = lstUsr.FirstOrDefault().Id_Machine;
}
log.Info("End : /dev/RetrieveCpuId");
return(Response.AsJson(new { code = HttpStatusCode.OK, message = "OK", cpuId = cpuId }));
}
catch (Exception ex)
{
log.Info("End : /dev/RetrieveCpuId");
return(Response.AsJson(new { code = HttpStatusCode.FailedDependency, message = ex.Message, cpuId = "" }));
}
};
Post["/dev/RetrieveJatuhTempo"] = parameter =>
{
try
{
log.Info("Start : /dev/RetrieveJatuhTempo");
string ip = this.Request.UserHostAddress;
log.Info($"incoming request from IP:{ip}");
string body = Nancy.IO.RequestStream.FromStream(Request.Body).AsString();
log.Info("Deserializing Object ............");
RequestDueDate dueDate = JsonConvert.DeserializeObject <RequestDueDate>(body);
string tanggal = string.Empty;
if (dueDate != null)
{
JatuhTempo jthTempo = _jatuhTempoBusiness.RetrieveJatuhTempo(dueDate.masapajak.AsInt32(), dueDate.tahunpajak.AsInt32());
if (jthTempo != null)
{
tanggal = jthTempo.Tgl_Jatuh_Tempo.ToString("dd/MM/yyyy");
log.Info("End : /dev/RetrieveJatuhTempo");
return(Response.AsJson(new { code = HttpStatusCode.OK, tanggal = tanggal }));
}
else
{
log.Info("End : /dev/RetrieveJatuhTempo");
return(Response.AsJson(new { code = HttpStatusCode.ExpectationFailed }));
}
}
else
{
log.Info("End : /dev/RetrieveJatuhTempo");
return(Response.AsJson(new { code = HttpStatusCode.Unauthorized, message = "Failed while deserializing object, data not found", body = string.Empty }));
}
}
catch (Exception ex)
{
log.Fatal("Error : /dev/RetrieveJatuhTempo", ex);
return(Response.AsJson(new { code = HttpStatusCode.InternalServerError, message = $"Error, {ex.Message}" }));
}
};
}
/// <summary>
/// 创建卡券
/// </summary>
/// <param name="accessTokenOrAppId"></param>
/// <param name="cardInfo">创建卡券需要的数据，格式可以看CardCreateData.cs</param>
/// <param name="timeOut">代理请求超时时间（毫秒）</param>
/// <returns></returns>
public static CardCreateResultJson CreateCard(string accessTokenOrAppId, BaseCardInfo cardInfo, int timeOut = Config.TIME_OUT)
{
return(ApiHandlerWapper.TryCommonApi(accessToken =>
{
var urlFormat = string.Format("https://api.weixin.qq.com/card/create?access_token={0}", accessToken);
CardCreateInfo cardData = null;
CardType cardType = cardInfo.GetCardType();
switch (cardType)
{
case CardType.GENERAL_COUPON:
cardData = new CardCreateInfo()
{
card = new Card_GeneralCoupon()
{
card_type = cardType.ToString(),
general_coupon = cardInfo as Card_GeneralCouponData
}
};
break;
case CardType.GROUPON:
cardData = new CardCreateInfo()
{
card = new Card_Groupon()
{
card_type = cardType.ToString(),
groupon = cardInfo as Card_GrouponData
}
};
break;
case CardType.GIFT:
cardData = new CardCreateInfo()
{
card = new Card_Gift()
{
card_type = cardType.ToString(),
gift = cardInfo as Card_GiftData
}
};
break;
case CardType.CASH:
cardData = new CardCreateInfo()
{
card = new Card_Cash()
{
card_type = cardType.ToString(),
cash = cardInfo as Card_CashData
}
};
break;
case CardType.DISCOUNT:
cardData = new CardCreateInfo()
{
card = new Card_DisCount()
{
card_type = cardType.ToString(),
discount = cardInfo as Card_DisCountData
}
};
break;
case CardType.MEMBER_CARD:
cardData = new CardCreateInfo()
{
card = new Card_MemberCard()
{
card_type = cardType.ToString(),
member_card = cardInfo as Card_MemberCardData
}
};
break;
case CardType.SCENIC_TICKET:
cardData = new CardCreateInfo()
{
card = new Card_ScenicTicket()
{
card_type = cardType.ToString(),
scenic_ticket = cardInfo as Card_ScenicTicketData
}
};
break;
case CardType.MOVIE_TICKET:
cardData = new CardCreateInfo()
{
card = new Card_MovieTicket()
{
card_type = cardType.ToString(),
movie_ticket = cardInfo as Card_MovieTicketData
}
};
break;
case CardType.BOARDING_PASS:
cardData = new CardCreateInfo()
{
card = new Card_BoardingPass()
{
card_type = cardType.ToString(),
boarding_pass = cardInfo as Card_BoardingPassData
}
};
break;
case CardType.LUCKY_MONEY:
cardData = new CardCreateInfo()
{
card = new Card_LuckyMoney()
{
card_type = cardType.ToString(),
lucky_money = cardInfo as Card_LuckyMoneyData
}
};
break;
case CardType.MEETING_TICKET:
cardData = new CardCreateInfo()
{
card = new Card_MeetingTicket()
{
card_type = cardType.ToString(),
meeting_ticket = cardInfo as Card_MeetingTicketData
}
};
break;
default:
break;
}
var jsonSetting = new JsonSetting(true, null,
new List <Type>()
{
//typeof (Modify_Msg_Operation),
//typeof (CardCreateInfo),
typeof(Card_BaseInfoBase) //过滤Modify_Msg_Operation主要起作用的是这个
});
var result = CommonJsonSend.Send <CardCreateResultJson>(null, urlFormat, cardData, timeOut: timeOut,
//针对特殊字段的null值进行过滤
jsonSetting: jsonSetting);
return result;
}, accessTokenOrAppId));
}
/// <summary>
/// 群机器人发送图文信息
/// </summary>
/// <param name="key">机器人Key</param>
/// <param name="data">内容</param>
/// <param name="timeOut"></param>
/// <returns></returns>
public static WorkJsonResult SendNews(string key, WebhookNews data, int timeOut = Config.TIME_OUT)
{
JsonSetting jsonSetting = new JsonSetting(true);
return(Senparc.Weixin.CommonAPIs.CommonJsonSend.Send <WorkJsonResult>(key, _urlFormat, data, CommonJsonSendType.POST, timeOut, jsonSetting: jsonSetting));
}
/// <summary>
/// 向需要AccessToken的API发送消息的公共方法
/// </summary>
/// <param name="accessToken">这里的AccessToken是通用接口的AccessToken，非OAuth的。如果不需要，可以为null，此时urlFormat不要提供{0}参数</param>
/// <param name="urlFormat"></param>
/// <param name="data">如果是Get方式，可以为null</param>
/// <param name="sendType"></param>
/// <param name="timeOut">代理请求超时时间（毫秒）</param>
/// <param name="checkValidationResult"></param>
/// <param name="jsonSetting"></param>
/// <returns></returns>
//[Obsolete("此方法已过期，请使用Senparc.Weixin.CommonAPIs.CommonJsonSend.Send()方法")]
public static WxJsonResult Send(string accessToken, string urlFormat, object data, CommonJsonSendType sendType = CommonJsonSendType.POST, int timeOut = Config.TIME_OUT, bool checkValidationResult = false, JsonSetting jsonSetting = null/*, int retry40001ErrorTimes = 0*/)
{
WxJsonResult result = null;
try
{
result = Senparc.Weixin.CommonAPIs.CommonJsonSend.Send(accessToken, urlFormat, data, sendType, timeOut,
checkValidationResult, jsonSetting);
}
//catch (ErrorJsonResultException ex)
//{
// if (ex.JsonResult.errcode == ReturnCode.获取access_token时AppSecret错误或者access_token无效 /*40001*/)
// {
// if (retry40001ErrorTimes == 0)
// {
// result = Send(accessToken, urlFormat, data, sendType, timeOut, checkValidationResult,
// jsonSetting, retry40001ErrorTimes + 1);
// }
// else if (retry40001ErrorTimes == 1)
// {
// }
// }
//}
catch
{
throw;
}
return result;
}
/// <summary>
/// 向需要AccessToken的API发送消息的公共方法
/// </summary>
/// <param name="accessToken">这里的AccessToken是通用接口的AccessToken，非OAuth的。如果不需要，可以为null，此时urlFormat不要提供{0}参数</param>
/// <param name="urlFormat">用accessToken参数填充{0}</param>
/// <param name="data">如果是Get方式，可以为null</param>
/// <param name="sendType"></param>
/// <param name="timeOut">代理请求超时时间（毫秒）</param>
/// <param name="checkValidationResult"></param>
/// <param name="jsonSetting"></param>
/// <returns></returns>
//[Obsolete("此方法已过期，请使用Senparc.Weixin.CommonAPIs.CommonJsonSend.Send<T>()方法")]
public static T Send<T>(string accessToken, string urlFormat, object data, CommonJsonSendType sendType = CommonJsonSendType.POST, int timeOut = Config.TIME_OUT, bool checkValidationResult = false, JsonSetting jsonSetting = null)
{
return Senparc.Weixin.CommonAPIs.CommonJsonSend.Send<T>(accessToken, urlFormat, data, sendType, timeOut, checkValidationResult, jsonSetting);
}
/// <summary>
/// 【异步方法】群机器人发送图文信息
/// </summary>
/// <param name="key">机器人Key</param>
/// <param name="data">内容</param>
/// <param name="timeOut"></param>
/// <returns></returns>
public static async Task <WorkJsonResult> SendNewsAsync(string key, WebhookNews data, int timeOut = Config.TIME_OUT)
{
JsonSetting jsonSetting = new JsonSetting(true);
return(await Senparc.Weixin.CommonAPIs.CommonJsonSend.SendAsync <WorkJsonResult>(key, _urlFormat, data, CommonJsonSendType.POST, timeOut, jsonSetting : jsonSetting).ConfigureAwait(false));
}
