/// <summary>
/// اجرای محاسبات برای یک نفر
/// </summary>
/// <param name="personId">شناسه شخص</param>
/// <param name="todate">انتهای بازه ی محاسبات</param>
public void Execute(string CallerIdentity, decimal personId, DateTime toDate)
{
try
{
ExecutablePersonCalculation MustExecuted = ExecutablePersonCalculation.GetExecutablePersonCalcRepositoy(false).GetByPrsId(personId, toDate);
ThreadHelper.CleanupThreads();
logger.Logger.Info(
string.Format("Execute for person '{0}' start at '{1}', Total Thread Count: '{2}', Runing Thread Count: '{3}'", personId.ToString()
, DateTime.Now.ToShortDateString()
, ThreadHelper.TotalThreadCount
, ThreadHelper.TotalExecutingThreadCount));
logger.Flush();
if (MustExecuted != null /*&& !MustExecuted.CalculationIsValid*/)
{
MustExecuted.ToDate = toDate;
ExecutableThread.ThreadParam param = ThreadHelper.ForceToExecute(CallerIdentity, MustExecuted, this.FinishedCallback);
if (param != null)
{
this.Execute(param);
}
}
}
catch (BaseException ex)
{
throw ex;
}
}
/// <summary>
/// تاریخ آخرین زمان محاسبات پرسنلی که محاسبه برای وی انجام شده است را بروزرسانی می نماید
/// </summary>
/// <param name="InvalidCalcResult"></param>
private void UpdateExecutablePersonCalculation(decimal ExecutablePrsCalcId, decimal PersonId, DateTime ToDate)
{
ExecutablePersonCalculation ExecPrsCalc = ExecutablePersonCalculation.GetExecutablePersonCalcRepositoy(false).GetById(ExecutablePrsCalcId, false);
if (ExecPrsCalc != null)
{
ExecPrsCalc.FromDate = ToDate;
ExecPrsCalc.CalculationIsValid = true;
ExecPrsCalc.MidNightCalculate = true;
ExecutablePersonCalculation.GetExecutablePersonCalcRepositoy(false).WithoutTransactUpdate(ExecPrsCalc);
}
else
{
gtsRuleLogger.Error(PersonId.ToString(), "This is a test log", new Exception());
gtsRuleLogger.Flush();
}
}
/// <summary>
/// این تابع وظیفه اجرای قوانین برای تماممی اشخاص شده در پارامتر تا تاریخ ورودی را برعهده دارد
/// </summary>
/// <param name="Persons"></param>
/// <param name="Date"></param>
public void Execute(string CallerIdentity, IList <decimal> Persons, DateTime toDate)
{
try
{
IList <ExecutablePersonCalculation> MustExecuted = ExecutablePersonCalculation.GetExecutablePersonCalcRepositoy(false).GetAllByPrsIds(Persons, toDate);
ThreadHelper.CleanupThreads();
IList <ExecutablePersonCalculation> Threads = ThreadHelper.AddThreads(CallerIdentity, MustExecuted, this.FinishedCallback);
logger.Logger.Info(
string.Format("Execute all start at '{0}', Total Thread Count: '{1}', Executable Thread Count: '{2}', Runing Thread Count: '{3}'", DateTime.Now.ToShortDateString()
, ThreadHelper.TotalThreadCount
, ThreadHelper.TotalThreadCount - ThreadHelper.TotalExecutingThreadCount
, ThreadHelper.TotalExecutingThreadCount));
logger.Flush();
IList <Action> actions = new List <Action>();
foreach (ExecutablePersonCalculation item in Threads /*.Where(x => x.CalculationIsValid == false)*/)
{
item.ToDate = toDate;
ExecutableThread.ThreadParam param = ThreadHelper.PrepareToExecute(CallerIdentity, item);
if (param != null)
{
//ThreadPool.QueueUserWorkItem(new WaitCallback(this.Execute), param);
actions.Add(() => this.Execute(param));
}
}
Task.Factory.StartNew(() => Parallel.Invoke(
new ParallelOptions()
{
MaxDegreeOfParallelism = MaxThread
},
actions.ToArray()));
}
catch (Exception ex)
{
logger.Error("Execute(string CallerIdentity, IList<decimal> Persons, DateTime toDate)->", "" + ex.Message, ex);
logger.Flush();
throw ex;
}
}
//private GTSEngineLogger gtsRuleLogger = new GTSEngineLogger();
#endregion
#region Comment
/*
* private Person GetPerson(decimal personId)
* {
* IPersonRepository PrsRep = Person.GetPersonRepository(false);
* return PrsRep.GetById(personId, false);
* }
* private Person GetPerson(string barcode)
* {
* IPersonRepository PrsRep = Person.GetPersonRepository(false);
* return PrsRep.GetByBarcode(barcode);
* }
*
* /// <summary>
* /// .این تابع مسئول اجرای قوانین تمامی پرسنل در تاریخ درخواست شده می باشد
* /// it's not Thread-Safe
* /// </summary>
* /// <param name="CalculationDate">تاریخ اعمال قوانین</param>
* /// <returns>پرسنل مشخص شده را به منظور بارگذاری مجدد در دسترسی های بعدی برمی گرداند</returns>
* private Person Execute(decimal personId)
* {
* Person person = null;
* person = GetPerson((int)personId);
*
* ExecutableThread.ThreadExecuteParam param = new ExecutableThread.ThreadExecuteParam();
* param.person = person;
*
* Execute(param);
*
* return person ?? null;
* }
*
* /// <summary>
* /// قوانین تردد را برای پرسنل با بارکد مشخص شده اجرا می نماید
* /// </summary>
* /// <param name="barcode"></param>
* /// <returns>پرسنل مشخص شده را به منظور بارگذاری مجدد در دسترسی های بعدی برمی گرداند</returns>
* private Person Execute(string barcode)
* {
* Person person = null;
* person = GetPerson(barcode);
*
* ExecutableThread.ThreadExecuteParam param = new ExecutableThread.ThreadExecuteParam();
* param.person = person;
*
*
* Execute(param);
* return person ?? null;
* }
*
* private void Execute()
* {
* IList<InvalidCalculationResult> MustExecuted = InvalidCalculationResult.GetInvalidCalcResultRepositoy(false).GetAll();
* ThreadHelper.AddThreads(MustExecuted,ThreadType.TrafficMapperThread);
* PersonRepository prsnRep = new PersonRepository(false);
*
* foreach (InvalidCalculationResult invalidlCalculationResult in MustExecuted)
* {
* ExecutableThread.ThreadExecuteParam param = new ExecutableThread.ThreadExecuteParam();
* param.FinishedCallback = new ExecutableThread.FinishedMyJob(ThreadHelper.FinishedJob);
* param.person = ThreadHelper.NowExecute(invalidlCalculationResult.Person, ThreadType.TrafficMapperThread) != null ? invalidlCalculationResult.Person : null;
*
* ThreadPool.QueueUserWorkItem(new WaitCallback(Execute), param);
* }
* }
*/
#endregion
public void Execute1(ExecutablePersonCalculation mustExecute)
{
if (mustExecute == null)
{
return;
}
//Person prs = Person.GetPersonRepository(false).GetById(mustExecute.PersonId, false);
//if (prs != null)
{
//prs.InitializeForTrafficMapper(mustExecute.FromDate, mustExecute.ToDate);
//using (NHibernateSessionManager.Instance.BeginTransactionOn())
{
try
{
//TrafficMapper tm = new TrafficMapper(prs);
//tm.DoMap();
//NHibernateSessionManager.Instance.CommitTransactionOn();
}
catch (TrafficMapperRuleException ex)
{
//gtsRuleLogger.Error(prs.BarCode, Infrastructure.Utility.Utility.GetExecptionMessage(ex));
//gtsRuleLogger.Flush();
//NHibernateSessionManager.Instance.RollbackTransactionOn();
throw ex;
}
catch (Exception ex)
{
//gtsRuleLogger.Error(prs.BarCode, String.Format("خطا در هنگام نگاشت تردد های پرسنل با بارکد: {0} متن خطا: {1}", prs.BarCode, Infrastructure.Utility.Utility.GetExecptionMessage(ex)));
//gtsRuleLogger.Flush();
//NHibernateSessionManager.Instance.RollbackTransactionOn();
throw ex;
}
}
}
}
/// <summary>
/// وظیفه تایید اجرای محاسبات برای "شخص" ورودی رابعهده دارد،
/// </summary>
/// <param name="MustExecuted">نگهدارانده "شخصی" که قصد اجرای محاسباتش را داریم</param>
/// <returns>در صورت که "نخی" به ازای "شخص" ورودی وجود نداشته باشد یا هم اکنون محاسبات برای این "شخص" در حال انجام باشد مقدار "خالی" برمی گرداند. در غیراینصورت "شخص" ورودی را برمیگرداند</returns>
public static ExecutableThread.ThreadParam PrepareToExecute(string CallerIdentity, ExecutablePersonCalculation MustExecuted)
{
try
{
mut.WaitOne();
///نخی ما بازای این پرسنل وجود ندارد
if (!executableThreadsWithCaller.ContainsKey(CallerIdentity) ||
!executableThreadsWithCaller[CallerIdentity].ContainsKey(MustExecuted.PersonId))
{
return(null);
}
///نخی محاسبات این پرسنل را قبلا در حالت اجرا قرار داده است
else if (IsThreadExecute(MustExecuted.PersonId))
{
///نخی که محاسبات را در حالت اجرا قرار داده با فراخواننده ی این تابع متفاوت است
if (!executableThreadsWithCaller[CallerIdentity][MustExecuted.PersonId].Executing)
{
executableThreadsWithCaller[CallerIdentity].Remove(MustExecuted.PersonId);
executableThreadsCountWithCaller[CallerIdentity]--;
}
return(null);
}
else
{
executableThreadsWithCaller[CallerIdentity][MustExecuted.PersonId].Executing = true;
executableThreadsWithCaller[CallerIdentity][MustExecuted.PersonId].Duration.Start();
executableThreadsWithCaller[CallerIdentity][MustExecuted.PersonId].Param.ToDate = MustExecuted.ToDate.Date;
return(executableThreadsWithCaller[CallerIdentity][MustExecuted.PersonId].Param);
}
}
finally
{
mut.ReleaseMutex();
}
}
/// <summary>
/// مورد ارسال شده را برای اجرا تست می کند، اگر قبلا برای اجرا ارسال نشده باشد یا اجرا نشده باشد آن را برای اجرا برمی گرداند
/// </summary>
/// <param name="Threads"></param>
/// <returns>موردی که برای اجر پذیرفته شده است</returns>
public static ExecutableThread.ThreadParam ForceToExecute(string CallerIdentity, ExecutablePersonCalculation MustExecuted, FinishedCallback Callback)
{
try
{
mut.WaitOne();
//if (IsThreadExecute(MustExecuted.PersonId))
//{
// ///نخی که محاسبات را در حالت اجرا قرار داده با فراخواننده ی این تابع متفاوت است
// if (executableThreadsWithCaller.ContainsKey(CallerIdentity) &&
// executableThreadsWithCaller[CallerIdentity].ContainsKey(MustExecuted.PersonId) &&
// !executableThreadsWithCaller[CallerIdentity][MustExecuted.PersonId].Executing)
// {
// executableThreadsWithCaller[CallerIdentity].Remove(MustExecuted.PersonId);
// }
// return null;
//}
//else
//{
if (!executableThreadsWithCaller.ContainsKey(CallerIdentity))
{
executableThreadsWithCaller.Add(CallerIdentity, new Dictionary <decimal, ExecutableThread>());
executableThreadsCountWithCaller.Add(CallerIdentity, 0);
}
if (!executableThreadsWithCaller[CallerIdentity].ContainsKey(MustExecuted.PersonId))
{
ExecutableThread executableThread = new ExecutableThread(CallerIdentity,
MustExecuted.ID,
MustExecuted.PersonId,
MustExecuted.FromDate.Date,
MustExecuted.ToDate.Date,
Callback);
executableThreadsWithCaller[CallerIdentity].Add(MustExecuted.PersonId, executableThread);
executableThreadsCountWithCaller[CallerIdentity]++;
}
executableThreadsWithCaller[CallerIdentity][MustExecuted.PersonId].Executing = true;
executableThreadsWithCaller[CallerIdentity][MustExecuted.PersonId].Duration.Start();
executableThreadsWithCaller[CallerIdentity][MustExecuted.PersonId].Param.ToDate = MustExecuted.ToDate;
return(executableThreadsWithCaller[CallerIdentity][MustExecuted.PersonId].Param);
//}
}
finally
{
mut.ReleaseMutex();
}
}
/// <summary>
/// این تابع وظیفه اجرای قوانین برای تماممی اشخاصی که محاسباتشان نامعتبر است را برعهده دارد
/// همجنین تنها توسط سرویس ویندوزی اجرا میگردد
/// </summary>
/// <param name="toDate"></param>
public void ExecuteByRobot(string CallerIdentity, DateTime toDate)
{
try
{
IList <ExecutablePersonCalculation> MustExecuted = ExecutablePersonCalculation.GetExecutablePersonCalcRepositoy(false).GetAll(toDate);
ThreadHelper.CleanupThreads();
IList <ExecutablePersonCalculation> Threads = ThreadHelper.AddThreads(CallerIdentity, MustExecuted, this.FinishedCallback);
logger.Logger.Info(
string.Format("ExecuteByRobot start at '{0}', Total Thread Count: '{1}', Executable Thread Count: '{2}', Runing Thread Count: '{3}'", DateTime.Now.ToShortDateString()
, ThreadHelper.TotalThreadCount
, ThreadHelper.TotalThreadCount - ThreadHelper.TotalExecutingThreadCount
, ThreadHelper.TotalExecutingThreadCount));
logger.Flush();
IList <Action> actions = new List <Action>();
int threadGroupSize = Threads.Count / MaxThread;
if (Threads.Count % MaxThread > 0)
{
MaxThread++;
}
var groupThreadParams = new ExecutableThread.GroupThreadParam[MaxThread];
for (int i = 0; i < MaxThread; i++)
{
//if (Utility.CpuUsage < MaxCPUUsage)
//{
groupThreadParams[i] = new ExecutableThread.GroupThreadParam();
Threads.Skip(threadGroupSize * i).Take(threadGroupSize).ToList().ForEach((item) =>
{
item.ToDate = toDate;
var param = ThreadHelper.PrepareToExecute(CallerIdentity, item);
if (param != null)
{
param.ExecuteByRobot = true;
groupThreadParams[i].ThreadParams.Add(param);
}
});
//}
//else
//{
// cpuUsageExtraCount++;
// ThreadHelper.RemoveThread(CallerIdentity, item.PersonId);
//}
}
groupThreadParams.ToList().ForEach((threadParams) => {
Task.Factory.StartNew(() => { ExecuteGroup(threadParams); });
});
//Task.Factory.StartNew(() => Parallel.Invoke(
// new ParallelOptions() { MaxDegreeOfParallelism = MaxThread },
// actions.ToArray()));
//if (cpuUsageExtraCount > 0)
//{
// logger.Info("ExecuteByRobot", String.Format("عدم اجرا تعداد {0} نفر بدلیل محدودیت پردازنده", cpuUsageExtraCount.ToString()));
// logger.Flush();
//}
}
catch (Exception ex)
{
logger.Error("ExecuteByRobot", "Eception on ExecuteByRobot : " + Utility.GetExecptionMessage(ex), ex);
logger.Flush();
}
}
