async Task <string> upload_firstChunk(string uuid, PartViewStream pvs, long iblock, string uploadToken, string host, string keyname)
{
var uploadUrl = host + $"/mkblk/{block_size}/{iblock}";
HttpWebRequest req = WebRequest.CreateHttp(uploadUrl);
req.Method = "POST";
req.Headers.Add("Authorization", uploadToken);
req.Headers.Add("UploadBatch", uuid);
req.ContentLength = pvs.Length;
req.ContentType = "application/octet-stream";
var reqStream = await req.GetRequestStreamAsync();
pvs.BlockCopyTo(reqStream);
reqStream.Close();
var resp = (HttpWebResponse)await req.GetResponseAsync();
var respStream = resp.GetResponseStream();
var sr = new StreamReader(respStream);
var retjson = sr.ReadToEnd();
sr.Close();
resp.Close();
req.Abort();
Newtonsoft.Json.Linq.JObject json = Newtonsoft.Json.Linq.JObject.Parse(retjson);
if (!json.ContainsKey("ctx"))
{
return(null);
}
return(json["ctx"].ToString());
}
protected void AddKeyToJson(Newtonsoft.Json.Linq.JObject Destination, string _KeyName, BPrimitiveType _KeyValue)
{
if (Destination != null && !Destination.ContainsKey(_KeyName))
{
Destination[_KeyName] = FromBPrimitiveTypeToJToken(_KeyValue);
}
}
public static DTO.QueryComposer.QueryComposerResponseDTO DeserializeResponse(string json)
{
Newtonsoft.Json.Linq.JObject obj = Newtonsoft.Json.Linq.JObject.Parse(json.Trim());
var serializationSettings = new Newtonsoft.Json.JsonSerializerSettings();
serializationSettings.Converters.Add(new DTO.QueryComposer.QueryComposerResponsePropertyDefinitionConverter());
serializationSettings.DefaultValueHandling = Newtonsoft.Json.DefaultValueHandling.IgnoreAndPopulate;
Newtonsoft.Json.JsonSerializer serializer = Newtonsoft.Json.JsonSerializer.Create(serializationSettings);
if (obj.ContainsKey("SchemaVersion"))
{
return(obj.ToObject <DTO.QueryComposer.QueryComposerResponseDTO>(serializer));
}
var queryResponse = obj.ToObject <DTO.QueryComposer.QueryComposerResponseQueryResultDTO>(serializer);
var response = new DTO.QueryComposer.QueryComposerResponseDTO
{
Header = new QueryComposerResponseHeaderDTO {
ID = queryResponse.ID,
},
Errors = Enumerable.Empty <QueryComposerResponseErrorDTO>(),
Queries = new[] { queryResponse }
};
response.RefreshQueryDates();
response.RefreshErrors();
return(response);
}
public dynamic DeleteCategory([FromBody] Newtonsoft.Json.Linq.JObject data)
{
if (!data.ContainsKey("categoryId"))
{
return("Category ID require");
}
string categoryId = data["categoryId"].ToString();
string response = "";
Dictionary <string, string> parameters = new Dictionary <string, string>();
WebExceptionStatus webExceptionStatus;
parameters.Add("categoryId", categoryId);
SendRequest(ApiLink, DeleteCategoryMethod, "POST", parameters, out response, out webExceptionStatus);
if (webExceptionStatus != WebExceptionStatus.Success)
{
try
{
ErrorMessage msg = Newtonsoft.Json.JsonConvert.DeserializeObject <ErrorMessage>(response);
return(msg);
}
catch
{
return(response);
}
}
else
{
return("OK");
}
}
public static async Task <UserToken> RefreshToken(UserToken token)
{
var parameters = new RefreshTokenRequestParameters(token.RefreshToken);
HttpClient client = new HttpClient();
client.BaseAddress = new Uri("https://api.imgur.com");
string result = "";
using (HttpRequestMessage message = new HttpRequestMessage(HttpMethod.Post, "oauth2/token"))
{
message.Content = new StringContent(JsonConvert.SerializeObject(parameters));
try
{
var response = await client.SendAsync(message);
result = await response.Content.ReadAsStringAsync();
}
catch (HttpRequestException ex)
{
throw new OAuthFailedException(OAuthFailureReason.NetworkException, "Network error occured while refreshing access token.", ex);
}
}
string accessToken = null;
string refreshToken = null;
int expiresIn = 0;
using (StringReader stringReader = new StringReader(result))
{
Newtonsoft.Json.Linq.JObject obj = Newtonsoft.Json.Linq.JObject.Parse(await stringReader.ReadToEndAsync());
if (obj.ContainsKey("access_token"))
{
accessToken = (string)obj["access_token"];
refreshToken = (string)obj["refresh_token"];
expiresIn = (int)obj["expires_in"];
}
}
if (accessToken == null)
{
throw new OAuthFailedException(OAuthFailureReason.PermissionDenied, "The authorization has been revoked.");
}
else
{
return(new UserToken()
{
UserId = token.UserId,
Username = token.Username,
AccessToken = accessToken,
RefreshToken = refreshToken,
ExpireTime = DateTime.Now + new TimeSpan(0, 0, expiresIn)
});
}
}
private static APIResult <T> GetObjectFromJson <T>(string objectString)
{
string details = "";
T obj;
objectString = objectString.Replace("_", string.Empty);
Newtonsoft.Json.Linq.JObject json = Newtonsoft.Json.Linq.JObject.Parse(objectString);
if (json.ContainsKey(Program.ADDITIONAL_INFO_KEY))
{
details = json.GetValue(Program.ADDITIONAL_INFO_KEY).ToString();
}
obj = JsonConvert.DeserializeObject <T>(objectString);
return(new APIResult <T>(obj, details));
}
public dynamic UpdateCategory([FromBody] Newtonsoft.Json.Linq.JObject data)
{
if (!data.ContainsKey("category"))
{
return("Category require");
}
Category category = Newtonsoft.Json.JsonConvert.DeserializeObject <Category>(data["category"].ToString());
if (string.IsNullOrEmpty(category.CategoryName))
{
return("Category name require");
}
if (string.IsNullOrEmpty(category.CategoryId))
{
return("Category ID require");
}
string response = "";
Dictionary <string, string> parameters = new Dictionary <string, string>();
WebExceptionStatus webExceptionStatus;
parameters.Add("category", Newtonsoft.Json.JsonConvert.SerializeObject(category));
SendRequest(ApiLink, UpdateCategoryMethod, "POST", parameters, out response, out webExceptionStatus);
ErrorMessage msg = new ErrorMessage();
if (webExceptionStatus != WebExceptionStatus.Success)
{
try
{
msg = Newtonsoft.Json.JsonConvert.DeserializeObject <ErrorMessage>(response);
return(msg);
}
catch
{
return(response);
}
}
else
{
return("OK");
}
}
private async Task <string> upload_restChunk(string uuid, PartViewStream pvs, string ctx, string uploadToken, string host, int ichunk, string keyname)
{
///POST /bput/<ctx>/<nextChunkOffset>
///Host: <UploadDomain>
///Authorization:<UploadToken>
///Content-Length:<ChunkSize>
///Content-Type:application/octet-stream
///UploadBatch:<uuid>
///Key:<key>
///
///<ChunkBinary>
var uploadUrl = host + $"/bput/{ctx}/{ichunk * chunk_size}";
HttpWebRequest req = WebRequest.CreateHttp(uploadUrl);
req.Method = "POST";
//req.Headers.Add("Qingzhen-Token", recentToken);
req.ContentLength = pvs.Length;
req.Headers.Add("Authorization", uploadToken);
req.ContentType = "application/octet-stream";
req.Headers.Add("UploadBatch", uuid);
//req.Headers.Add("Key", UrlSafeBase64.encode(keyname));
var reqStream = await req.GetRequestStreamAsync();
//await pvs.CopyToAsync(reqStream);
// CopyTo(reqSteam) 使用在这个请求里可能发生异常，故用自己写的BlockCopyTo
pvs.BlockCopyTo(reqStream);
reqStream.Close();
HttpWebResponse resp = (HttpWebResponse)await req.GetResponseAsync();
var respStream = resp.GetResponseStream();
var sr = new StreamReader(respStream);
var retjson = await sr.ReadToEndAsync();
sr.Close();
resp.Close();
req.Abort();
Newtonsoft.Json.Linq.JObject json = Newtonsoft.Json.Linq.JObject.Parse(retjson);
if (!json.ContainsKey("ctx"))
{
return(null);
}
return(json["ctx"].ToString());
}
protected override Condition Create(Type objectType, Newtonsoft.Json.Linq.JObject jObject)
{
foreach (var assembly in AppDomain.CurrentDomain.GetAssemblies())
{
foreach (Type t in assembly.GetTypes())
{
if (t.IsSubclassOf(typeof(Condition)))
{
var name = jObject.ContainsKey("name") ? jObject.Value <string>("name") : jObject.Value <string>("Name");
if (!t.IsGenericTypeDefinition && name == ((Condition)Activator.CreateInstance(t)).Name)
{
return((Condition)Activator.CreateInstance(t));
}
}
}
}
throw new Exception("Routed request configuration was not found");
}
static StackObject *ContainsKey_2(ILIntepreter __intp, StackObject *__esp, IList <object> __mStack, CLRMethod __method, bool isNewObj)
{
ILRuntime.Runtime.Enviorment.AppDomain __domain = __intp.AppDomain;
StackObject *ptr_of_this_method;
StackObject *__ret = ILIntepreter.Minus(__esp, 2);
ptr_of_this_method = ILIntepreter.Minus(__esp, 1);
System.String @propertyName = (System.String) typeof(System.String).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack));
__intp.Free(ptr_of_this_method);
ptr_of_this_method = ILIntepreter.Minus(__esp, 2);
Newtonsoft.Json.Linq.JObject instance_of_this_method = (Newtonsoft.Json.Linq.JObject) typeof(Newtonsoft.Json.Linq.JObject).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack));
__intp.Free(ptr_of_this_method);
var result_of_this_method = instance_of_this_method.ContainsKey(@propertyName);
__ret->ObjectType = ObjectTypes.Integer;
__ret->Value = result_of_this_method ? 1 : 0;
return(__ret + 1);
}
public void awsLambdaHandler(Stream inputStream)
{
Console.WriteLine("starting via lambda");
string argument = "create-and-post-appraisal-for-lambda";
using (StreamReader reader = new StreamReader(inputStream, System.Text.Encoding.UTF8))
{
string inputString = reader.ReadToEnd();
Console.WriteLine("Input: " + inputString);
Newtonsoft.Json.Linq.JObject jsonObject = Newtonsoft.Json.Linq.JObject.Parse(inputString);
if (jsonObject.ContainsKey("argument"))
{
argument = jsonObject.Value <string>("argument");
}
}
Console.WriteLine("Argument: " + argument);
Main(new string[] { argument });
}
public dynamic ExecuteCustomScriptQuery([FromBody] Newtonsoft.Json.Linq.JObject data)
{
if (!data.ContainsKey("script"))
{
return("Script require");
}
string script = data["script"].ToString();
string response = "";
Dictionary <string, string> parameters = new Dictionary <string, string>();
WebExceptionStatus webExceptionStatus;
parameters.Add("script", script);
SendRequest(ApiLink, ExecuteCustomScriptQueryMethod, "POST", parameters, out response, out webExceptionStatus);
ErrorMessage msg = new ErrorMessage();
if (webExceptionStatus != WebExceptionStatus.Success)
{
try
{
msg = Newtonsoft.Json.JsonConvert.DeserializeObject <ErrorMessage>(response);
return(msg);
}
catch
{
return(response);
}
}
else
{
return(Newtonsoft.Json.JsonConvert.DeserializeObject(response));
}
}
/// <summary>
/// Deserializes a request, it will convert a previous schema version to the current RequestDTO.
/// </summary>
/// <param name="json">The json to deserialize to a <see cref="DTO.QueryComposer.QueryComposerRequestDTO"/>.</param>
/// <returns></returns>
public static DTO.QueryComposer.QueryComposerRequestDTO DeserializeRequest(string json)
{
Newtonsoft.Json.Linq.JObject obj = Newtonsoft.Json.Linq.JObject.Parse(json.Trim());
var serializationSettings = new Newtonsoft.Json.JsonSerializerSettings();
serializationSettings.Converters.Add(new DTO.QueryComposer.QueryComposerResponsePropertyDefinitionConverter());
serializationSettings.DefaultValueHandling = Newtonsoft.Json.DefaultValueHandling.IgnoreAndPopulate;
Newtonsoft.Json.JsonSerializer serializer = Newtonsoft.Json.JsonSerializer.Create(serializationSettings);
if (obj.ContainsKey("SchemaVersion"))
{
return(obj.ToObject <DTO.QueryComposer.QueryComposerRequestDTO>(serializer));
}
var query = obj.ToObject <DTO.QueryComposer.QueryComposerQueryDTO>(serializer);
var requestDTO = new DTO.QueryComposer.QueryComposerRequestDTO
{
Header = new DTO.QueryComposer.QueryComposerRequestHeaderDTO
{
ID = query.Header.ID,
Name = query.Header.Name,
Description = query.Header.Description,
DueDate = query.Header.DueDate,
Priority = query.Header.Priority,
SubmittedOn = query.Header.SubmittedOn,
ViewUrl = query.Header.ViewUrl
},
Queries = new[] {
query
}
};
return(requestDTO);
}
private async Task <bool> upload_mkfile(string uuid, long fileSize, List <string> ctxs, string host, string uploadToken)
{
///POST /mkfile/<fileSize>/<UserParam>/<encodedUserVars>
///Host: <UploadDomain>
///Authorization:<UploadToken>
///Content-Length:<ctxListSize>
///Content-Type:text/plain;charset=UTF-8
///UploadBatch:<uuid>
///Key:<key>
///MimeType:<mimeType>
///Deadline:<Deadline>
///
///<ctxList>
var uploadUrl = host + $"/mkfile/{fileSize}";
HttpWebRequest req = WebRequest.CreateHttp(uploadUrl);
req.Method = "POST";
req.Headers.Add("Qingzhen-Token", recentToken);
//req.Host = host;
req.Headers.Add("Authorization", uploadToken);
var sb = new StringBuilder();
foreach (var ctx in ctxs)
{
sb.Append(ctx).Append(',');
}
sb.Length = sb.Length - 1;
var tt = sb.ToString();
var buf = System.Text.Encoding.UTF8.GetBytes(tt);
req.ContentLength = buf.Length;
req.ContentType = "text/plain;charset=UTF-8";
req.Headers.Add("UploadBatch", uuid);
//req.Headers.Add("Deadline", "30"); //文件保存期限。
var reqStream = await req.GetRequestStreamAsync();
await reqStream.WriteAsync(buf);
reqStream.Close();
HttpWebResponse resp = null;
try
{
resp = (HttpWebResponse)await req.GetResponseAsync();
}
catch (Exception e)
{
System.Windows.MessageBox.Show(e.Message);
}
var respStream = resp.GetResponseStream();
var sr = new StreamReader(respStream);
var retjson = sr.ReadToEnd();
sr.Close();
resp.Close();
req.Abort();
Newtonsoft.Json.Linq.JObject json = Newtonsoft.Json.Linq.JObject.Parse(retjson);
if (!json.ContainsKey("response"))
{
return(false);
}
return(true);
}
public async void upload_stream_fore2(string host, System.IO.Stream stream, string name, string folder_id, string uploadToken)
{
/// POST /mkblk/<blockSize>/<blockOrder>
/// Host: <UploadDomain>
/// Authorization:<UploadToken>
/// Content-Length:<firstChunkSize>
/// Content-Type:application/octet-stream
/// UploadBatch:<uuid>
/// Key:<key>
///
/// <firstChunkBinary>
//const int block_size = 4 * 1024 * 1024;
var uploadUrl = $"/mkblk/{stream.Length}/0";
HttpRequestMessage req = new HttpRequestMessage(HttpMethod.Post, host + uploadUrl);
//req.Version = System.Net.HttpVersion.Version10;
//req.Headers.Add("Host", host);
//req.Headers.Host = host;
req.Content = new StreamContent(stream);
req.Headers.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue(uploadToken);
req.Headers.Add("UploadBatch", System.Guid.NewGuid().ToString());
//req.Headers.Add("Key", "<key>");
//req.Content.Headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue("application/octet-stream");
var result = await _hc.SendAsync(req, HttpCompletionOption.ResponseHeadersRead);
var retjson = result.Content.ReadAsStringAsync().Result;
Newtonsoft.Json.Linq.JObject json = Newtonsoft.Json.Linq.JObject.Parse(retjson);
bool ok = json.ContainsKey("ctx");
return;
///
///bool ok = json["ctx"].ToObject<int>() == 1;
///
///var dataContent = new MultipartFormDataContent()
///{
/// { new StringContent($"file"), "name" },
/// { new StringContent($"{uploadToken}"), "token" },
/// { new StringContent("application/octet-stream"), "type" }
///
///};
///
///var sc = new StreamContent(stream);
///String headerValue = $"form-data; name=\"upload_file\"; filename=\"{name}\"";
///byte[] bytes = Encoding.UTF8.GetBytes(headerValue);
///headerValue = "";
///foreach (byte b in bytes)
/// headerValue += (Char)b;
///sc.Headers.Add("Content-Disposition", headerValue);
///dataContent.Add(sc);
///try
///{
/// HttpRequestMessage req = new HttpRequestMessage(HttpMethod.Post, uploadUrl);
/// req.Version = System.Net.HttpVersion.Version10;
/// var result = await _hc.SendAsync(req, HttpCompletionOption.ResponseHeadersRead);
/// var retjson = result.Content.ReadAsStringAsync().Result;
/// Newtonsoft.Json.Linq.JObject json = Newtonsoft.Json.Linq.JObject.Parse(retjson);
/// bool ok = json["zt"].ToObject<int>() == 1;
///
/// if (ok)
/// return ;
///}
///catch (Exception e)
///{
/// var t = e.Message.Length;
///}
}
private void AddSuperchargerState(Newtonsoft.Json.Linq.JObject suc, ArrayList send)
{
int sucID = int.MinValue;
bool SuCfound = GetSuperchargerByName(suc["name"].ToString(), out sucID);
dynamic location = suc["location"];
double lat = location["lat"];
double lng = location["long"];
if (!SuCfound)
{
// add new entry to supercharger list in DB
sucID = AddNewSupercharger(suc["name"].ToString(), lat, lng);
}
if (suc.ContainsKey("available_stalls") &&
suc.ContainsKey("total_stalls") &&
suc.ContainsKey("site_closed") &&
bool.TryParse(suc["site_closed"].ToString(), out bool site_closed) &&
site_closed == false)
{
Tools.DebugLog($"SuC: <{suc["name"]}> <{suc["available_stalls"]}> <{suc["total_stalls"]}>");
if (int.TryParse(suc["available_stalls"].ToString(), out int available_stalls) &&
int.TryParse(suc["total_stalls"].ToString(), out int total_stalls))
{
if (total_stalls > 0)
{
if (!ContainsSupercharger(send, suc["name"].ToString()))
{
Dictionary <string, object> sendKV = new Dictionary <string, object>();
send.Add(sendKV);
sendKV.Add("n", suc["name"]);
sendKV.Add("lat", lat);
sendKV.Add("lng", lng);
sendKV.Add("ts", DateTime.UtcNow.ToString("s", Tools.ciEnUS));
sendKV.Add("a", available_stalls);
sendKV.Add("t", total_stalls);
using (MySqlConnection con = new MySqlConnection(DBHelper.DBConnectionstring))
{
con.Open();
// find internal ID of supercharger by name
using (MySqlCommand cmd = new MySqlCommand(@"
INSERT
superchargerstate(
nameid,
ts,
available_stalls,
total_stalls
)
VALUES(
@nameid,
@ts,
@available_stalls,
@total_stalls
)", con))
{
cmd.Parameters.AddWithValue("@nameid", sucID);
cmd.Parameters.AddWithValue("@ts", DateTime.Now);
cmd.Parameters.AddWithValue("@available_stalls", available_stalls);
cmd.Parameters.AddWithValue("@total_stalls", total_stalls);
SQLTracer.TraceNQ(cmd);
}
con.Close();
}
}
}
else
{
// TODO how do we handle total_stalls == 0 ?
}
}
}
else if (suc.ContainsKey("site_closed") &&
bool.TryParse(suc["site_closed"].ToString(), out site_closed) &&
site_closed)
{
Tools.DebugLog($"SuC: <{suc["name"]}> site_closed");
if (!ContainsSupercharger(send, suc["name"].ToString()))
{
Dictionary <string, object> sendKV = new Dictionary <string, object>();
send.Add(sendKV);
sendKV.Add("n", suc["name"]);
sendKV.Add("lat", lat);
sendKV.Add("lng", lng);
sendKV.Add("ts", DateTime.UtcNow.ToString("s", Tools.ciEnUS));
sendKV.Add("a", -1);
sendKV.Add("t", -1);
using (MySqlConnection con = new MySqlConnection(DBHelper.DBConnectionstring))
{
con.Open();
// find internal ID of supercharger by name
using (MySqlCommand cmd = new MySqlCommand("INSERT superchargerstate (nameid, ts, available_stalls, total_stalls) values (@nameid, @ts, @available_stalls, @total_stalls) ", con))
{
cmd.Parameters.AddWithValue("@nameid", sucID);
cmd.Parameters.AddWithValue("@ts", DateTime.Now);
cmd.Parameters.AddWithValue("@available_stalls", -1);
cmd.Parameters.AddWithValue("@total_stalls", -1);
SQLTracer.TraceNQ(cmd);
}
con.Close();
}
}
}
else if (suc.ContainsKey("site_closed") &&
bool.TryParse(suc["site_closed"].ToString(), out site_closed) &&
!site_closed)
{
Tools.DebugLog($"SuC: <{suc["name"]}> no info (fields available: available_stalls {suc.ContainsKey("available_stalls")} total_stalls {suc.ContainsKey("available_stalls")})");
Tools.DebugLog(new Tools.JsonFormatter(JsonConvert.SerializeObject(suc)).Format());
}
else
{
Tools.DebugLog($"suc ContainsKey available_stalls {suc.ContainsKey("available_stalls")} total_stalls {suc.ContainsKey("available_stalls")} site_closed {suc.ContainsKey("site_closed")}");
}
}
private async Task BeatTask(BeatInfo beatInfo)
{
if (beatInfo.Stopped)
{
return;
}
long nextTime = beatInfo.Period;
try
{
Newtonsoft.Json.Linq.JObject result = await _serverProxy.SendBeat(beatInfo, false);
long interval = result.GetValue("clientBeatInterval").ToObject <long>();
bool lightBeatEnabled = false;
if (result.ContainsKey(CommonParams.LIGHT_BEAT_ENABLED))
{
lightBeatEnabled = result.GetValue(CommonParams.LIGHT_BEAT_ENABLED).ToObject <bool>();
}
if (interval > 0)
{
nextTime = interval;
}
int code = 10200;
if (result.ContainsKey(CommonParams.CODE))
{
code = result.GetValue(CommonParams.CODE).ToObject <int>();
}
if (code == 20404)
{
Instance instance = new Instance
{
Port = beatInfo.Port,
Ip = beatInfo.Ip,
Weight = beatInfo.Weight ?? 1,
Metadata = beatInfo.Metadata,
ClusterName = beatInfo.Cluster,
ServiceName = beatInfo.ServiceName,
Ephemeral = true,
// InstanceId = ""
};
try
{
await _serverProxy.RegisterServiceAsync(beatInfo.ServiceName, NamingUtils.GetGroupName(beatInfo.ServiceName), instance);
}
catch
{
}
}
}
catch (NacosException ex)
{
_logger?.LogError(ex, "[CLIENT-BEAT] failed to send beat: {0}, code: {1}, msg: {2}", beatInfo, ex.ErrorCode, ex.ErrorMsg);
}
string key = BuildKey(beatInfo.ServiceName, beatInfo.Ip, beatInfo.Port);
if (_beatTimer.TryGetValue(key, out var timer))
{
timer.Change(nextTime, Timeout.Infinite);
}
}
/// <summary>
/// 过滤通配符
/// </summary>
/// <param name="str"></param>
/// <param name="currentUser">当前登录用户实体</param>
/// <param name="obj">对象</param>
/// <returns></returns>
public static string Filter(string str, Model.User user = null, object obj = null)
{
if (str.IsNullOrWhiteSpace())
{
return("");
}
Microsoft.AspNetCore.Http.HttpRequest request = Tools.HttpContext.Request;
foreach (string wildcard in wildcardList)
{
while (str.ContainsIgnoreCase(wildcard))
{
string value = string.Empty;
string wildcard1 = wildcard;
if ("{Query<".EqualsIgnoreCase(wildcard))
{
string key = str.Substring(str.IndexOf("{Query<") + 7);
string key1 = key.Substring(0, key.IndexOf(">}"));
if (!key1.IsNullOrWhiteSpace())
{
wildcard1 = wildcard + key1 + ">}";
value = request.Querys(key1);
}
}
else if ("{Form<".EqualsIgnoreCase(wildcard))
{
string key = str.Substring(str.IndexOf("{Form<") + 6);
string key1 = key.Substring(0, key.IndexOf(">}"));
if (!key1.IsNullOrWhiteSpace())
{
wildcard1 = wildcard + key1 + ">}";
value = request.Forms(key1);
}
}
else if ("{DataRow<".EqualsIgnoreCase(wildcard))
{
string key = str.Substring(str.IndexOf("{DataRow<") + 9);
string key1 = key.Substring(0, key.IndexOf(">}"));
if (!key1.IsNullOrWhiteSpace())
{
wildcard1 = wildcard + key1 + ">}";
var dr = (System.Data.DataRow)obj;
try
{
value = dr[key1].ToString();
}
catch
{
value = "";
}
}
}
else if ("{Method<".EqualsIgnoreCase(wildcard))
{
//执行一个方法替换通配符 object为方法参数
string key = str.Substring(str.IndexOf("{Method<") + 8);
string key1 = key.Substring(0, key.IndexOf(">}"));
if (!key1.IsNullOrWhiteSpace())
{
wildcard1 = wildcard + key1 + ">}";
var(o, err) = obj == null?Tools.ExecuteMethod(key1) : Tools.ExecuteMethod(key1, obj);
value = null == o ? "" : o.ToString();
}
}
else if ("{Date<".EqualsIgnoreCase(wildcard))
{
//取当前日期替换指定格式
string key = str.Substring(str.IndexOf("{Date<") + 6);
string key1 = key.Substring(0, key.IndexOf(">}"));
if (!key1.IsNullOrWhiteSpace())
{
wildcard1 = wildcard + key1 + ">}";
value = DateExtensions.Now.ToString(key1);
}
}
else if ("{Object<".EqualsIgnoreCase(wildcard))
{
//将对象转换为字符串替换
string key = str.Substring(str.IndexOf("{Object<") + 8);
string key1 = key.Substring(0, key.IndexOf(">}"));
if (!key1.IsNullOrWhiteSpace())
{
wildcard1 = wildcard + key1 + ">}";
value = obj == null ? "" : obj.ToString();
}
}
else if ("{JArray<".EqualsIgnoreCase(wildcard))
{
//取json数组值
string key = str.Substring(str.IndexOf("{JArray<") + 8);
string key1 = key.Substring(0, key.IndexOf(">}"));
if (!key1.IsNullOrWhiteSpace())
{
wildcard1 = wildcard + key1 + ">}";
Newtonsoft.Json.Linq.JArray jArray = (Newtonsoft.Json.Linq.JArray)obj;
if (null != jArray)
{
foreach (Newtonsoft.Json.Linq.JObject jObject in jArray)
{
if (jObject.ContainsKey(key1))
{
value = jObject.Value <string>(key1);
break;
}
}
if (value.IsNullOrEmpty())
{
//这里循环找是取表单数据形式的JSON [{"name":"","value":""}] 这里取表单字段对应的值
foreach (Newtonsoft.Json.Linq.JObject jObject in jArray)
{
if (jObject.ContainsKey("name") && jObject.Value <string>("name").Equals(key1))
{
value = jObject.Value <string>("value");
break;
}
}
}
}
else
{
value = "";
}
}
}
else if ("{JObject<".EqualsIgnoreCase(wildcard))
{
//取json对象值
string key = str.Substring(str.IndexOf("{JObject<") + 9);
string key1 = key.Substring(0, key.IndexOf(">}"));
if (!key1.IsNullOrWhiteSpace())
{
wildcard1 = wildcard + key1 + ">}";
Newtonsoft.Json.Linq.JObject jObject = (Newtonsoft.Json.Linq.JObject)obj;
if (null != jObject && jObject.ContainsKey(key1))
{
value = jObject.Value <string>(key1);
}
else
{
value = "";
}
}
}
else
{
value = GetWildcardValue(wildcard, user, obj);
}
str = str.ReplaceIgnoreCase(wildcard1, value);
}
}
return(str);
}
