/// <summary>
/// Thsi will save the cliams to database
/// </summary>
/// <param name="claimInputXml"></param>
/// <returns></returns>
public string AddClaimData(string claimInputXml)
{
ServiceUtility serviceUtility = new ServiceUtility(claimInputXml);
if (serviceUtility.ValidateXml())
{
if (serviceUtility.AddClaim())
{
return "Status: OK.";
}
else
{
return "Status: Not Saved.";
}
}
else
{
return "Status: Not Vlaid XML.";
}
}
/// <summary>
/// 检索数据
/// </summary>
/// <param name="filter"></param>
/// <param name="responseEntity"></param>
public void SearchData(XtgJhzkCheckFilter filter, ResponseEntity responseEntity)
{
if (filter == null)
{
ServiceUtility.SetResponseStatus(responseEntity, EnumResponseState.RequestCommandError);
return;
}
// 获取件数
int totalCount = 0;
if (filter.IsReGetCount)
{
totalCount = Singleton <XtgJhzkCheckSearchDAL <XtgJhzkViewData> > .Instance.GetCount(filter);
}
else
{
totalCount = filter.TotalCount;
}
if (totalCount <= 0)
{
ServiceUtility.SetResponseStatus(responseEntity, EnumResponseState.NoResult);
m_Logger.Info("未查询到数据。");
return;
}
decimal totalAmount = 0;
if (filter.IsReGetCount)
{
totalAmount = Singleton <XtgJhzkCheckSearchDAL <XtgJhzkViewData> > .Instance.GetSumAmount(filter);
}
else
{
totalAmount = filter.TotalAmount;
}
if (filter.PageNo < 1)
{
filter.PageNo = 1;
}
int fromIndex = (filter.PageNo - 1) * filter.PageSize;
int toIndex = filter.PageNo * filter.PageSize;
if (toIndex > totalCount)
{
toIndex = totalCount;
}
filter.FromIndex = fromIndex;
filter.ToIndex = toIndex;
var lstXtgJhzkViewDatas = Singleton <XtgJhzkCheckSearchDAL <XtgJhzkViewData> > .Instance.SearchData(filter);
if (lstXtgJhzkViewDatas == null || lstXtgJhzkViewDatas.Count == 0)
{
ServiceUtility.SetResponseStatus(responseEntity, EnumResponseState.NoResult);
m_Logger.Info("未查询到数据。");
}
else
{
lstXtgJhzkViewDatas.ForEach(x => x.TotalAmount = totalAmount);
var responseResult = new ResponseListResult <XtgJhzkViewData>();
responseResult.TotalCount = totalCount;
responseResult.LstResult = lstXtgJhzkViewDatas;
ServiceUtility.SetResponseStatus(responseEntity, EnumResponseState.Success);
responseEntity.Results = responseResult;
}
}
private CommentResponse PostInternal(CommentCreateRequest request)
{
CommentsWebServiceReflector.Validate(request);
CommentResponse result;
try
{
var author = CommentsUtilitiesReflector.GetAuthor(request);
var cs = SystemManager.GetCommentsService();
var thread = cs.GetThread(request.ThreadKey);
if (thread == null)
{
request.Thread.Key = request.ThreadKey;
CommentsWebServiceReflector.Validate(request.Thread);
CommentsWebServiceReflector.ValidatePostRequest(request.Thread.Type, request.Captcha, false);
var group = cs.GetGroup(request.Thread.GroupKey);
if (group == null)
{
CommentsWebServiceReflector.Validate(request.Thread.Group);
request.Thread.Group.Key = request.Thread.GroupKey;
var groupProxy = new GroupProxy(request.Thread.Group.Name, request.Thread.Group.Description, author)
{
Key = request.Thread.Group.Key
};
group = cs.CreateGroup(groupProxy);
}
var threadProxy = new ThreadProxy(request.Thread.Title, request.Thread.Type, group.Key, author, SystemManager.CurrentContext.Culture)
{
Key = request.Thread.Key,
Language = request.Thread.Language,
DataSource = request.Thread.DataSource,
Behavior = request.Thread.Behavior
};
thread = cs.CreateThread(threadProxy);
}
else
{
if (thread.IsClosed)
{
throw new InvalidOperationException("Thread is closed.");
}
CommentsWebServiceReflector.ValidatePostRequest(thread.Type, request.Captcha, false);
}
result = this.SubmitCommentInternal(request, thread, author);
}
catch (InvalidOperationException ex)
{
throw new InvalidOperationException("Comment cannot be submitted at the moment. Please refresh the page and try again.", ex);
}
ServiceUtility.DisableCache();
return(result);
}
/// <summary>
/// 检索数据
/// </summary>
/// <param name="filter"></param>
/// <param name="responseEntity"></param>
public void SearchData(InterestFitFilter filter, ResponseEntity responseEntity)
{
if (filter == null)
{
ServiceUtility.SetResponseStatus(responseEntity, EnumResponseState.RequestCommandError);
return;
}
List <string> companys = Singleton <RedisEnumOperatorBLL> .Instance.GetUserOwnCompanyKeys(responseEntity.UserId);
filter.BranchKey = string.Join("','", companys.ToArray());
// 获取件数
int totalCount = Singleton <InterestFitDAL <Business> > .Instance.GetCount(filter);
if (totalCount <= 0)
{
ServiceUtility.SetResponseStatus(responseEntity, EnumResponseState.NoResult);
m_Logger.Info("未查询到数据。");
return;
}
if (filter.PageNo < 1)
{
filter.PageNo = 1;
}
int fromIndex = (filter.PageNo - 1) * filter.PageSize;
int toIndex = filter.PageNo * filter.PageSize;
if (toIndex > totalCount)
{
toIndex = totalCount;
}
filter.FromIndex = fromIndex;
filter.ToIndex = toIndex;
var lstBusinessDatas = Singleton <InterestFitDAL <Business> > .Instance.SearchData(filter);
if (lstBusinessDatas == null || lstBusinessDatas.Count == 0)
{
ServiceUtility.SetResponseStatus(responseEntity, EnumResponseState.NoResult);
m_Logger.Info("未查询到数据。");
}
else
{
var lstBusinessIds = lstBusinessDatas.Select(x => x.BusinessID);
filter.BusinessIDs = string.Join(",", lstBusinessIds.ToArray());
// 银行账户
var bankAccounts = Singleton <RedisEnumOperatorBLL>
.Instance.GetEnumRedisDataEntitys <BankAccountRedisEntity>();
var lstBills = Singleton <BillDAL <Bill> > .Instance.SearchData(filter);
var lstInterestFiltViewData = new List <InterestFiltViewData>();
foreach (var business in lstBusinessDatas)
{
business.Bills = lstBills.FindAll(x => x.BusinessID == business.BusinessID).ToList();
decimal sum = GetSum(business) + GetInter(business);
var bankser = bankAccounts.FirstOrDefault(x => x.BankAccountID == business.LendingSideID);
lstInterestFiltViewData.Add(new InterestFiltViewData
{
ContractNO = business.ContractNo,
CustomerName = business.CustomerName,
idenNO = business.IdentityNo,
GuaranteeSideDate = business.ToGuaranteeTime.ToDateString(),
SurplusInterest = sum.ToAmtString(),
Loaner = Singleton <RedisEnumOperatorBLL> .Instance.GetRedisData(
RedisEnumOperatorBLL.HashId_LendingGroup_4, bankser.CompanyKey).Name,
PayDate = business.PaymentDate.ToString()
});
}
var responseResult = new ResponseListResult <InterestFiltViewData>();
responseResult.TotalCount = totalCount;
responseResult.LstResult = lstInterestFiltViewData;
ServiceUtility.SetResponseStatus(responseEntity, EnumResponseState.Success);
responseEntity.Results = responseResult;
}
}
/// <inheritdoc/>
public CollectionContext <CustomErrorPageItemPropertyViewModel> GetProperties()
{
ServiceUtility.DisableCache();
return(this.GetPropertiesInternal());
}
/// <inheritdoc/>
public ItemContext <CustomErrorPageItemViewModel> GetCustomErrorPageItemInXml(string customErrorPageItemId)
{
ServiceUtility.DisableCache();
return(this.GetCustomErrorPageItemInternal(customErrorPageItemId));
}
/// <inheritdoc/>
public bool BatchDeleteCustomErrorPageItemsInXml(string[] ids, string provider)
{
ServiceUtility.DisableCache();
return(this.BatchDeleteCustomErrorPageItemsInternal(ids, provider));
}
private void DefineReferenceTypeGetMethodNameMethod(Type baseType, TypeBuilder typeBuilder, Type interfaceType, PropertyBuilder interfaceIdProperty)
{
var stringFormatMethod = typeof(string).GetMethod(nameof(string.Format), BindingFlags.Static | BindingFlags.Public, null, new Type[] { typeof(string), typeof(object), typeof(object) }, null);
var notSupportedMethodExceptionConstructor = typeof(NotSupportedMethodException).GetConstructor(new Type[] { typeof(string) });
var methodTemplate = baseType.GetMethod(nameof(Reference.GetMethodName));
var methodAttributes = MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.Virtual;
var parameters = methodTemplate.GetParameters();
var parameterTypes = parameters.Select(p => p.ParameterType).ToArray();
var methodBuilder = typeBuilder.DefineMethod(methodTemplate.Name, methodAttributes, CallingConventions.Standard, methodTemplate.ReturnType, parameterTypes);
var bindingAttr = BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly | BindingFlags.InvokeMethod;
var methods = interfaceType.GetMethods(bindingAttr);
for (int i = 0; i < parameters.Length; i++)
{
var parameter = parameters[i];
methodBuilder.DefineParameter(i + 1, ParameterAttributes.None, parameter.Name);
}
var iLGenerator = methodBuilder.GetILGenerator();
iLGenerator.DeclareLocal(typeof(object));
var retLabel = iLGenerator.DefineLabel();
var defLabel = iLGenerator.DefineLabel();
var jumpTable = new Label[methods.Length];
var bodyTable = new Label[methods.Length];
for (int i = 0; i < jumpTable.Length; i++)
{
jumpTable[i] = iLGenerator.DefineLabel();
bodyTable[i] = iLGenerator.DefineLabel();
}
var endSentinel = methods.Length - 1;
for (int i = 0; i < methods.Length; i++)
{
var method = methods[i];
var methodId = ServiceUtility.ComputeMethodId(method);
iLGenerator.MarkLabel(jumpTable[i]);
iLGenerator.Emit(OpCodes.Ldarg_1);
iLGenerator.Emit(OpCodes.Ldc_I4, methodId);
iLGenerator.Emit(OpCodes.Beq, bodyTable[i]);
iLGenerator.Emit(OpCodes.Br, i < endSentinel ? jumpTable[i + 1] : defLabel);
}
for (int i = 0; i < methods.Length; i++)
{
var method = methods[i];
iLGenerator.MarkLabel(bodyTable[i]);
iLGenerator.Emit(OpCodes.Ldstr, method.Name);
iLGenerator.Emit(OpCodes.Stloc_0);
iLGenerator.Emit(OpCodes.Br, retLabel);
}
iLGenerator.MarkLabel(defLabel);
iLGenerator.Emit(OpCodes.Ldstr, "interfaceId={0},methodId={1}");
iLGenerator.Emit(OpCodes.Ldarg_0);
iLGenerator.Emit(OpCodes.Callvirt, interfaceIdProperty.GetMethod);
iLGenerator.Emit(OpCodes.Box, interfaceIdProperty.PropertyType);
iLGenerator.Emit(OpCodes.Ldarg_1);
iLGenerator.Emit(OpCodes.Box, typeof(int));
iLGenerator.Emit(OpCodes.Call, stringFormatMethod);
iLGenerator.Emit(OpCodes.Newobj, notSupportedMethodExceptionConstructor);
iLGenerator.Emit(OpCodes.Throw);
iLGenerator.MarkLabel(retLabel);
iLGenerator.Emit(OpCodes.Ldloc_0);
iLGenerator.Emit(OpCodes.Ret);
}
/// <inheritdoc/>
public ItemContext <CustomErrorPageItemViewModel> SaveCustomErrorPageItemInXml(ItemContext <CustomErrorPageItemViewModel> context, string customErrorPageItemId, string provider)
{
ServiceUtility.DisableCache();
return(this.SaveCustomErrorPageItemInternal(context, customErrorPageItemId, provider));
}
/// <inheritdoc/>
public CollectionContext <CustomErrorPageItemViewModel> GetCustomErrorPageItemsInXml(string provider, string sortExpression, int skip, int take, string filter)
{
ServiceUtility.DisableCache();
return(this.GetCustomErrorPageItemsInternal(provider, sortExpression, skip, take, filter));
}
/// <summary>
/// 加载所有服务端配置信息
/// </summary>
public void ReloadAllServiceMapConfig()
{
// 记录执行时间类
using (StopWatcherAuto auto = new StopWatcherAuto())
{
ServiceUtility.ExportLog(m_Logger, LogExport, "开始加载所有服务端配置信息。");
// 全部清空
m_ServiceMapDic.Clear();
if (string.IsNullOrEmpty(ServiceMapConfigFilePath))
{
return;
}
string filePath = ServiceMapConfigFilePath + ServiceMapFileName;
m_Logger.Debug("服务配置文件路径：" + filePath);
if (!File.Exists(filePath))
{
return;
}
string xmlContent = File.ReadAllText(filePath);
m_Logger.Debug("服务配置文件内容：" + xmlContent);
if (string.IsNullOrEmpty(xmlContent))
{
return;
}
try
{
ServiceConfigs configs = ServiceConfigs.XmlDeSerialization(xmlContent);
if (configs == null ||
configs.ServiceMaps == null ||
configs.ServiceMaps.Count == 0)
{
m_Logger.Debug("文件中没有服务配置信息。");
return;
}
foreach (var map in configs.ServiceMaps)
{
AddServiceMap(map);
}
ServiceUtility.ExportLog(m_Logger, LogExport, "加载所有服务端配置信息完成。");
ServiceUtility.ExportLog(m_Logger, LogExport
, string.Concat("共计加载配置文件：ServiceConfig Count：", configs.ServiceMaps.Count));
// 加载完毕
IsLoadOver = true;
}
catch (Exception ex)
{
m_Logger.Fatal(string.Concat("加载所有服务端配置信息异常 异常信息: ", ex.Message));
m_Logger.Fatal(string.Concat("加载所有服务端配置信息异常 异常信息: ", ex.StackTrace));
throw ex;
}
}
}
/// <summary>
/// 检索数据
/// </summary>
/// <param name="baseFilter"></param>
/// <param name="responseEntity"></param>
public void SearchData(BaseFilter baseFilter, ResponseEntity responseEntity)
{
if (baseFilter == null)
{
return;
}
var reportDetailList = Singleton <GetOverDueReportSearchResultDAL <OverDueDetailReportData> >
.Instance.SearchData(baseFilter);
List <OverDueReportViewData> listOverDueReportViewData = new List <OverDueReportViewData>();
IDictionary <int, Dictionary <int, List <OverDueDetailReportData> > > dicReport
= new Dictionary <int, Dictionary <int, List <OverDueDetailReportData> > >();
Dictionary <int, List <OverDueDetailReportData> > dicTmp;
List <OverDueDetailReportData> lstTmp;
foreach (var detail in reportDetailList)
{
if (!dicReport.TryGetValue(detail.Examiner, out dicTmp))
{
dicTmp = new Dictionary <int, List <OverDueDetailReportData> >();
}
if (!dicTmp.TryGetValue(detail.ExamineStatus, out lstTmp))
{
lstTmp = new List <OverDueDetailReportData>();
}
lstTmp.Add(detail);
dicTmp[detail.ExamineStatus] = lstTmp;
dicReport[detail.Examiner] = dicTmp;
}
int index = 0;
int loanCount = 0;
int firstOverDueCount = 0;
int fourM2Count = 0;
int threeNonePayCount = 0;
int m1Count = 0;
int m2Count = 0;
int m3Count = 0;
int m4Count = 0;
int m5PlusCount = 0;
OverDueReportViewData report;
foreach (var key in dicReport.Keys)
{
foreach (var keyInner in dicReport[key].Keys)
{
lstTmp = dicReport[key][keyInner];
report = new OverDueReportViewData();
report.FirstOverDueBusinessIDs = "";
report.FourM2BusinessIDs = "";
report.ThreeNonePayBusinessIDs = "";
report.M1BusinessIDs = "";
report.M2BusinessIDs = "";
report.M3BusinessIDs = "";
report.M4BusinessIDs = "";
report.M5PlusBusinessIDs = "";
// 序号
report.No = ++index;
// 工号
report.Examiner = key;
// 审核属性
report.ExamineStatus = GetExamineStatusName(keyInner);
loanCount = 0;
firstOverDueCount = 0;
fourM2Count = 0;
threeNonePayCount = 0;
m1Count = 0;
m2Count = 0;
m3Count = 0;
m4Count = 0;
m5PlusCount = 0;
if (lstTmp == null || lstTmp.Count == 0)
{
continue;
}
// 已放款数
loanCount = lstTmp.Count;
report.LoanCount = loanCount;
foreach (var detail in lstTmp)
{
// 审核人
report.ExaminerName = detail.Name;
// 首逾数
if (detail.DifferCountFirst > 0 &&
!report.FirstOverDueBusinessIDs.Contains(detail.Bid.ToString()))
{
firstOverDueCount++;
report.FirstOverDueBusinessIDs += WebServiceConst.Separater_Comma + detail.Bid;
}
// 前4期账单出现M2的数量
if (detail.DifferCountFour > 0 &&
!report.FourM2BusinessIDs.Contains(detail.Bid.ToString()))
{
fourM2Count++;
report.FourM2BusinessIDs += WebServiceConst.Separater_Comma + detail.Bid;
}
// 前3期账单0次还款
if (detail.DifferCountThree == 0 &&
!report.ThreeNonePayBusinessIDs.Contains(detail.Bid.ToString()))
{
threeNonePayCount++;
report.ThreeNonePayBusinessIDs += WebServiceConst.Separater_Comma + detail.Bid;
}
int mCount = detail.OverMonth;
switch (mCount)
{
case 0:
break;
case 1:
if (!report.M1BusinessIDs.Contains(detail.Bid.ToString()))
{
m1Count++;
report.M1BusinessIDs += WebServiceConst.Separater_Comma + detail.Bid;
}
break;
case 2:
if (!report.M2BusinessIDs.Contains(detail.Bid.ToString()))
{
m2Count++;
report.M2BusinessIDs += WebServiceConst.Separater_Comma + detail.Bid;
}
break;
case 3:
if (!report.M3BusinessIDs.Contains(detail.Bid.ToString()))
{
m3Count++;
report.M3BusinessIDs += WebServiceConst.Separater_Comma + detail.Bid;
}
break;
case 4:
if (!report.M4BusinessIDs.Contains(detail.Bid.ToString()))
{
m4Count++;
report.M4BusinessIDs += WebServiceConst.Separater_Comma + detail.Bid;
}
break;
default:
if (!report.M5PlusBusinessIDs.Contains(detail.Bid.ToString()))
{
m5PlusCount++;
report.M5PlusBusinessIDs += WebServiceConst.Separater_Comma + detail.Bid;
}
break;
}
}
report.FirstOverDueCount = firstOverDueCount;
report.FourM2Count = fourM2Count;
report.ThreeNonePayCount = threeNonePayCount;
// M1逾期率
report.M1Rate
= string.Format("{0}%", Math.Round((double)m1Count / (double)loanCount * 100, 1).ToString("#0.0"));
// M2逾期率
report.M2Rate
= string.Format("{0}%", Math.Round((double)m2Count / (double)loanCount * 100, 1).ToString("#0.0"));
// M3逾期率
report.M3Rate
= string.Format("{0}%", Math.Round((double)m3Count / (double)loanCount * 100, 1).ToString("#0.0"));
// M4逾期率
report.M4Rate
= string.Format("{0}%", Math.Round((double)m4Count / (double)loanCount * 100, 1).ToString("#0.0"));
// M5+逾期率
report.M5PlusRate
= string.Format("{0}%", Math.Round((double)m5PlusCount / (double)loanCount * 100, 1).ToString("#0.0"));
listOverDueReportViewData.Add(report);
}
}
if (listOverDueReportViewData == null || listOverDueReportViewData.Count == 0)
{
ServiceUtility.SetResponseStatus(responseEntity, EnumResponseState.NoResult);
m_Logger.Info("未查询到数据。");
}
else
{
var responseResult = new ResponseListResult <OverDueReportViewData>();
responseResult.TotalCount = listOverDueReportViewData.Count;
responseResult.LstResult = listOverDueReportViewData
.Skip((baseFilter.PageNo - 1) * baseFilter.PageSize).Take(baseFilter.PageSize).ToList();
ServiceUtility.SetResponseStatus(responseEntity, EnumResponseState.Success);
responseEntity.Results = responseResult;
}
}
public BlogsImportBasicSettingsModel GetBlogsImportConfig()
{
ServiceUtility.RequestAuthentication();
return(new BlogsImportBasicSettingsModel());
}
private void DefineReferenceTypeInvokeMethods(Type baseType, TypeBuilder typeBuilder, Type interfaceType, PropertyBuilder interfaceIdProperty)
{
var voidType = typeof(void);
var bindingAttr = BindingFlags.Instance | BindingFlags.NonPublic;
var argumentTypes = new Type[] { typeof(int), typeof(object[]), typeof(InvokeMethodOptions) };
var invokeMethodMethod = typeof(Reference).GetMethods(bindingAttr).First(p => p.Name == "InvokeMethod" && p.IsGenericMethod);
var invokeOneWayMethodMethod = typeof(Reference).GetMethods(bindingAttr).First(p => p.Name == "InvokeMethod" && p.ReturnType == typeof(void));
var arrayEmptyMethod = typeof(Array).GetMethod(nameof(Array.Empty)).MakeGenericMethod(typeof(object));
ParameterInfo parameter;
bindingAttr = BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly | BindingFlags.InvokeMethod;
foreach (var method in interfaceType.GetMethods(bindingAttr))
{
var methodId = ServiceUtility.ComputeMethodId(method);
var operationContract = method.GetCustomAttribute <OperationContractAttribute>();
var invokeMethodOptions = operationContract?.Options ?? InvokeMethodOptions.None;
if (invokeMethodOptions.HasFlag(InvokeMethodOptions.OneWay) && method.ReturnType != typeof(void))
{
throw new InvalidOperationException(string.Format("Addressable:{0}.{1} invalid return type:{2}", interfaceType.FullName, method.Name, method.ReturnType.FullName));
}
var parameters = method.GetParameters();
var parameterTypes = parameters.Select(p => p.ParameterType).ToArray();
var methodAttributes = MethodAttributes.Public | MethodAttributes.Final | MethodAttributes.HideBySig | MethodAttributes.NewSlot | MethodAttributes.Virtual;
var methodBuilder = typeBuilder.DefineMethod(method.Name, methodAttributes, CallingConventions.Standard, method.ReturnType, parameterTypes);
for (int index = 0; index < parameters.Length; index++)
{
parameter = parameters[index];
methodBuilder.DefineParameter(index + 1, ParameterAttributes.None, parameter.Name);
}
var iLGenerator = methodBuilder.GetILGenerator();
if (method.ReturnType != voidType)
{
iLGenerator.DeclareLocal(method.ReturnType);
}
iLGenerator.Emit(OpCodes.Ldarg_0);
iLGenerator.Emit(OpCodes.Ldc_I4, methodId);
if (parameters.Length > 0)
{
EmitLdc(iLGenerator, parameters.Length);
iLGenerator.Emit(OpCodes.Newarr, typeof(object));
for (int i = 0; i < parameters.Length; i++)
{
parameter = parameters[i];
iLGenerator.Emit(OpCodes.Dup);
EmitLdc(iLGenerator, i);
EmitLdarg(iLGenerator, i + 1);
if (parameter.ParameterType.IsValueType)
{
iLGenerator.Emit(OpCodes.Box, parameter.ParameterType);
}
iLGenerator.Emit(OpCodes.Stelem_Ref);
}
}
else
{
iLGenerator.Emit(OpCodes.Ldnull);
}
//iLGenerator.Emit(OpCodes.Ldc_I4_0);
EmitLdc(iLGenerator, (byte)invokeMethodOptions);
if (method.ReturnType != voidType)
{
var genericInvokeMethod = invokeMethodMethod.MakeGenericMethod(method.ReturnType);
iLGenerator.Emit(OpCodes.Call, genericInvokeMethod);
iLGenerator.Emit(OpCodes.Ret);
}
else
{
iLGenerator.Emit(OpCodes.Call, invokeOneWayMethodMethod);
iLGenerator.Emit(OpCodes.Ret);
}
}
}
/// <inheritdoc/>
public bool DeleteCustomErrorPageItemInXml(string customErrorPageItemId, string provider)
{
ServiceUtility.DisableCache();
return(this.DeleteCustomErrorPageItemInternal(customErrorPageItemId, provider));
}
/// <summary>
/// this will return the list of claims from database
/// </summary>
/// <returns></returns>
public List<ModelMitchellCliams> GetClaims()
{
ServiceUtility serviceUtility = new ServiceUtility();
return serviceUtility.GetClaims();
}
private void DefineMethodInvokerTypeInvokeMethod(TypeBuilder typeBuilder, Type interfaceType, PropertyBuilder interfaceIdPropertyBuilder)
{
var interfaceMethod = typeof(IMethodInvoker).GetMethod(nameof(IMethodInvoker.Invoke));
var stringFormatMethod = typeof(string).GetMethod(nameof(string.Format), BindingFlags.Static | BindingFlags.Public, null, new Type[] { typeof(string), typeof(object), typeof(object) }, null);
var notSupportedMethodExceptionConstructor = typeof(NotSupportedMethodException).GetConstructor(new Type[] { typeof(string) });
var getMethodIdProperty = typeof(InvokeMethodRequest).GetProperty(nameof(InvokeMethodRequest.MethodId));
var getArgumentsProperty = typeof(InvokeMethodRequest).GetProperty(nameof(InvokeMethodRequest.Arguments));
var methodParameterTypes = new Type[] { typeof(IAddressable), typeof(InvokeMethodRequest) };
var methodAttributes = MethodAttributes.Public | MethodAttributes.Final | MethodAttributes.HideBySig | MethodAttributes.NewSlot | MethodAttributes.Virtual;
var methodBuilder = typeBuilder.DefineMethod(nameof(IMethodInvoker.Invoke), methodAttributes, CallingConventions.HasThis, typeof(object), methodParameterTypes);
var parameters = interfaceMethod.GetParameters();
for (int i = 0; i < parameters.Length; i++)
{
var parameter = parameters[i];
methodBuilder.DefineParameter(i + 1, ParameterAttributes.None, parameter.Name);
}
var iLGenerator = methodBuilder.GetILGenerator();
iLGenerator.DeclareLocal(typeof(int));
iLGenerator.DeclareLocal(typeof(object));
iLGenerator.Emit(OpCodes.Ldarg_2);
iLGenerator.Emit(OpCodes.Callvirt, getMethodIdProperty.GetMethod);
iLGenerator.Emit(OpCodes.Stloc_0);
var bindingAttr = BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly | BindingFlags.InvokeMethod;
var methods = interfaceType.GetMethods(bindingAttr);
var retLabel = iLGenerator.DefineLabel();
var defLabel = iLGenerator.DefineLabel();
var jumpTable = new Label[methods.Length];
var bodyTable = new Label[methods.Length];
for (int i = 0; i < jumpTable.Length; i++)
{
jumpTable[i] = iLGenerator.DefineLabel();
bodyTable[i] = iLGenerator.DefineLabel();
}
var endSentinel = methods.Length - 1;
for (int i = 0; i < methods.Length; i++)
{
var method = methods[i];
var methodId = ServiceUtility.ComputeMethodId(method);
iLGenerator.MarkLabel(jumpTable[i]);
iLGenerator.Emit(OpCodes.Ldloc_0);
iLGenerator.Emit(OpCodes.Ldc_I4, methodId);
iLGenerator.Emit(OpCodes.Beq, bodyTable[i]);
iLGenerator.Emit(OpCodes.Br, i < endSentinel ? jumpTable[i + 1] : defLabel);
}
for (int i = 0; i < methods.Length; i++)
{
var method = methods[i];
iLGenerator.MarkLabel(bodyTable[i]);
iLGenerator.Emit(OpCodes.Ldarg_1);
iLGenerator.Emit(OpCodes.Castclass, interfaceType);
parameters = method.GetParameters();
for (var j = 0; j < parameters.Length; j++)
{
var parameter = parameters[j];
iLGenerator.Emit(OpCodes.Ldarg_2);
iLGenerator.Emit(OpCodes.Callvirt, getArgumentsProperty.GetMethod);
EmitLdc(iLGenerator, j);
iLGenerator.Emit(OpCodes.Ldelem_Ref);
if (parameter.ParameterType.IsValueType)
{
iLGenerator.Emit(OpCodes.Unbox_Any, parameter.ParameterType);
}
else
{
iLGenerator.Emit(OpCodes.Castclass, parameter.ParameterType);
}
}
iLGenerator.Emit(OpCodes.Callvirt, method);
if (method.ReturnType == typeof(void))
{
iLGenerator.Emit(OpCodes.Ldnull);
}
else if (method.ReturnType.IsValueType)
{
iLGenerator.Emit(OpCodes.Box, method.ReturnType);
}
iLGenerator.Emit(OpCodes.Stloc_1);
iLGenerator.Emit(OpCodes.Br, retLabel);
}
iLGenerator.MarkLabel(defLabel);
iLGenerator.Emit(OpCodes.Ldstr, "interfaceId={0},methodId={1}");
iLGenerator.Emit(OpCodes.Ldarg_0);
iLGenerator.Emit(OpCodes.Call, interfaceIdPropertyBuilder.GetMethod);
iLGenerator.Emit(OpCodes.Box, interfaceIdPropertyBuilder.PropertyType);
iLGenerator.Emit(OpCodes.Ldarg_2);
iLGenerator.Emit(OpCodes.Callvirt, getMethodIdProperty.GetMethod);
iLGenerator.Emit(OpCodes.Box, getMethodIdProperty.PropertyType);
iLGenerator.Emit(OpCodes.Call, stringFormatMethod);
iLGenerator.Emit(OpCodes.Newobj, notSupportedMethodExceptionConstructor);
iLGenerator.Emit(OpCodes.Throw);
iLGenerator.MarkLabel(retLabel);
iLGenerator.Emit(OpCodes.Ldloc_1);
iLGenerator.Emit(OpCodes.Ret);
}
