public virtual void Validate(dynamic returnObj, params string[] validationNames)
{
if (validationNames.Length == 0)
{
var validate = false;
if (UtilRepository.IsPropertyExist(returnObj, "errcode"))
{
if (int.TryParse(returnObj.errcode, out int errcode))
{
validate = errcode == 0;
}
}
if (UtilRepository.IsPropertyExist(returnObj, "return_code"))
{
validate = returnObj.return_code == "SUCCESS";
}
if (!validate)
{
throw new BadResultException(returnObj);
}
}
validationNames.ToList().ForEach(i =>
{
if (!UtilRepository.IsPropertyExist(returnObj, i))
{
throw new BadResultException(returnObj);
}
});
}
public ServerService()
{
_serverRepository = new ServerRepository();
_gameModeRepository = new GameModeRepository();
_matchRepository = new MatchRepository();
_utilRepository = new UtilRepository();
}
public static IApplicationBuilder UseLazyWeChat(
this IApplicationBuilder app,
Action <WeChatMessager> onMessageReceived)
{
Type implementation = UtilRepository.GetImplementation(DEFAULTMESSAGEQUEUE);
return(app.UseMiddleware <LazyWeChatMiddleware>(onMessageReceived, implementation));
}
public MatchService()
{
_scoreService = new ScoreService();
_matchRepository = new MatchRepository();
_scoresRepository = new ScoreRepository();
_playerService = new PlayerService();
_mapService = new MapService();
_utilRepository = new UtilRepository();
}
private async Task <dynamic> RequestUploadAPI(
string fullFilePath, string requestAPIUrl, MediaType mediaType, string formName = "file", string additionInfo = "")
{
string requestUrl = await ValidateMaterial(fullFilePath, requestAPIUrl, mediaType);
var returnJson = await _httpRepository.UploadFileAsync(requestUrl, fullFilePath, formName, additionInfo);
var returnObject = UtilRepository.ParseAPIResult(returnJson);
return(returnObject);
}
public virtual async Task <dynamic> UploadKFAvatarAsync(string kf_account, string avatarFilePath)
{
var access_token = await _lazyWeChatBasic.GetAccessTokenAsync();
var requestUrl = string.Format(CONSTANT.UPLOADKFAVATARURL, access_token, kf_account);
var returnJson = await _httpRepository.UploadFileAsync(requestUrl, avatarFilePath);
var returnObject = UtilRepository.ParseAPIResult(returnJson);
return(returnObject);
}
public virtual async Task <dynamic> UploadImgMaterialAsync(string fullImgFilePath)
{
var accessToken = await GetAccessTokenAsync();
var url = string.Format(CONSTANT.UPLOADIMGURL, accessToken);
var returnJson = await _httpRepository.UploadFileAsync(url, fullImgFilePath);
var returnObject = UtilRepository.ParseAPIResult(returnJson);
_httpRepository.Validate(returnObject, "url");
return(returnObject);
}
private dynamic Pasre(string content)
{
dynamic returnObject = new ExpandoObject();
if (content.StartsWith("{") && content.EndsWith("}"))
{
returnObject = UtilRepository.ParseAPIResult(content);
}
else
{
returnObject = content.FromXml().ToDynamic();
}
return(returnObject);
}
public virtual async Task <object> GetTempMaterialAsync(string media_id)
{
var access_token = await GetAccessTokenAsync();
var url = string.Format(CONSTANT.GETTEMPMATERIALURL, access_token, media_id);
var res = await _httpRepository.GetAsync(url);
if (res.Contains("video_url"))
{
var returnObject = UtilRepository.ParseAPIResult(res);
return(returnObject);
}
else
{
byte[] byteArray = Encoding.Default.GetBytes(res);
return(byteArray);
}
}
public BadResultException(dynamic obj)
{
if (UtilRepository.IsPropertyExist(obj, "errcode") &&
UtilRepository.IsPropertyExist(obj, "errmsg"))
{
if (!int.TryParse(obj.errcode.ToString(), out _errcode))
{
_message = $"invlid errcode:{obj.errcode}";
}
else
{
_message = $"wechat API return unsuccessful result:errcode('{_errcode}'),errmsg('{obj.errmsg}')";
}
}
else
{
_message = $"invalid error message format:{JsonConvert.SerializeObject(obj)}";
}
}
public virtual async Task <string> GenerateWXConfigScriptAsync(
string requestUrl,
bool debug,
params string[] jsApiList)
{
if (jsApiList == null || jsApiList.Length == 0)
{
throw new ArgumentNullException(nameof(jsApiList));
}
string script = @"
wx.config({{
debug: {0},
appId: '{1}',
timestamp: {2},
nonceStr: '{3}',
signature: '{4}',
jsApiList: [
{5}
]
}});
";
StringBuilder api = new StringBuilder();
jsApiList.ToList().ForEach(i => api.Append($"'{i}',"));
var apiList = api.ToString();
var appId = _options.Value.AppID;
var noncestr = _options.Value.NonceStr;
var timestamp = _options.Value.Timestamp;
var jsTicket = await GetJSTicketAsync();
var signature = UtilRepository.GenerateSignature(noncestr, timestamp, requestUrl, jsTicket, out string outString);
_logger.LogInformation($"noncestr:{noncestr},timestamp:{timestamp},requestUrl:{requestUrl},jsTicket:{jsTicket},signature:{signature},outString:{outString}");
script = string.Format(script, debug.ToString().ToLower(), appId, timestamp, noncestr, signature, apiList.Substring(0, apiList.Length - 1));
return(script);
}
public virtual async Task <string> PostAsync(string url, string requestContent)
{
dynamic resultObject = new ExpandoObject();
resultObject.requestID = UtilRepository.GenerateRandomCode();
resultObject.method = "POST";
resultObject.url = url;
resultObject.requestContent = requestContent;
resultObject.createdAt = DateTime.Now.ToString();
string json = "";
using (var client = _clientFactory.CreateClient())
{
using (HttpContent httpContent = new StringContent(requestContent))
{
httpContent.Headers.ContentType = new MediaTypeHeaderValue("application/json");
var response = await client.PostAsync(url, httpContent);
if (response.IsSuccessStatusCode)
{
var content = await response.Content.ReadAsStringAsync();
resultObject.result = "success";
resultObject.resultContent = content;
json = JsonConvert.SerializeObject(resultObject);
_logger.LogInformation(json);
return(content);
}
else
{
resultObject.result = "fail";
resultObject.resultContent = "BadHttpResponseException";
json = JsonConvert.SerializeObject(resultObject);
_logger.LogInformation(json);
throw new BadHttpResponseException(url, response.StatusCode);
}
}
}
}
public virtual async Task <object> GetMaterialAsync(string media_id)
{
dynamic requestObject = new ExpandoObject();
requestObject.media_id = media_id;
var access_token = await _lazyWeChatBasic.GetAccessTokenAsync();
var url = string.Format(CONSTANT.GETMATERIALURL, access_token, media_id);
var json = JsonConvert.SerializeObject(requestObject);
string res = await _httpRepository.PostAsync(url, json);
if (res.Contains("down_url") || res.Contains("news_item"))
{
var returnObject = UtilRepository.ParseAPIResult(res);
return(returnObject);
}
else
{
byte[] byteArray = Encoding.Default.GetBytes(res);
return(byteArray);
}
}
public virtual async Task <string> GetAsync(string url)
{
dynamic resultObject = new ExpandoObject();
resultObject.requestID = UtilRepository.GenerateRandomCode();
resultObject.method = "GET";
resultObject.url = url;
resultObject.createdAt = DateTime.Now.ToString();
string json = "";
using (var client = _clientFactory.CreateClient())
{
var response = await client.GetAsync(url);
resultObject.statusCode = response.StatusCode;
if (response.IsSuccessStatusCode)
{
var content = await response.Content.ReadAsStringAsync();
resultObject.result = "success";
resultObject.resultContent = content;
json = JsonConvert.SerializeObject(resultObject);
_logger.LogInformation(json);
return(content);
}
else
{
resultObject.result = "fail";
resultObject.resultContent = "BadHttpResponseException";
json = JsonConvert.SerializeObject(resultObject);
_logger.LogInformation(json);
throw new BadHttpResponseException(url, response.StatusCode);
}
}
}
public async Task InvokeAsync(HttpContext context)
{
var request = context.Request;
if (request.Path.Value.Contains(_options.Value.LazyWechatListener))
{
bool validation = Validate(out string signature, out string timestamp, out string nonce, out string echostr);
var info = "signature:{0},timestamp:{1},nonce:{2},echostr:{3} received from wechat at {4}";
_logger.LogInformation(info, signature, timestamp, nonce, echostr, DateTime.Now);
var weChatMessager = new WeChatMessager
{
signature = signature,
timestamp = timestamp,
nonce = nonce,
echostr = echostr,
validation = validation,
type = _options.Value.Type,
method = context.Request.Method
};
#region 以stream的方式获取微信post到监听程序的数据:数据类型为XML
var inputContent = "";
using (StreamReader stream = new StreamReader(request.Body, Encoding.UTF8))
{
inputContent = await stream.ReadToEndAsync();
}
#endregion
info = "inputXml:'{0}' received from wechat at {1}";
_logger.LogInformation(info, inputContent, DateTime.Now);
var encrypted = false;
if (!string.IsNullOrEmpty(inputContent))
{
dynamic messageBody = new ExpandoObject();
messageBody = ParseMessage(inputContent, out MessageFormat format);
weChatMessager.format = format;
if (UtilRepository.IsPropertyExist(messageBody, "Encrypt"))
{
string decryptedMessage = Cryptography.AES_decrypt(messageBody.Encrypt, _options.Value.EncodingAESKey);
messageBody = ParseMessage(decryptedMessage, out _);
encrypted = true;
}
weChatMessager.messageBody = messageBody;
if (UtilRepository.IsPropertyExist(messageBody, "FromUserName"))
{
_onMessageReceived?.Invoke(weChatMessager);
}
var json = JsonConvert.SerializeObject(weChatMessager);
_ = _messageQueue.Push(json);
info = "json format of message:'{0}' has been pushed into queue at {1}";
_logger.LogInformation(info, json, DateTime.Now);
}
var message = weChatMessager.message;
if (encrypted && message.ToLower() != "success")
{
var encryptMessage = Cryptography.AES_encrypt(weChatMessager.message, _options.Value.EncodingAESKey, _options.Value.AppID);
var signatureResponse = generateSignature(timestamp, nonce, encryptMessage);
message = string.Format(MessageTemplateFactory.CreateInstance(weChatMessager.format == MessageFormat.Xml ? MessageType.Encrypt : MessageType.EncryptJson), encryptMessage, signatureResponse, timestamp, nonce);
}
info = "sent message:'{0}' has been logged at {1}";
_logger.LogInformation(info, message, DateTime.Now);
await context.Response.WriteAsync(message);
}
else
{
await _next(context);
}
bool Validate(out string signature, out string timestamp, out string nonce, out string echostr)
{
#region 微信在向监听程序发送数据的时候会同时发送signature,timestamp,nonce以及echostr供用户判断该请求是否来自微信端
signature = string.IsNullOrEmpty(request.Query["signature"]) ? "" : request.Query["signature"].ToString();
timestamp = string.IsNullOrEmpty(request.Query["timestamp"]) ? "" : request.Query["timestamp"].ToString();
nonce = string.IsNullOrEmpty(request.Query["nonce"]) ? "" : request.Query["nonce"].ToString();
echostr = string.IsNullOrEmpty(request.Query["echostr"]) ? "" : request.Query["echostr"].ToString();
#endregion
List <string> lstSort = new List <string> {
_options.Value.Token, timestamp, nonce
};
lstSort.Sort();
var sha1 = string.Join(string.Empty, lstSort).SHA1();
var validation = (sha1.ToUpper() == signature.ToUpper());
return(validation);
}
string generateSignature(string timestamp, string nonce, string encryptMessage)
{
ArrayList AL = new ArrayList();
AL.Add(_options.Value.Token);
AL.Add(timestamp);
AL.Add(nonce);
AL.Add(encryptMessage);
AL.Sort(new DictionarySort());
string raw = "";
for (int i = 0; i < AL.Count; ++i)
{
raw += AL[i];
}
SHA1 sha;
ASCIIEncoding enc;
string hash = "";
sha = new SHA1CryptoServiceProvider();
enc = new ASCIIEncoding();
byte[] dataToHash = enc.GetBytes(raw);
byte[] dataHashed = sha.ComputeHash(dataToHash);
hash = BitConverter.ToString(dataHashed).Replace("-", "");
hash = hash.ToLower();
return(hash);
}
dynamic ParseMessage(string inputContent, out MessageFormat format)
{
inputContent = inputContent.Trim().Replace("\n", "");
dynamic messageBody = new ExpandoObject();
if (inputContent.StartsWith("<") && inputContent.EndsWith(">"))
{
messageBody = UtilRepository.ParseAPIResult(JsonConvert.SerializeObject(inputContent.FromXml()));
format = MessageFormat.Xml;
}
else if (inputContent.StartsWith("{") && inputContent.EndsWith("}"))
{
messageBody = UtilRepository.ParseAPIResult(inputContent);
format = MessageFormat.Json;
}
else
{
throw new ArgumentException(nameof(inputContent));
}
return(messageBody);
}
}
string HttpUploadFile(string url, string path, string formName = "file", string additionInfo = "")
{
dynamic resultObject = new ExpandoObject();
resultObject.requestID = UtilRepository.GenerateRandomCode();
resultObject.method = "POST";
resultObject.url = url;
resultObject.requestContent = path;
resultObject.createdAt = DateTime.Now.ToString();
string content = "";
try
{
#region Upload
HttpWebRequest request = WebRequest.Create(url) as HttpWebRequest;
CookieContainer cookieContainer = new CookieContainer();
request.CookieContainer = cookieContainer;
request.AllowAutoRedirect = true;
request.Method = "POST";
string boundary = DateTime.Now.Ticks.ToString("X"); // 随机分隔线
request.ContentType = "multipart/form-data;charset=utf-8;boundary=" + boundary;
byte[] itemBoundaryBytes = Encoding.UTF8.GetBytes("\r\n--" + boundary + "\r\n");
byte[] endBoundaryBytes = Encoding.UTF8.GetBytes("\r\n--" + boundary + "--\r\n");
int pos = path.LastIndexOf("\\");
string fileName = path.Substring(pos + 1);
StringBuilder sbHeader = new StringBuilder(string.Format("Content-Disposition:form-data;name=\"" + formName + "\";filename=\"{0}\"\r\nContent-Type:application/octet-stream\r\n\r\n", fileName));
byte[] postHeaderBytes = Encoding.UTF8.GetBytes(sbHeader.ToString());
FileStream fs = new FileStream(path, FileMode.Open, FileAccess.Read);
byte[] bArr = new byte[fs.Length];
fs.Read(bArr, 0, bArr.Length);
fs.Close();
Stream postStream = request.GetRequestStream();
postStream.Write(itemBoundaryBytes, 0, itemBoundaryBytes.Length);
postStream.Write(postHeaderBytes, 0, postHeaderBytes.Length);
postStream.Write(bArr, 0, bArr.Length);
byte[] bSplit = Encoding.UTF8.GetBytes("--" + boundary + "\r\n");
postStream.Write(bSplit, 0, bSplit.Length);
if (!string.IsNullOrEmpty(additionInfo))
{
byte[] additionBytes = Encoding.UTF8.GetBytes("Content-Disposition: form-data; name=\"description\";\r\n\r\n");
postStream.Write(additionBytes, 0, additionBytes.Length);
byte[] additionContentBytes = Encoding.UTF8.GetBytes(additionInfo);
postStream.Write(additionContentBytes, 0, additionContentBytes.Length);
postStream.Write(endBoundaryBytes, 0, endBoundaryBytes.Length);
}
postStream.Close();
HttpWebResponse response = request.GetResponse() as HttpWebResponse;
Stream instream = response.GetResponseStream();
StreamReader sr = new StreamReader(instream, Encoding.UTF8);
content = sr.ReadToEnd();
#endregion
resultObject.result = "success";
resultObject.resultContent = content;
string json = JsonConvert.SerializeObject(resultObject);
_logger.LogInformation(json);
}
catch (Exception ex)
{
resultObject.result = "fail";
resultObject.resultContent = ex.Message;
string json = JsonConvert.SerializeObject(resultObject);
_logger.LogInformation(json);
throw ex;
}
return(content);
}
