/// <summary>
/// Replace parameters with requested parameter format
/// </summary>
/// <param name="userQuery">SQL Query with SAP parameters</param>
/// <param name="parameterFormat">Parameter format</param>
/// <returns>SQL Query with requested parameter format</returns>
public static string ReturnParameterStyle(string userQuery, ParameterFormat parameterFormat)
{
switch (parameterFormat)
{
case ParameterFormat.Database:
case ParameterFormat.Sql:
if (SboApp.Company.DbServerType == BoDataServerTypes.dst_HANADB)
{
userQuery = Regex.Replace(userQuery, @"'?\[%([0-9])\]'?", ":p$1");
}
else
{
userQuery = Regex.Replace(userQuery, @"'?\[%([0-9])\]'?", "@p$1");
}
break;
case ParameterFormat.String:
userQuery = Regex.Replace(userQuery, @"'\[%([0-9])\]'", "'{$1}'");
userQuery = Regex.Replace(userQuery, @"\[%([0-9])\]", "{$1}");
break;
}
return(userQuery);
}
/// <summary>
/// Replace parameters with requested parameter format
/// </summary>
/// <param name="userQuery">SQL Query with SAP parameters</param>
/// <param name="parameterFormat">Parameter format</param>
/// <returns>SQL Query with requested parameter format</returns>
public static string ReturnParameterStyle(string userQuery, ParameterFormat parameterFormat)
{
switch (parameterFormat)
{
case ParameterFormat.Database:
#pragma warning disable CS0618 // Type or member is obsolete
case ParameterFormat.Sql:
#pragma warning restore CS0618 // Type or member is obsolete
if (SboApp.Company.DbServerType == BoDataServerTypes.dst_HANADB)
{
userQuery = Regex.Replace(userQuery, @"'?\[%([0-9])\]'?", ":p$1");
}
else
{
userQuery = Regex.Replace(userQuery, @"'?\[%([0-9])\]'?", "@p$1");
}
break;
case ParameterFormat.String:
userQuery = Regex.Replace(userQuery, @"'\[%([0-9])\]'", "'{$1}'");
userQuery = Regex.Replace(userQuery, @"\[%([0-9])\]", "{$1}");
break;
}
return(userQuery);
}
/// <summary>
/// Append a constant parameter encoded byte in either short or long format. Note that if format is long parameter constant type will be a value
/// </summary>
/// <param name="value">Value to append</param>
/// <param name="format">Use either short or long format</param>
public void Append(sbyte value, ParameterFormat format)
{
if (format == ParameterFormat.Short)
{
byte b = 0x00;
if (value < 0)
{
if (value < ShortValueMin)
{
value = ShortValueMin;
}
b = (byte)((byte)format | (byte)ParameterType.Constant | (byte)(value & ((byte)0x1f)));
b = (byte)((byte)ShortSign.Negative | b);
}
else
{
if (value > ShortValueMax)
{
value = ShortValueMax;
}
b = (byte)((byte)format | (byte)ParameterType.Constant | (byte)(value & ((byte)0x1f)));
b = (byte)((byte)ShortSign.Positive | b);
}
Append(b);
}
else
{
byte b = (byte)((byte)format | (byte)ParameterType.Constant | (byte)ConstantParameterType.Value | (byte)FollowType.OneByte);
Append(b);
Append(value);
}
}
public static string GetOrCreateUserQuery(
this Company company,
string userQueryName,
string userQueryDefaultQuery,
ParameterFormat parameterFormat = ParameterFormat.Database,
string queryCategoryName = null)
{
return(GetOrCreateUserQuery(company, userQueryName, () => userQueryDefaultQuery, parameterFormat, queryCategoryName));
}
private static string FormatThis(ParameterFormat format, TypeReference thisType)
{
if (format == ParameterFormat.WithNameCastThis)
{
return($"({Naming.ForVariable(thisType)}){Naming.ThisParameterName}");
}
if (format == ParameterFormat.WithNameUnboxThis)
{
return($"({Naming.ForVariable(thisType)})UnBox({Naming.ThisParameterName})");
}
return(FormatParameterName(thisType, Naming.ThisParameterName, format));
}
private Stream GetResponseStream(ParameterFormat format, string kind, string method, Stream stream)
{
var request = WebOperationContext.Current.IncomingRequest;
var response = WebOperationContext.Current.OutgoingResponse;
NameValueCollection nvs = null;
if (stream == null)
{
nvs = request.UriTemplateMatch.QueryParameters;
}
else
{
//接收流内部数据
var sr = new StreamReader(stream, Encoding.UTF8);
string streamValue = sr.ReadToEnd();
//转换成NameValueCollection
nvs = ConvertCollection(streamValue);
}
string result = GetResponseString(format, kind, method, nvs);
if (string.IsNullOrEmpty(result)) return new MemoryStream();
//转换成buffer
var buffer = Encoding.UTF8.GetBytes(result);
if (request.Method.ToUpper() == "GET" && response.StatusCode == HttpStatusCode.OK)
{
//处理ETag功能
string etagToken = MD5.HexHash(buffer);
response.ETag = etagToken;
var IfNoneMatch = request.Headers["If-None-Match"];
if (IfNoneMatch != null && IfNoneMatch == etagToken)
{
response.StatusCode = HttpStatusCode.NotModified;
//request.IfModifiedSince.HasValue ? request.IfModifiedSince.Value :
var IfModifiedSince = request.Headers["If-Modified-Since"];
response.LastModified = IfModifiedSince == null ? DateTime.Now : Convert.ToDateTime(IfModifiedSince);
return new MemoryStream();
}
else
{
response.LastModified = DateTime.Now;
}
}
return new MemoryStream(buffer);
}
/// <summary>
/// Replace parameters with requested parameterformat
/// </summary>
/// <param name="userQuery">SQL Query with SAP parmeters</param>
/// <param name="parameterFormat"></param>
/// <returns>SQL Query with requsted parameter format</returns>
public static string ReturnParameterStyle(string userQuery, ParameterFormat parameterFormat)
{
switch (parameterFormat)
{
case ParameterFormat.Sql:
userQuery = Regex.Replace(userQuery, @"'?\[%([0-9])\]'?", "@p$1");
break;
case ParameterFormat.String:
userQuery = Regex.Replace(userQuery, @"'\[%([0-9])\]'", "'{$1}'");
userQuery = Regex.Replace(userQuery, @"\[%([0-9])\]", "{$1}");
break;
}
return(userQuery);
}
/// <summary>
/// 创建序列化
/// </summary>
/// <param name="format"></param>
/// <returns></returns>
public static ISerializer Create(ParameterFormat format)
{
switch (format)
{
case ParameterFormat.Xml:
return new XmlSerializer();
case ParameterFormat.Text:
case ParameterFormat.Html:
return new TextSerializer();
case ParameterFormat.Json:
return new JsonSerializer();
case ParameterFormat.Jsonp:
return new JsonpSerializer();
default:
return new JsonSerializer();
}
}
/// <summary>
/// Append a constant parameter encoded byte in either short or long format. Note that if format is long parameter constant type will be a value
/// </summary>
/// <param name="value">Value to append</param>
/// <param name="format">Use either short or long format</param>
public void Append(byte value, ParameterFormat format)
{
if (format == ParameterFormat.Short)
{
if (value > (byte)ShortValueMax)
{
value = (byte)ShortValueMax;
}
byte b = (byte)((byte)format | (byte)ParameterType.Constant | (byte)(value & ((byte)0x1f)) | (byte)ShortSign.Positive);
Append(b);
}
else
{
byte b = (byte)((byte)format | (byte)ParameterType.Constant | (byte)ConstantParameterType.Value | (byte)FollowType.OneByte);
Append(b);
Append(value);
}
}
/// <summary>
/// Outputs the SQL script as a string
/// </summary>
/// <param name="outputParameterDeclarations">
/// If set to true will place the parameter DECLARE statements on top of the script
/// and try to escape values where needed.
/// </param>
/// <returns>
/// SQL script as a string
/// </returns>
public string ToSqlString(bool outputParameterDeclarations) {
if (outputParameterDeclarations && this.HasParameters) {
var tsb = new StringBuilder();
foreach (SqlParameter sqlParameter in this.Parameters) {
ParameterFormat paramInfo = ParameterFormatter.Format(sqlParameter);
tsb.AppendFormat(
"DECLARE {0} AS {1} = {2};",
sqlParameter.ParameterName,
paramInfo.SqlServerDbEngineTypeString,
paramInfo.PrintableParameterValue);
tsb.AppendLine();
}
tsb.AppendLine(this.sb.ToString());
return tsb.ToString();
}
return this.sb.ToString();
}
private static string FormatHiddenMethodArgument(ParameterFormat format)
{
switch (format)
{
case ParameterFormat.WithTypeAndName:
case ParameterFormat.WithTypeAndNameNoThis:
case ParameterFormat.WithTypeAndNameThisObject:
return("const MethodInfo* method");
case ParameterFormat.WithType:
case ParameterFormat.WithTypeNoThis:
case ParameterFormat.WithTypeThisObject:
return("const MethodInfo*");
case ParameterFormat.WithName:
case ParameterFormat.WithNameCastThis:
case ParameterFormat.WithNameUnboxThis:
return("method");
}
throw new ArgumentOutOfRangeException("format");
}
/// <summary>
/// 创建序列化
/// </summary>
/// <param name="format"></param>
/// <returns></returns>
public static ISerializer Create(ParameterFormat format)
{
switch (format)
{
case ParameterFormat.Xml:
return(new XmlSerializer());
case ParameterFormat.Text:
case ParameterFormat.Html:
return(new TextSerializer());
case ParameterFormat.Json:
return(new JsonSerializer());
case ParameterFormat.Jsonp:
return(new JsonpSerializer());
default:
return(new JsonSerializer());
}
}
/// <summary>
/// Get or create User Query
/// </summary>
/// <param name="company">Company Object</param>
/// <param name="userQueryName">User Query Name</param>
/// <param name="userQueryDefaultQueryFunc">Default query</param>
/// <param name="parameterFormat">Define parameter format [%0]/(@p0/:p0)/{0}</param>
/// <param name="queryCategoryName">Add query in category with this name</param>
/// <returns>SQL Query</returns>
public static string GetOrCreateUserQuery(this Company company, string userQueryName, Func <string> userQueryDefaultQueryFunc, ParameterFormat parameterFormat = ParameterFormat.Database, string queryCategoryName = null)
{
string userQuery;
using (var userQueryObject = new SboRecordsetQuery <UserQueries>(FrameworkQueries.Instance.GetOrCreateUserQueryQuery(userQueryName), BoObjectTypes.oUserQueries))
{
var queryCategoryCode = GetOrCreateQueryCategory(queryCategoryName);
if (userQueryObject.Count == 0)
{
userQuery = userQueryDefaultQueryFunc.Invoke();
userQueryObject.BusinessObject.QueryDescription = userQueryName;
userQueryObject.BusinessObject.Query = userQuery;
userQueryObject.BusinessObject.QueryCategory = queryCategoryCode;
var response = userQueryObject.BusinessObject.Add();
ErrorHelper.HandleErrorWithException(response, $"Could not create User Query '{userQueryName}'");
}
else
{
var row = userQueryObject.Result.First();
userQuery = row.Query;
if (queryCategoryCode > 0 && userQueryObject.BusinessObject.QueryCategory != queryCategoryCode)
{
userQueryObject.BusinessObject.QueryCategory = queryCategoryCode;
var response = userQueryObject.BusinessObject.Update();
ErrorHelper.HandleErrorWithException(response, $"Could not update User Query '{userQueryName}' with Query Category {queryCategoryCode}");
}
}
}
userQuery = ReturnParameterStyle(userQuery, parameterFormat);
return(userQuery);
}
/// <summary>
/// Get or create User Query
/// </summary>
/// <param name="company">Company Object</param>
/// <param name="userQueryName">User Query Name</param>
/// <param name="userQueryDefaultQuery">Query</param>
/// <param name="parameterFormat">Define parameter format [%0]/@p0/{0}</param>
/// <returns>SQL</returns>
public static string GetOrCreateUserQuery(this Company company, string userQueryName, string userQueryDefaultQuery, ParameterFormat parameterFormat = ParameterFormat.Sbo)
{
var userQuery = userQueryDefaultQuery;
using (var userQueryObject = new SboRecordsetQuery <UserQueries>(
$"SELECT [IntrnalKey] FROM [OUQR] WHERE [QName] = '{userQueryName}'", BoObjectTypes.oUserQueries))
{
if (userQueryObject.Count == 0)
{
userQueryObject.BusinessObject.QueryDescription = userQueryName;
userQueryObject.BusinessObject.Query = userQueryDefaultQuery;
userQueryObject.BusinessObject.QueryCategory = -1;
var response = userQueryObject.BusinessObject.Add();
ErrorHelper.HandleErrorWithException(response, $"Could not create User Query '{userQueryName}'");
}
else
{
userQuery = userQueryObject.Result.First().Query;
}
}
userQuery = ReturnParameterStyle(userQuery, parameterFormat);
return(userQuery);
}
public static string FormatParameters(MethodReference method, ParameterFormat format = 0, bool forceNoStaticThis = false, bool includeHiddenMethodInfo = false)
{
List <string> elements = ParametersFor(method, format, forceNoStaticThis, includeHiddenMethodInfo, false).ToList <string>();
return((elements.Count != 0) ? elements.AggregateWithComma() : string.Empty);
}
private static string FormatParameterName(TypeReference parameterType, string parameterName, ParameterFormat format)
{
string str = string.Empty;
if ((((format == ParameterFormat.WithTypeAndName) || (format == ParameterFormat.WithTypeAndNameNoThis)) || ((format == ParameterFormat.WithType) || (format == ParameterFormat.WithTypeNoThis))) || ((format == ParameterFormat.WithTypeAndNameThisObject) || (format == ParameterFormat.WithTypeThisObject)))
{
str = str + Naming.ForVariable(parameterType);
}
if (((format == ParameterFormat.WithTypeAndName) || (format == ParameterFormat.WithTypeAndNameNoThis)) || (format == ParameterFormat.WithTypeAndNameThisObject))
{
str = str + " ";
}
if ((((format != ParameterFormat.WithTypeAndName) && (format != ParameterFormat.WithTypeAndNameNoThis)) && ((format != ParameterFormat.WithName) && (format != ParameterFormat.WithTypeAndNameThisObject))) && (((format != ParameterFormat.WithNameNoThis) && (format != ParameterFormat.WithNameCastThis)) && (format != ParameterFormat.WithNameUnboxThis)))
{
return(str);
}
return(str + parameterName);
}
public static IEnumerable <string> ParametersFor(MethodReference methodDefinition, ParameterFormat format = 0, bool forceNoStaticThis = false, bool includeHiddenMethodInfo = false, bool useVoidPointerForThis = false) =>
public static string GetMethodPointerForVTable(MethodReference method)
{
ParameterFormat parameterFormat = (!method.DeclaringType.IsValueType || !method.HasThis) ? ParameterFormat.WithType : ParameterFormat.WithTypeThisObject;
return(GetMethodPointer(method, parameterFormat));
}
public static string GetMethodPointer(MethodReference method, ParameterFormat parameterFormat)
{
Unity.IL2CPP.ILPreProcessor.TypeResolver resolver = new Unity.IL2CPP.ILPreProcessor.TypeResolver(method.DeclaringType as GenericInstanceType, method as GenericInstanceMethod);
return(GetMethodSignature("(*)", Naming.ForVariable(resolver.ResolveReturnType(method)), FormatParameters(method, parameterFormat, false, true), string.Empty, ""));
}
public SfxrParams(Stream s, ParameterFormat format)
{
FromStream(s, format);
}
/// <summary>
/// Append a constant parameter encoded byte in either short or long format. Note that if format is long parameter constant type will be a value
/// </summary>
/// <param name="value">Value to append</param>
/// <param name="format">Use either short or long format</param>
public void Append (byte value, ParameterFormat format)
{
if(format == ParameterFormat.Short){
if(value > (byte) ShortValueMax){
value = (byte) ShortValueMax;
}
byte b = (byte)((byte)format | (byte) ParameterType.Constant | (byte)(value & ((byte)0x1f)) | (byte)ShortSign.Positive);
Append (b);
}
else{
byte b = (byte)((byte)format | (byte) ParameterType.Constant | (byte) ConstantParameterType.Value | (byte)FollowType.OneByte);
Append (b);
Append (value);
}
}
private string GetResponseString(ParameterFormat format, string kind, string method, NameValueCollection parameters)
{
var request = WebOperationContext.Current.IncomingRequest;
var response = WebOperationContext.Current.OutgoingResponse;
if (format == ParameterFormat.Json)
response.ContentType = "application/json;charset=utf-8";
else if (format == ParameterFormat.Xml)
response.ContentType = "text/xml;charset=utf-8";
else if (format == ParameterFormat.Text)
response.ContentType = "text/plain;charset=utf-8";
else if (format == ParameterFormat.Html)
response.ContentType = "text/html;charset=utf-8";
//从缓存读取
object result = null;
if (Context != null && !Context.Contains(kind, method))
{
response.StatusCode = HttpStatusCode.NotFound;
result = new RESTfulResult { Code = (int)response.StatusCode, Message = "service [" + kind + "." + method + "] not found." };
}
else
{
//进行认证处理
RESTfulResult authResult = new RESTfulResult { Code = (int)HttpStatusCode.OK };
//进行认证处理
if (Context != null && Context.IsAuthorized(kind, method))
{
authResult = AuthorizeRequest();
}
//认证成功
if (authResult.Code == (int)HttpStatusCode.OK)
{
try
{
Type retType;
result = Context.Invoke(kind, method, parameters, out retType);
//设置返回成功
response.StatusCode = HttpStatusCode.OK;
//xml方式需要进行数据包装
if (format == ParameterFormat.Xml)
{
//如果是值类型，则以对象方式返回
if (retType.IsValueType || retType == typeof(string))
{
result = new RESTfulResponse { Value = result };
}
}
}
catch (Exception ex)
{
RESTfulResult ret;
var errorMessage = GetErrorMessage(ex, kind, method, parameters, out ret);
result = ret;
//重新定义一个异常
var error = new Exception(errorMessage, ex);
//记录错误日志
SimpleLog.Instance.WriteLogForDir("RESTful\\" + kind, error);
}
finally
{
//使用完后清理上下文
AuthorizeContext.Current = null;
}
}
else
{
result = authResult;
}
}
ISerializer serializer = SerializerFactory.Create(format);
return serializer.Serialize(result);
}
/// <summary>
/// Append a constant parameter encoded byte in either short or long format. Note that if format is long parameter constant type will be a value
/// </summary>
/// <param name="value">Value to append</param>
/// <param name="format">Use either short or long format</param>
public void Append(sbyte value, ParameterFormat format)
{
if(format == ParameterFormat.Short){
byte b = 0x00;
if(value <0 ){
if(value < ShortValueMin){
value = ShortValueMin;
}
b = (byte)((byte)format | (byte) ParameterType.Constant | (byte)(value & ((byte)0x1f)));
b = (byte)((byte)ShortSign.Negative | b);
}
else{
if(value > ShortValueMax){
value = ShortValueMax;
}
b = (byte)((byte)format | (byte) ParameterType.Constant | (byte)(value & ((byte)0x1f)));
b = (byte)((byte)ShortSign.Positive | b);
}
Append (b);
}
else{
byte b = (byte)((byte)format | (byte) ParameterType.Constant | (byte) ConstantParameterType.Value | (byte)FollowType.OneByte);
Append (b);
Append (value);
}
}
public void FromStream(Stream stream, ParameterFormat format)
{
if (format == ParameterFormat.String)
{
using (var sr = new StreamReader(stream))
{
var data = sr.ReadToEnd();
FromString(data);
}
}
else if (format == ParameterFormat.Binary)
{
using (var br = new BinaryReader(stream))
{
var version = br.ReadInt32();
if (version != 102 && version != 101 && version != 100)
{
throw new FormatException($"Unsupported SFXR file version '{version}'.");
}
WaveShape = (WaveShape)br.ReadInt32();
MasterVolume = 0.5f;
if (version == 102)
{
MasterVolume = br.ReadSingle();
}
StartFrequency = br.ReadSingle();
MinFrequency = br.ReadSingle();
Slide = br.ReadSingle();
if (version >= 101)
{
DeltaSlide = br.ReadSingle();
}
SquareDuty = br.ReadSingle();
DutySweep = br.ReadSingle();
VibratoDepth = br.ReadSingle();
VibratoSpeed = br.ReadSingle();
// p_vib_delay
br.ReadSingle();
AttackTime = br.ReadSingle();
SustainTime = br.ReadSingle();
DecayTime = br.ReadSingle();
SustainPunch = br.ReadSingle();
// filter_on
br.ReadBoolean();
LowPassResonance = br.ReadSingle();
LowPassCutoff = br.ReadSingle();
LowPassCutoffSweep = br.ReadSingle();
HighPassCutoff = br.ReadSingle();
HighPassCutoffSweep = br.ReadSingle();
PhaserOffset = br.ReadSingle();
PhaserSweep = br.ReadSingle();
if (version >= 101)
{
ChangeSpeed = br.ReadSingle();
ChangeAmount = br.ReadSingle();
}
}
}
else
{
throw new FormatException("Unsupported parameter format provided.");
}
}
