/// <summary>
/// Receives tracking events. Instance terminated events are written to the event log.
/// </summary>
protected override void Send(TrackingRecord record)
{
WorkflowTrackingRecord instanceTrackingRecord = record as WorkflowTrackingRecord;
if ((null == instanceTrackingRecord) || (TrackingWorkflowEvent.Terminated != instanceTrackingRecord.TrackingWorkflowEvent))
{
return;
}
// Create an EventLog instance and assign its source.
EventLog log = new EventLog();
log.Source = sourceValue;
// Write an informational entry to the event log.
TrackingWorkflowTerminatedEventArgs terminatedEventArgs = instanceTrackingRecord.EventArgs as TrackingWorkflowTerminatedEventArgs;
StringBuilder message = new StringBuilder(512);
message.AppendLine(string.Format(System.Globalization.CultureInfo.InvariantCulture, "Workflow instance {0} has been terminated.", parametersValue.InstanceId.ToString()));
message.AppendLine();
if (null != terminatedEventArgs.Exception)
{
message.AppendLine(terminatedEventArgs.Exception.ToString());
}
log.WriteEntry(message.ToString(), EventLogEntryType.Warning);
}
protected override void Send(TrackingRecord record)
{
//Process.GetCurrentProcess().MachineName
//System.Threading.Thread.CurrentThread.ManagedThreadId
ActivityTrackingRecord activityTrackingRecord = record as ActivityTrackingRecord;
if (activityTrackingRecord != null)
{
WorkflowEnvironment.WorkBatch.Add(this,
BuildSerializableActivityTrackRecord(activityTrackingRecord));
return;
}
WorkflowTrackingRecord workflowTrackingRecord = record as WorkflowTrackingRecord;
if (workflowTrackingRecord != null)
{
WorkflowEnvironment.WorkBatch.Add(this,
BuildSerializableWorkFlowTrackRecord(workflowTrackingRecord));
return;
}
UserTrackingRecord userTrackingRecord = record as UserTrackingRecord;
//TrackingRecord userTrackingRecord = record as UserTrackingRecord;
if (record is UserTrackingRecord)
{
WorkflowEnvironment.WorkBatch.Add(this, record);
//Debug.WriteLine(((UserTrackingRecord)record).UserData);
}
}
//On Tracing Record Received call the TrackingRecordReceived with the record received information from the TrackingParticipant.
//We also do not worry about Expressions' tracking data
protected void OnTrackingRecordReceived(TrackingRecord record, TimeSpan timeout)
{
System.Diagnostics.Debug.WriteLine(
String.Format("Tracking Record Received: {0} with timeout: {1} seconds.", record, timeout.TotalSeconds)
);
if (TrackingRecordReceived != null)
{
ActivityStateRecord activityStateRecord = record as ActivityStateRecord;
if ((activityStateRecord != null) && (!activityStateRecord.Activity.TypeName.Contains("System.Activities.Expressions")))
{
if (ActivityIdToWorkflowElementMap.ContainsKey(activityStateRecord.Activity.Id))
{
TrackingRecordReceived(this, new TrackingEventArgs(
record,
timeout,
ActivityIdToWorkflowElementMap[activityStateRecord.Activity.Id]
)
);
}
}
else
{
TrackingRecordReceived(this, new TrackingEventArgs(record, timeout, null));
}
}
}
protected override void Track(TrackingRecord record, TimeSpan timeout)
{
if (Received != null)
{
Received.BeginInvoke(record, BeginInvokeCallback, Received);
}
}
protected override void Track(TrackingRecord record, TimeSpan timeout)
{
Contract.Assert(null != record);
Contract.Assert(null != timeout);
if (record is ActivityStateRecord)
{
LogActivityRecord((ActivityStateRecord)record);
}
else if (record is WorkflowInstanceRecord)
{
LogWorkflowRecord((WorkflowInstanceRecord)record);
}
else if (record is BookmarkResumptionRecord)
{
LogBookmarkRecord((BookmarkResumptionRecord)record);
}
else if (record is ActivityScheduledRecord)
{
LogActivityScheduledRecord((ActivityScheduledRecord)record);
}
else if (record is CancelRequestedRecord)
{
LogCancelRequestedRecord((CancelRequestedRecord)record);
}
else if (record is FaultPropagationRecord)
{
LogFaultPropagationRecord((FaultPropagationRecord)record);
}
else
{
LogCustomRecord((CustomTrackingRecord)record);
}
}
protected override void Track(TrackingRecord record, TimeSpan timeout)
{
Console.WriteLine();
IDictionary <string, string> annotations = record.Annotations;
Console.WriteLine(record.ToString());
}
protected override void Send(TrackingRecord record)
{
var activityTrackingRecord = record as ActivityTrackingRecord;
if (activityTrackingRecord == null)
{
return;
}
var type = GetWorkflowType(_parameters.WorkflowType);
if (type.StatesToIgnoreInTracking.Count(s => s.Equals(activityTrackingRecord.QualifiedName, StringComparison.InvariantCultureIgnoreCase)) > 0)
{
return;
}
using (var context = new Budget2DataContext(ConfigurationManager.ConnectionStrings["default"].ConnectionString))
{
WorkflowTrackingHistory item = new WorkflowTrackingHistory()
{
Id = Guid.NewGuid(),
TransitionTime = DateTime.Now,
StateName = activityTrackingRecord.QualifiedName,
WorkflowId = _parameters.InstanceId,
WorkflowTypeId = type.Id
};
context.WorkflowTrackingHistories.InsertOnSubmit(item);
context.SubmitChanges();
}
}
protected override void Track(TrackingRecord record, TimeSpan timeout)
{
Event e = null;
if (record is ActivityStateRecord)
{
e = ProcessTrackingRecord((ActivityStateRecord)record);
}
else if (record is CustomTrackingRecord)
{
e = ProcessTrackingRecord((CustomTrackingRecord)record);
}
else if (record is FaultPropagationRecord)
{
e = ProcessTrackingRecord((FaultPropagationRecord)record);
}
else
{
Console.WriteLine(record);
}
if (e != null)
{
Jhu.Graywulf.Logging.Logger.Instance.LogEvent(e);
}
}
protected override void Track(TrackingRecord record, TimeSpan timeout)
{
Console.ForegroundColor = ConsoleColor.Cyan;
if (record is ActivityScheduledRecord)
{
ActivityScheduledRecord actSchedule = record as ActivityScheduledRecord;
Console.WriteLine("Name: {0}, Scheduled", actSchedule.Child.Name);
}
else if (record is ActivityStateRecord)
{
ActivityStateRecord actState = record as ActivityStateRecord;
Console.WriteLine("Name: {0}, {1}", actState.Activity.Name, actState.State);
}
else if (record is WorkflowInstanceRecord)
{
WorkflowInstanceRecord wInstanceRecord = record as WorkflowInstanceRecord;
Console.WriteLine("WorkFlow, {0}", wInstanceRecord.State);
}
else
{
Console.WriteLine(record.ToString());
}
Console.ResetColor();
}
/// <summary>
/// Tracks a record.
/// </summary>
/// <param name="record"></param>
/// <param name="timeout"></param>
protected override void Track(TrackingRecord record, TimeSpan timeout)
{
if (ActivityActorEventSource.Current.IsEnabled())
{
TrackRecord(record);
}
}
private void PersistRecord(TrackingRecord tr)
{
try
{
String path = Path.Combine(
Environment.CurrentDirectory, "tracking");
String fileName = String.Format("{0}.{1}",
tr.EventTime.ToString("yyyyMMdd.HHmmss.fffffff"),
tr.RecordNumber);
String fullPath = Path.Combine(path, fileName + ".xml");
if (!Directory.Exists(path))
{
Directory.CreateDirectory(path);
}
using (FileStream stream =
new FileStream(fullPath, FileMode.Create))
{
XmlWriterSettings settings = new XmlWriterSettings();
settings.Encoding = Encoding.UTF8;
using (XmlWriter writer = XmlWriter.Create(stream, settings))
{
writer.WriteRaw(TrackingRecordSerializer.Serialize(tr));
}
}
}
catch (IOException exception)
{
Console.WriteLine(
"PersistRecord Exception: {0}", exception.Message);
}
}
/// <summary>
/// Tracks the given record.
/// </summary>
/// <param name="record"></param>
/// <param name="timeout"></param>
protected override void Track(TrackingRecord record, TimeSpan timeout)
{
if (telemetryClient.IsEnabled())
{
TrackRecord(record);
}
}
private void ProcessingThreadProc()
{
while (_isThreadRunning)
{
if (_recordsToProcess.WaitOne(2000))
{
Int32 count = 0;
lock (_records)
{
count = _records.Count;
}
while (count > 0)
{
TrackingRecord record = null;
lock (_records)
{
record = _records.Dequeue();
count = _records.Count;
}
if (record != null)
{
PersistRecord(record);
}
}
}
}
}
protected override void Track(TrackingRecord record, TimeSpan timeout)
{
switch (record.Level)
{
case TraceLevel.Error:
{
Trace.TraceError(FormatMessage(record));
break;
}
case TraceLevel.Warning:
{
Trace.TraceWarning(FormatMessage(record));
break;
}
case TraceLevel.Info:
{
{
Trace.TraceInformation(FormatMessage(record));
break;
}
}
default:
{
Trace.WriteLine(FormatMessage(record));
break;
}
}
}
protected override void Track(TrackingRecord record, TimeSpan timeout)
{
if (record is StateMachineStateRecord)
{
var stateMachineRecord = (StateMachineStateRecord)record;
Log.Debug("State Change {stateMachineRecord.InstanceId}: {stateMachineRecord.StateName}");
OnWorkflowInstanceStateChange?.Invoke(stateMachineRecord);
}
else if (record is ActivityStateRecord)
{
var activityStateRecord = (ActivityStateRecord)record;
if (activityStateRecord.Activity.TypeName == "System.Activities.Statements.InternalState")
{
Log.Debug("Activity State: {stateRecord.InstanceId} - {stateRecord.Activity.Name} ({stateRecord.State})");
}
OnWorkflowInstanceActivityChange?.Invoke(activityStateRecord);
}
else if (record is WorkflowInstanceRecord)
{
var instanceRecord = (WorkflowInstanceRecord)record;
Log.Debug($"Instance State: {instanceRecord.InstanceId} - {instanceRecord.ActivityDefinitionId} ({instanceRecord.State})");
OnWorkflowInstanceChange?.Invoke(instanceRecord);
}
}
protected override void Track(TrackingRecord record, TimeSpan timeout)
{
if (record is ActivityStateRecord)
{
TrackActivityRecord((ActivityStateRecord)record);
}
else if (record is WorkflowInstanceRecord)
{
TrackWorkflowRecord((WorkflowInstanceRecord)record);
}
else if (record is BookmarkResumptionRecord)
{
TrackBookmarkRecord((BookmarkResumptionRecord)record);
}
else if (record is ActivityScheduledRecord)
{
TrackActivityScheduledRecord((ActivityScheduledRecord)record);
}
else if (record is CancelRequestedRecord)
{
TrackCancelRequestedRecord((CancelRequestedRecord)record);
}
else if (record is FaultPropagationRecord)
{
TrackFaultPropagationRecord((FaultPropagationRecord)record);
}
else if (record is CustomTrackingRecord)
{
TrackCustomRecord((CustomTrackingRecord)record);
}
else
{
throw new PlatformNotSupportedException(Resources.UnrecognizedTrackingRecord(record?.GetType().Name));
}
}
// The track method is called when a tracking record is emitted by the workflow runtime
protected override void Track(TrackingRecord record, TimeSpan timeout)
{
TrackingCommand trackingCommand = new TrackingCommand(record);
try
{
using (SqlConnection sqlConnection = new SqlConnection(this.connectionString))
{
sqlConnection.Open();
SqlCommand sqlCommand = sqlConnection.CreateCommand();
foreach (SqlParameter parameter in trackingCommand.Parameters)
{
sqlCommand.Parameters.Add(parameter);
}
int sqlTimeout = (int)timeout.TotalSeconds;
if (sqlTimeout > 0)
{
sqlCommand.CommandTimeout = sqlTimeout;
}
// Wrap the command in a transaction since the command may contain multiple statements.
sqlCommand.Transaction = sqlConnection.BeginTransaction();
sqlCommand.CommandText = trackingCommand.Procedure;
sqlCommand.CommandType = CommandType.StoredProcedure;
sqlCommand.ExecuteNonQuery();
sqlCommand.Transaction.Commit();
}
}
catch (Exception e)
{
Trace.WriteLine(String.Format(CultureInfo.InvariantCulture, "SqlTrackingParticipant: Exception in Track {0}", e.StackTrace));
}
}
public TrackingCommand(TrackingRecord record)
: this()
{
ActivityScheduledRecord activityScheduledRecord = record as ActivityScheduledRecord;
if (activityScheduledRecord != null)
{
CreateTrackingCommand(activityScheduledRecord);
return;
}
CancelRequestedRecord cancelRequestedRecord = record as CancelRequestedRecord;
if (cancelRequestedRecord != null)
{
CreateTrackingCommand(cancelRequestedRecord);
return;
}
FaultPropagationRecord faultPropagationRecord = record as FaultPropagationRecord;
if (faultPropagationRecord != null)
{
CreateTrackingCommand(faultPropagationRecord);
return;
}
ActivityStateRecord activityStateRecord = record as ActivityStateRecord;
if (activityStateRecord != null)
{
CreateTrackingCommand(activityStateRecord);
return;
}
WorkflowInstanceRecord workflowInstanceRecord = record as WorkflowInstanceRecord;
if (workflowInstanceRecord != null)
{
CreateTrackingCommand(workflowInstanceRecord);
return;
}
BookmarkResumptionRecord bookmarkResumptionRecord = record as BookmarkResumptionRecord;
if (bookmarkResumptionRecord != null)
{
CreateTrackingCommand(bookmarkResumptionRecord);
return;
}
CustomTrackingRecord customTrackingRecord = record as CustomTrackingRecord;
if (customTrackingRecord != null)
{
CreateTrackingCommand(customTrackingRecord);
return;
}
}
public async Task <IActionResult> TrackingRecordUpdate(TrackingRecordUpdateDto model)
{
if (ModelState.IsValid)
{
TrackingRecord trackingRecord = await trackingRecordGenericService.GetByIdAsync(model.Id);
if (trackingRecord != null)
{
trackingRecord.Transfer(model);
trackingRecord.UpdateUserId = appUserSessionService.Get().Id;
await trackingRecordGenericService.UpdateAsync(trackingRecord);
return(Json(new { IsOk = true, Massage = "Ürün Guncellendi" }));
}
else
{
ModelState.AddModelError("", "Lütfen verileri manipüle etmeyiniz");
string messages = ModelState.GetErrorsString();
return(Json(new { IsOk = false, Massage = messages }));
}
}
else
{
ModelState.AddModelError("", "Lütfen gerekli tüm alanları doldurun.");
string messages = ModelState.GetErrorsString();
return(Json(new { IsOk = false, Massage = messages }));
}
}
protected override void Track(TrackingRecord record, TimeSpan timeout)
{
StringBuilder trackingContents = new StringBuilder();
trackingContents.AppendFormat(CultureInfo.InvariantCulture,
"{0}: Level: {1}, RecordNumber: {2}",
record.GetType().Name, record.Level, record.RecordNumber);
if (record is WorkflowInstanceRecord)
{
trackingContents.AppendFormat(CultureInfo.InvariantCulture,
" Workflow InstanceID: {0} Workflow instance state: {1}\n",
record.InstanceId, ((WorkflowInstanceRecord)record).State);
}
else if (record is ActivityStateRecord)
{
ActivityStateRecord activityTrackingRecord = (ActivityStateRecord)record;
IDictionary <String, object> variables = activityTrackingRecord.Variables;
StringBuilder vars = new StringBuilder();
if (variables.Count > 0)
{
vars.AppendLine("\n\tVariables:");
foreach (KeyValuePair <string, object> variable in variables)
{
vars.AppendLine(String.Format(
"\t\tName: {0} Value: {1}", variable.Key, variable.Value));
}
}
trackingContents.AppendFormat(CultureInfo.InvariantCulture,
" :Activity DisplayName: {0} :ActivityInstanceState: {1} {2}\n",
activityTrackingRecord.Activity.Name, activityTrackingRecord.State,
((variables.Count > 0) ? vars.ToString() : String.Empty));
}
else if (record is ActivityScheduledRecord)
{
trackingContents.AppendFormat(CultureInfo.InvariantCulture,
" :ChildActivity DisplayName: {0}\n",
((ActivityScheduledRecord)record).Child.Name);
}
else if (record is CustomTrackingRecord)
{
CustomTrackingRecord userTrackingRecord = (CustomTrackingRecord)record;
if (userTrackingRecord.Data.Count > 0)
{
trackingContents.AppendFormat(CultureInfo.InvariantCulture,
"\n\tUser Data:\n");
foreach (string data in userTrackingRecord.Data.Keys)
{
trackingContents.AppendFormat(CultureInfo.InvariantCulture,
" \t\t {0} : {1}\n", data, userTrackingRecord.Data[data]);
}
}
}
this.writer.WriteLine(trackingContents);
}
protected override void Track(TrackingRecord record, TimeSpan timeout)
{
var sb = new StringBuilder(record.ToString());
//foreach (var annotation in record.Annotations)
// sb.AppendLine(annotation.Key + " " + annotation.Value);
Debug.WriteLine(sb.ToString());
}
private static void WriteTrackingRecord(TrackingRecord record)
{
WriteTitle("Tracking Record");
Console.WriteLine(string.Format("{0}: {1} on {2}: ",
record.Annotations,
record.EventArgs,
record.EventDateTime.ToString()));
}
protected override void Track(TrackingRecord record, TimeSpan timeout)
{
lock (_records)
{
_records.Enqueue(record);
}
_recordsToProcess.Set();
}
// Send() is called by Tracking runtime to send various tracking records
protected override void Send(TrackingRecord record)
{
//filter on record type
if (record is UserTrackingRecord)
{
WriteUserTrackingRecord((UserTrackingRecord)record);
}
}
protected override void Track(TrackingRecord record, TimeSpan timeout)
{
if (record != null)
{
Console.WriteLine("====================================");
Console.WriteLine(record);
}
}
protected override void Track(TrackingRecord record, TimeSpan timeout)
{
if (record is ActivityStateRecord)
{
ActivityStateRecord state = record as ActivityStateRecord;
if (null == state.Activity)
{
return;
}
bool closed = state.State.Equals("Closed"); //NOXLATE
StringBuilder logLine = new StringBuilder();
logLine.Append(String.Format(
"{0}{1}{2} {3} {4}", //NOXLATE
state.Level.ToString(), _indent,
closed ? "<-" : "--", //NOXLATE
state.Activity.Id, GetName(state.Activity)));
if (record.Level == TraceLevel.Info)
{
if (closed)
{
if (state.Arguments.ContainsKey("Result")) // NOXLATE
{
logLine.Append(String.Format(
" == \"{0}\"", state.Arguments["Result"])); //NOXLATE
}
DecrementIndent();
}
else
{
foreach (KeyValuePair <string, object> keyValue in state.Arguments)
{
Track(keyValue, logLine);
}
}
}
_log.AppendLine(logLine.ToString());
}
else if (record is ActivityScheduledRecord)
{
ActivityScheduledRecord scheduled = record as ActivityScheduledRecord;
if (null == scheduled.Activity || null == scheduled.Child)
{
return;
}
if (record.Level == TraceLevel.Info)
{
IncrementIndent();
}
StringBuilder logLine = new StringBuilder();
logLine.Append(String.Format(
"{0}{1}-> {2} {3}", //NOXLATE
scheduled.Level.ToString(), _indent, //scheduled.Activity.Id, GetName(scheduled.Activity), <- parent activity
scheduled.Child.Id, GetName(scheduled.Child)));
_log.AppendLine(logLine.ToString());
}
}
protected override void Track(TrackingRecord record, TimeSpan timeout)
{
// Log header information
AddEvent(String.Format("Type: {0} Level: {1}, RecordNumber: {2}",
record.GetType().Name, record.Level, record.RecordNumber));
// If this is a instance record
WorkflowInstanceRecord instance = record as WorkflowInstanceRecord;
if (instance != null)
{
AddEvent(String.Format(" InstanceID: {0} State: {1}",
instance.InstanceId, instance.State));
}
// If this is a bookmark record
BookmarkResumptionRecord bookmark = record as BookmarkResumptionRecord;
if (bookmark != null)
{
AddEvent(String.Format(" Bookmark {0} resumed",
bookmark.BookmarkName));
}
// If this is an activity record
ActivityStateRecord activity = record as ActivityStateRecord;
if (activity != null)
{
IDictionary <String, object> variables = activity.Variables;
StringBuilder s = new StringBuilder();
if (variables.Count > 0)
{
s.AppendLine(" Variables:");
foreach (KeyValuePair <string, object> v in variables)
{
s.AppendLine(String.Format(" {0} Value: [{1}]",
v.Key, v.Value));
}
}
AddEvent(String.Format(" Activity: {0} State: {1} {2}",
activity.Activity.Name, activity.State, s.ToString()));
}
// If this is a user record
CustomTrackingRecord user = record as CustomTrackingRecord;
if ((user != null) && (user.Data.Count > 0))
{
AddEvent(String.Format(" User Data: {0}", user.Name));
foreach (string data in user.Data.Keys)
{
AddEvent(String.Format(" {0} : {1}", data, user.Data[data]));
}
}
}
/// <summary>
/// Appends the current TrackingRecord data to the Workflow Execution Log
/// </summary>
/// <param name="trackRecord">Tracking Record Data</param>
/// <param name="timeStamp">Timestamp</param>
protected override void Track(TrackingRecord trackRecord, TimeSpan timeStamp)
{
ActivityStateRecord recordEntry = trackRecord as ActivityStateRecord;
if (recordEntry != null)
{
TrackData += String.Format("[{0}] [{1}] [{2}]" + Environment.NewLine, recordEntry.EventTime.ToLocalTime().ToString(), recordEntry.Activity.Name, recordEntry.State);
}
}
protected override void Track(TrackingRecord record, TimeSpan timeout)
{
var r = false;
if (OnTrackingRecordReceived != null)
{
r = OnTrackingRecordReceived(record, timeout);
}
}
public async Task <IViewComponentResult> InvokeAsync(UpdateModalViewModel model)
{
ViewBag.ModalModel = new ModalViewModel(model.Name, model.Submit);
TrackingRecord trackingRecord = await trackingRecordService.GetByIdAsync(model.Id);
TrackingRecordUpdateDto vm = trackingRecord != null?mapper.Map <TrackingRecordUpdateDto>(trackingRecord) : new TrackingRecordUpdateDto();
return(View(vm));
}
/// <summary>
/// 追踪
/// </summary>
/// <param name="TrackingTower">追踪塔</param>
/// <param name="Steps">步数</param>
public void Track(Tower TrackingTower, int Steps)
{
foreach (TrackingRecord r in FTrackingTowers)
{
if (r.TrackingTower == TrackingTower)
{
r.RemainSteps += Steps;
return;
}
}
TrackingRecord tr = new TrackingRecord();
tr.TrackingTower = TrackingTower;
tr.RemainSteps = Steps;
FTrackingTowers.AddLast(tr);
}