public void LogTaskState(ITaskExecuteClient client, ITask task, TaskMessage message)
{
//��������Լ�¼��־
if (this.Storage != null)
this.Storage.SaveTaskChangedState(task, message);
}
public void InsertOrUpdate(TaskMessage taskmessage)
{
if (taskmessage.TaskMessageID == default(long)) {
// New entity
context.TaskMessages.Add(taskmessage);
} else {
// Existing entity
context.Entry(taskmessage).State = System.Data.Entity.EntityState.Modified;
}
}
public static void PostMessage(string taskName, object param = null, int waitSeconds = 0)
{
var msg = new TaskMessage()
{
Name = taskName,
Param = param,
Start = DateTime.Now,
Wait = waitSeconds
};
_messages.Enqueue(msg);
}
public string CreateOrchestrationInstance(string name, string version, object input)
{
string instanceId = Guid.NewGuid().ToString("N");
string serializedInput = this.defaultConverter.Serialize(input);
TaskMessage taskMessage = new TaskMessage();
taskMessage.InstanceId = instanceId;
taskMessage.Event = new ExecutionStartedEvent(-1, serializedInput);
taskMessage.WorkflowDefinition = name;
taskMessage.Version = version;
BrokeredMessage brokeredMessage = new BrokeredMessage(taskMessage);
brokeredMessage.SessionId = taskMessage.InstanceId;
this.oxQueueClient.Send(brokeredMessage);
return instanceId;
}
public virtual async Task AbandonMessageAsync(MessageData message, SessionBase session)
{
CloudQueueMessage queueMessage = message.OriginalQueueMessage;
TaskMessage taskMessage = message.TaskMessage;
OrchestrationInstance instance = taskMessage.OrchestrationInstance;
// Exponentially backoff a given queue message until a maximum visibility delay of 10 minutes.
// Once it hits the maximum, log the message as a poison message.
const int maxSecondsToWait = 600;
int numSecondsToWait = queueMessage.DequeueCount <= 30 ?
Math.Min((int)Math.Pow(2, queueMessage.DequeueCount), maxSecondsToWait) :
maxSecondsToWait;
if (numSecondsToWait == maxSecondsToWait)
{
this.settings.Logger.PoisonMessageDetected(
this.storageAccountName,
this.settings.TaskHubName,
taskMessage.Event.EventType.ToString(),
Utils.GetTaskEventId(taskMessage.Event),
queueMessage.Id,
instance.InstanceId,
instance.ExecutionId,
this.storageQueue.Name,
queueMessage.DequeueCount);
}
this.settings.Logger.AbandoningMessage(
this.storageAccountName,
this.settings.TaskHubName,
taskMessage.Event.EventType.ToString(),
Utils.GetTaskEventId(taskMessage.Event),
queueMessage.Id,
instance.InstanceId,
instance.ExecutionId,
this.storageQueue.Name,
message.SequenceNumber,
numSecondsToWait);
try
{
// We "abandon" the message by settings its visibility timeout using an exponential backoff algorithm.
// This allows it to be reprocessed on this node or another node at a later time, hopefully successfully.
await this.storageQueue.UpdateMessageAsync(
queueMessage,
TimeSpan.FromSeconds(numSecondsToWait),
MessageUpdateFields.Visibility,
this.QueueRequestOptions,
session.StorageOperationContext);
this.stats.MessagesUpdated.Increment();
}
catch (Exception e)
{
// Message may have been processed and deleted already.
this.HandleMessagingExceptions(e, message, $"Caller: {nameof(AbandonMessageAsync)}");
}
finally
{
this.stats.StorageRequests.Increment();
}
}
public TaskMessageItem(TaskMessage taskMessage)
{
this.TaskMessage = taskMessage ?? throw new ArgumentNullException(nameof(taskMessage));
}
public Task CompleteTaskOrchestrationWorkItemAsync(TaskOrchestrationWorkItem workItem, OrchestrationRuntimeState newOrchestrationRuntimeState, IList<TaskMessage> outboundMessages, IList<TaskMessage> orchestratorMessages, IList<TaskMessage> timerMessages, TaskMessage continuedAsNewMessage, OrchestrationState orchestrationState) {
return this.OrchestrationService.CompleteTaskOrchestrationWorkItemAsync(workItem, newOrchestrationRuntimeState, outboundMessages, orchestratorMessages, timerMessages, continuedAsNewMessage, orchestrationState);
}
public void Start()
{
TimeSpan waitTime = new TimeSpan(0);
int brakTime = 5;
int stepTime = 1;
int stopTime = 5;
message = new TaskMessage();
started = true;
try
{
do
{
OnClientUpdate(new ClientUpdateEventArgs("Wysyłanie wiadomości..."));
bytes = TaskMessage.Serialize(message);
client.Send(bytes, bytes.Length, _host, _port);
//Odbierz wiadomość
received = false;
OnClientUpdate(new ClientUpdateEventArgs("Czekam na odpowiedź..."));
IAsyncResult iresult = client.BeginReceive(new AsyncCallback(ReceiveCallback), null);
int index = WaitHandle.WaitAny(new WaitHandle[] { iresult.AsyncWaitHandle }, timeout, false);
if (index == WaitHandle.WaitTimeout)
{
OnClientUpdate(new ClientUpdateEventArgs("Serwer nie odpowiada, czekam " + stopTime + "s..."));
if (stopTime < 60)
{
stopTime += stepTime;
}
waitTime = new TimeSpan(0, 0, stopTime);
Thread.Sleep(waitTime);
//break;
}
else
{
stopTime = 5;
//Trzeba chwilę poczekać...
OnClientUpdate(new ClientUpdateEventArgs("Kończę odbieranie wiadomości..."));
DateTime startTime = DateTime.Now;
waitTime = new TimeSpan(0, 0, 1); //1s
while (!received && DateTime.Now - startTime < waitTime)
{
continue;
}
if (!received)
{
OnClientUpdate(new ClientUpdateEventArgs("Nie udało się odebrać wiadomości :("));
break;
}
OnClientUpdate(new ClientUpdateEventArgs("Wiadomość odebrana"));
if (message.TaskId < 0)
{
if (brakTime < 60)
{
brakTime += stepTime;
}
OnClientUpdate(new ClientUpdateEventArgs("Chwilowo brak aktywnych zadań, czekam " + brakTime.ToString() + "s..."));
waitTime = new TimeSpan(0, 0, brakTime);
Thread.Sleep(waitTime);
}
else
if (message.Task != null)
{
brakTime = 5;
_task = message.Task;
_id = message.TaskId;
OnClientUpdate(new ClientUpdateEventArgs("Wykonuję zadanie..."));
ITaskResult result = _task.Execute();
message.Result = result;
OnClientUpdate(
new ClientUpdateEventArgs("Zakończyłem szukanie")
);
}
}
} while (started);
}
catch (SocketException)
{
OnClientUpdate(new ClientUpdateEventArgs("Serwer nie odpowiada"));
}
catch (Exception ex)
{
MessageBox.Show("Błąd aplikacji klienta: " + ex.ToString());
}
finally
{
started = false;
}
}
public Task <MessageData> AddMessageAsync(TaskMessage message, OrchestrationInstance sourceInstance)
{
return(this.AddMessageAsync(message, sourceInstance, session: null));
}
/******************************/
// client methods
/******************************/
/// <inheritdoc />
public Task CreateTaskOrchestrationAsync(TaskMessage creationMessage)
{
return(CreateTaskOrchestrationAsync(creationMessage, null));
}
/// <inheritdoc />
public Task CompleteTaskOrchestrationWorkItemAsync(
TaskOrchestrationWorkItem workItem,
OrchestrationRuntimeState newOrchestrationRuntimeState,
IList <TaskMessage> outboundMessages,
IList <TaskMessage> orchestratorMessages,
IList <TaskMessage> workItemTimerMessages,
TaskMessage continuedAsNewMessage,
OrchestrationState state)
{
lock (this.thisLock)
{
this.orchestratorQueue.CompleteSession(
workItem.InstanceId,
newOrchestrationRuntimeState != null ?
SerializeOrchestrationRuntimeState(newOrchestrationRuntimeState) : null,
orchestratorMessages,
continuedAsNewMessage
);
if (outboundMessages != null)
{
foreach (TaskMessage m in outboundMessages)
{
// TODO : make async (AFFANDAR)
this.workerQueue.SendMessageAsync(m);
}
}
if (workItemTimerMessages != null)
{
lock (this.timerLock)
{
foreach (TaskMessage m in workItemTimerMessages)
{
this.timerMessages.Add(m);
}
}
}
if (state != null)
{
if (!this.instanceStore.TryGetValue(workItem.InstanceId, out Dictionary <string, OrchestrationState> mapState))
{
mapState = new Dictionary <string, OrchestrationState>();
this.instanceStore[workItem.InstanceId] = mapState;
}
mapState[workItem.OrchestrationRuntimeState.OrchestrationInstance.ExecutionId] = state;
// signal any waiters waiting on instanceid_executionid or just the latest instanceid_
if (state.OrchestrationStatus == OrchestrationStatus.Running ||
state.OrchestrationStatus == OrchestrationStatus.Pending)
{
return(Task.FromResult(0));
}
string key = workItem.OrchestrationRuntimeState.OrchestrationInstance.InstanceId + "_" +
workItem.OrchestrationRuntimeState.OrchestrationInstance.ExecutionId;
string key1 = workItem.OrchestrationRuntimeState.OrchestrationInstance.InstanceId + "_";
var tasks = new List <Task>();
if (this.orchestrationWaiters.TryGetValue(key, out TaskCompletionSource <OrchestrationState> tcs))
{
tasks.Add(Task.Run(() => tcs.TrySetResult(state)));
}
// for instance id level waiters, we will not consider ContinueAsNew as a terminal state because
// the high level orchestration is still ongoing
if (state.OrchestrationStatus != OrchestrationStatus.ContinuedAsNew &&
this.orchestrationWaiters.TryGetValue(key1, out TaskCompletionSource <OrchestrationState> tcs1))
{
tasks.Add(Task.Run(() => tcs1.TrySetResult(state)));
}
if (tasks.Count > 0)
{
Task.WaitAll(tasks.ToArray());
}
}
}
return(Task.FromResult(0));
}
void OnTaskMessage(TaskMessage message)
{
Task = message.Task;
}
async Task <MessageData> AddMessageAsync(TaskMessage taskMessage, OrchestrationInstance sourceInstance, SessionBase session)
{
MessageData data;
try
{
// We transfer to a new trace activity ID every time a new outbound queue message is created.
Guid outboundTraceActivityId = Guid.NewGuid();
data = new MessageData(
taskMessage,
outboundTraceActivityId,
this.storageQueue.Name,
session?.GetCurrentEpisode() ?? 0);
data.SequenceNumber = Interlocked.Increment(ref messageSequenceNumber);
string rawContent = await messageManager.SerializeMessageDataAsync(data);
CloudQueueMessage queueMessage = new CloudQueueMessage(rawContent);
AnalyticsEventSource.Log.SendingMessage(
outboundTraceActivityId,
this.storageAccountName,
this.settings.TaskHubName,
taskMessage.Event.EventType.ToString(),
Utils.GetTaskEventId(taskMessage.Event),
sourceInstance.InstanceId,
sourceInstance.ExecutionId,
Encoding.Unicode.GetByteCount(rawContent),
data.QueueName /* PartitionId */,
taskMessage.OrchestrationInstance.InstanceId,
taskMessage.OrchestrationInstance.ExecutionId,
data.SequenceNumber,
data.Episode,
Utils.ExtensionVersion);
await this.storageQueue.AddMessageAsync(
queueMessage,
null /* timeToLive */,
GetVisibilityDelay(taskMessage),
this.QueueRequestOptions,
session?.StorageOperationContext);
this.stats.MessagesSent.Increment();
// Wake up the queue polling thread
this.backoffHelper.Reset();
}
catch (StorageException e)
{
AnalyticsEventSource.Log.MessageFailure(
this.storageAccountName,
this.settings.TaskHubName,
string.Empty /* MessageId */,
sourceInstance.InstanceId,
sourceInstance.ExecutionId,
this.storageQueue.Name,
taskMessage.Event.EventType.ToString(),
Utils.GetTaskEventId(taskMessage.Event),
e.ToString(),
Utils.ExtensionVersion);
throw;
}
finally
{
this.stats.StorageRequests.Increment();
}
return(data);
}
public void ShowTaskMessage(int teacherNum, TaskMessage message)
{
message.Transform.SetParent(_teachers[teacherNum].MessageArea);
message.Transform.localPosition = Vector3.zero;
}
public async Task <IHttpActionResult> SendTaskOrchestrationMessage([FromUri] long messageId, [FromBody] TaskMessage message)
{
if (messageId != message.SequenceNumber)
{
return(Conflict());
}
message.OrchestrationInstance.InstanceId.EnsureValidInstanceId();
await this.orchestrationServiceClient.SendTaskOrchestrationMessageAsync(message);
return(new OkResult(this));
}
public void Ongo()
{
try
{
TaskInfoDialog = TaskInfoDialogViewModel.getInstance();
TaskMessage taskMessage = new TaskMessage();
taskMessage.Title = "导出项目：" + Project.ProjectName;
taskMessage.Progress = 0.0;
TaskInfoDialog.Messages.Insert(0, taskMessage);
NaturalBuildingDal naturalBuildingDal = new NaturalBuildingDal();
LogicalBuildingDal logicalBuildingDal = new LogicalBuildingDal();
FloorDal floorDal = new FloorDal();
HouseholdDal householdDal = new HouseholdDal();
ObligeeDal obligeeDal = new ObligeeDal();
MortgageDal mortgageDal = new MortgageDal();
SequestrationDal sequestrationDal = new SequestrationDal();
Task task = new Task(() =>
{
try
{
book.Project = Project;
book.TaskMessage = taskMessage;
book.NaturalBuildings = naturalBuildingDal.GetListBy(t => t.ProjectID == Project.ID);
book.LogicalBuildings = logicalBuildingDal.GetListBy(t => t.ProjectID == Project.ID);
book.Floors = floorDal.GetListBy(t => t.ProjectID == Project.ID);
book.Households = householdDal.GetListBy(t => t.ProjectID == Project.ID);
book.Obligees = obligeeDal.GetListBy(t => t.ProjectID == Project.ID);
if ("2".Equals(Project.OwnershipType))
{
book.Mortgages = mortgageDal.GetListBy(t => t.ProjectID == Project.ID);
book.Sequestrations = sequestrationDal.GetListBy(t => t.ProjectID == Project.ID);
}
book.Open(TemplateFileName);
book.Write();
//book.SaveAsExcel(SaveFileName);
}
catch (Exception ex)
{
ErrorMsg.Add(ex.Message);
}
ErrorMsg.AddRange(book.ErrorMsg);
});
task.Start();
task.ContinueWith(t =>
{
ThreadPool.QueueUserWorkItem(delegate
{
SynchronizationContext.SetSynchronizationContext(new
System.Windows.Threading.DispatcherSynchronizationContext(System.Windows.Application.Current.Dispatcher));
SynchronizationContext.Current.Post(pl =>
{
foreach (var error in ErrorMsg)
{
taskMessage.DetailMessages.Add(error);
}
if (ErrorMsg != null && ErrorMsg.Count > 0)
{
taskMessage.DetailMessages.Add("导出失败");
}
else
{
string bufferPath = System.AppDomain.CurrentDomain.BaseDirectory + @"Buffer\" + Path.GetFileName(SaveFileName);
try
{
book.SaveAsExcel(bufferPath);
//// 压缩成报盘
//ZipHelper zipHelper = new ZipHelper();
//zipHelper.ZipFile(SaveFileName.Replace(".bpf", ".xls"), SaveFileName, 5, 500);
//// 删除excel
//File.Delete(SaveFileName.Replace(".bpf", ".xls"));
if (Path.GetExtension(bufferPath) == ".xls")
{
File.Copy(bufferPath, SaveFileName, true);
File.Delete(bufferPath);
}
else if (Path.GetExtension(bufferPath) == ".bpf")
{
File.Copy(bufferPath.Replace(".xls", ".bpf"), SaveFileName.Replace(".xls", ".bpf"), true);
File.Delete(bufferPath.Replace(".xls", ".bpf"));
}
taskMessage.Progress = 100.00;
taskMessage.DetailMessages.Add("导出成功");
}
catch (Exception ex)
{
taskMessage.DetailMessages.Add(ex.Message + ex.StackTrace);
}
}
}, null);
});
});
}
catch (Exception ex)
{
throw ex;
}
}
public Task SendTaskOrchestrationMessageAsync(TaskMessage message)
{
message.OrchestrationInstance.InstanceId.EnsureValidInstanceId();
return(this.orchestrationProvider.AppendMessageAsync(new TaskMessageItem(message)));
}
/// <inheritdoc />
public async Task CompleteTaskOrchestrationWorkItemAsync(
TaskOrchestrationWorkItem workItem,
OrchestrationRuntimeState newOrchestrationRuntimeState,
IList <TaskMessage> outboundMessages,
IList <TaskMessage> orchestratorMessages,
IList <TaskMessage> timerMessages,
TaskMessage continuedAsNewMessage,
OrchestrationState orchestrationState)
{
if (this.partitionOrchestrationManager == null || this.redisConnection == null)
{
await StartAsync();
}
string orchestrationId = workItem.InstanceId;
RedisTransactionBuilder transaction = this.partitionOrchestrationManager.CreateExistingOrchestrationTransaction(orchestrationId);
List <string> events = newOrchestrationRuntimeState.Events.Select(histEvent => histEvent as TaskCompletedEvent)
.Where(taskCompletedEvent => taskCompletedEvent != null)
.OrderBy(task => task.TaskScheduledId)
.Select(TaskCompletedEvent => $"{{\"id\": {TaskCompletedEvent.TaskScheduledId}, \"Result\": {TaskCompletedEvent.Result}}}")
.ToList();
string logMessage = "Current events processed: " + string.Join(",", events);
await this.logger.LogAsync(logMessage);
transaction.SetOrchestrationRuntimeState(orchestrationId, newOrchestrationRuntimeState);
foreach (TaskMessage outboundMessage in outboundMessages)
{
transaction.SendActivityMessage(outboundMessage);
}
foreach (TaskMessage message in orchestratorMessages)
{
transaction.SendControlQueueMessage(message);
}
if (continuedAsNewMessage != null)
{
transaction.SendControlQueueMessage(continuedAsNewMessage);
}
// TODO send timer messages in transaction
transaction.AddOrchestrationStateToHistory(orchestrationId: orchestrationId,
state: orchestrationState);
transaction.RemoveItemsFromOrchestrationQueue(orchestrationId, workItem.NewMessages.Count);
bool transactionSucceeded = await transaction.CommitTransactionAsync();
if (transactionSucceeded)
{
logMessage = $"Succeeded in transaction of finishing task orchestration item: execution id={workItem.OrchestrationRuntimeState.OrchestrationInstance.ExecutionId}, numMessagesProcessed: {workItem.NewMessages.Count}, numOutBoundMessages: {outboundMessages.Count}, numOrchMessages: {orchestratorMessages.Count}";
}
else
{
logMessage = $"Failed in transaction of finishing task orchestration item: execution id={workItem.OrchestrationRuntimeState.OrchestrationInstance.ExecutionId}, numMessagesProcessed: {workItem.NewMessages.Count}, numOutBoundMessages: {outboundMessages.Count}, numOrchMessages: {orchestratorMessages.Count}";
}
await this.logger.LogAsync(logMessage);
}
/// <summary>
/// Logs that an orchestration work item message is being processed.
/// </summary>
/// <param name="workItem">The orchestration work item.</param>
/// <param name="message">The message being processed.</param>
internal void ProcessingOrchestrationMessage(TaskOrchestrationWorkItem workItem, TaskMessage message)
{
if (this.IsStructuredLoggingEnabled)
{
this.WriteStructuredLog(new LogEvents.ProcessingOrchestrationMessage(workItem, message));
}
}
/// <inheritdoc/>
public Task CompleteTaskActivityWorkItemAsync(TaskActivityWorkItem workItem, TaskMessage responseMessage)
{
return(this.GetOrchestrationService().CompleteTaskActivityWorkItemAsync(workItem, responseMessage));
}
/// <summary>
/// Logs that a work item message is being dropped and includes a reason.
/// </summary>
/// <param name="workItem">The work item that this message belonged to.</param>
/// <param name="message">The message being dropped.</param>
/// <param name="reason">The reason for dropping the message.</param>
internal void DroppingOrchestrationMessage(TaskOrchestrationWorkItem workItem, TaskMessage message, string reason)
{
if (this.IsStructuredLoggingEnabled)
{
this.WriteStructuredLog(new LogEvents.DiscardingMessage(workItem, message, reason));
}
}
static IEnumerable <SqlDataRecord> ToOrchestrationMessageParameter(TaskMessage msg)
{
var record = new SqlDataRecord(OrchestrationEventSchema);
yield return(PopulateOrchestrationMessage(msg, record, eventPayloadMap: null));
}
/// <inheritdoc />
public Task SendTaskOrchestrationMessageAsync(TaskMessage message)
{
return(SendTaskOrchestrationMessageBatchAsync(message));
}
public Task CreateTaskOrchestrationAsync(TaskMessage creationMessage)
{
return(this.OrchestrationServiceClient.CreateTaskOrchestrationAsync(creationMessage));
}
public ExecutionHandler(ITaskExecutionHandler taskExecutionHandler, string taskMessageBody, TaskProperties taskProperties)
{
this.taskExecutionHandler = taskExecutionHandler;
this.taskProperties = taskProperties;
taskMessage = new TaskMessage(taskMessageBody, taskProperties);
}
/// <inheritdoc />
public Task CompleteTaskOrchestrationWorkItemAsync(
TaskOrchestrationWorkItem workItem,
OrchestrationRuntimeState newOrchestrationRuntimeState,
IList <TaskMessage> outboundMessages,
IList <TaskMessage> orchestratorMessages,
IList <TaskMessage> workItemTimerMessages,
TaskMessage continuedAsNewMessage,
OrchestrationState state)
{
lock (this._ThisLock) {
byte[] newSessionState;
if (newOrchestrationRuntimeState == null ||
newOrchestrationRuntimeState.ExecutionStartedEvent == null ||
newOrchestrationRuntimeState.OrchestrationStatus != OrchestrationStatus.Running)
{
newSessionState = null;
}
else
{
newSessionState = SerializeOrchestrationRuntimeState(newOrchestrationRuntimeState);
}
this._OrchestratorQueue.CompleteSession(
workItem.InstanceId,
newSessionState,
orchestratorMessages,
continuedAsNewMessage
);
if (outboundMessages != null)
{
foreach (TaskMessage tm in outboundMessages)
{
// TODO : make async (AFFANDAR)
this._WorkerQueue.SendMessageAsync(tm);
}
}
if (workItemTimerMessages != null)
{
lock (this._TimerLock) {
foreach (TaskMessage tm in workItemTimerMessages)
{
var te = tm.Event as TimerFiredEvent;
if (te == null)
{
// TODO : unobserved task exception (AFFANDAR)
throw new InvalidOperationException("Invalid timer message");
}
else
{
this._TimerMessages.Add(tm);
}
}
}
}
if (workItem.OrchestrationRuntimeState != newOrchestrationRuntimeState)
{
var oldState = Utils.BuildOrchestrationState(workItem.OrchestrationRuntimeState);
CommitState(workItem.OrchestrationRuntimeState, oldState).GetAwaiter().GetResult();
}
if (state != null)
{
CommitState(newOrchestrationRuntimeState, state).GetAwaiter().GetResult();
}
}
return(Task.FromResult(0));
}
public Task AddMessageAsync(TaskMessage message, SessionBase sourceSession)
{
return(this.AddMessageAsync(message, sourceSession.Instance, sourceSession));
}
// public int progress_value{get; set;}
// public int progress_value{get; set;}
public void parseData(TaskMessage.Task data)
{
templateID = data.taskId;
param1_value = data.param1_value;
param2_value = data.param2_value;
}
async Task <MessageData> AddMessageAsync(TaskMessage taskMessage, OrchestrationInstance sourceInstance, SessionBase?session)
{
MessageData data;
try
{
// We transfer to a new trace activity ID every time a new outbound queue message is created.
Guid outboundTraceActivityId = Guid.NewGuid();
data = new MessageData(
taskMessage,
outboundTraceActivityId,
this.storageQueue.Name,
session?.GetCurrentEpisode(),
sourceInstance);
data.SequenceNumber = Interlocked.Increment(ref messageSequenceNumber);
// Inject Correlation TraceContext on a queue.
CorrelationTraceClient.Propagate(
() => { data.SerializableTraceContext = GetSerializableTraceContext(taskMessage); });
string rawContent = await this.messageManager.SerializeMessageDataAsync(data);
QueueMessage queueMessage = new QueueMessage(rawContent);
this.settings.Logger.SendingMessage(
outboundTraceActivityId,
this.storageAccountName,
this.settings.TaskHubName,
taskMessage.Event.EventType.ToString(),
Utils.GetTaskEventId(taskMessage.Event),
sourceInstance.InstanceId,
sourceInstance.ExecutionId,
Encoding.UTF8.GetByteCount(rawContent),
data.QueueName /* PartitionId */,
taskMessage.OrchestrationInstance.InstanceId,
taskMessage.OrchestrationInstance.ExecutionId,
data.SequenceNumber,
data.Episode.GetValueOrDefault(-1));
await this.storageQueue.AddMessageAsync(
queueMessage,
GetVisibilityDelay(taskMessage),
session?.TraceActivityId);
// Wake up the queue polling thread
this.backoffHelper.Reset();
}
catch (DurableTaskStorageException e)
{
this.settings.Logger.MessageFailure(
this.storageAccountName,
this.settings.TaskHubName,
string.Empty /* MessageId */,
sourceInstance.InstanceId,
sourceInstance.ExecutionId,
this.storageQueue.Name,
taskMessage.Event.EventType.ToString(),
Utils.GetTaskEventId(taskMessage.Event),
e.ToString());
throw;
}
return(data);
}
public void CancelAsync(TaskMessage taskMessage, TaskLogger taskLogger, CancellationToken cancellationToken)
{
}
public Task CreateTaskOrchestrationAsync(TaskMessage creationMessage, OrchestrationStatus[] dedupeStatuses)
{
return(this.OrchestrationServiceClient.CreateTaskOrchestrationAsync(creationMessage, dedupeStatuses));
}
private void TaskChangedEvent(object sender, TaskMessage task)
{
TaskChangedEventHandler?.Invoke(sender, task);
}
public Task SendTaskOrchestrationMessageAsync(TaskMessage message)
{
return(this.OrchestrationServiceClient.SendTaskOrchestrationMessageAsync(message));
}
private async Task TaskMessageReceived(TaskMessage message)
{
var type = message.Type.ToString();
await hubContext.Clients.All.SendAsync(type, message.Task);
}
public void SaveTaskChangedState(ITask task, TaskMessage message)
{
//��������״̬�����ı�ʱ����״̬
//������������Ѿ�ִ�гɹ��ˣ�ʧ���ˡ�
}
public void Ongo()
{
try
{
TaskInfoDialog = TaskInfoDialogViewModel.getInstance();
String FileName = Path.GetFileName(FullPath);
//TaskInfoDialog.Messages.Add("开始导入：" + FileName);
TaskMessage taskMessage = new TaskMessage();
taskMessage.Title = "导入项目：" + FileName;
taskMessage.Progress = 0.0;
TaskInfoDialog.Messages.Insert(0, taskMessage);
Task task = new Task(() =>
{
ImportRealEstateBook import = new ImportRealEstateBook();
import.FileName = FullPath;
import.Read();
bool canContinue = import.ReadInformation();
if (canContinue)
{
taskMessage.Progress = 50.00;
//var naturalEffective = NaturalEffective(import.ZRZList);
var isNaturalBuildingUnique = IsNaturalBuildingUnique(import.NaturalBuildings);
var isHouseholdUnique = IsHouseholdUnique(import.Households);
if (isNaturalBuildingUnique && isHouseholdUnique)
{
Project project = InitialProject();
ProjectDal projectDal = new ProjectDal();
NaturalBuildingDal naturalBuildingDal = new NaturalBuildingDal();
LogicalBuildingDal logicalBuildingDal = new LogicalBuildingDal();
FloorDal floorDal = new FloorDal();
HouseholdDal householdDal = new HouseholdDal();
ObligeeDal obligeeDal = new ObligeeDal();
try
{
foreach (var naturalBuilding in import.NaturalBuildings)
{
naturalBuilding.ID = Guid.NewGuid();
naturalBuilding.ProjectID = project.ID;
naturalBuilding.UpdateTime = DateTime.Now;
naturalBuildingDal.Add(naturalBuilding);
}
}
catch (Exception ex)
{
ErrorMsg.Add("自然幢数据异常：" + ex.Message);
}
try
{
foreach (var logicalBuilding in import.LogicalBuildings)
{
logicalBuilding.ID = Guid.NewGuid();
logicalBuilding.ProjectID = project.ID;
logicalBuilding.UpdateTime = DateTime.Now;
logicalBuildingDal.Add(logicalBuilding);
}
}
catch (Exception ex)
{
ErrorMsg.Add("逻辑幢数据异常：" + ex.Message);
}
try
{
foreach (var floor in import.Floors)
{
floor.ID = Guid.NewGuid();
floor.ProjectID = project.ID;
floor.UpdateTime = DateTime.Now;
floorDal.Add(floor);
}
}
catch (Exception ex)
{
ErrorMsg.Add("层数据异常：" + ex.Message);
}
try
{
foreach (var household in import.Households)
{
household.ID = Guid.NewGuid();
household.ProjectID = project.ID;
household.UpdateTime = DateTime.Now;
householdDal.Add(household);
}
}
catch (Exception ex)
{
ErrorMsg.Add("户数据异常：" + ex.Message);
}
try
{
foreach (var obligee in import.Obligees)
{
obligee.ID = Guid.NewGuid();
obligee.ProjectID = project.ID;
obligee.UpdateTime = DateTime.Now;
obligeeDal.Add(obligee);
}
}
catch (Exception ex)
{
ErrorMsg.Add("权利人数据异常：" + ex.Message);
}
try
{
projectDal.Add(project);
}
catch (Exception ex)
{
ErrorMsg.Add("项目数据异常：" + ex.Message);
}
}
}
ErrorMsg.AddRange(import.ErrorMsg);
});
task.Start();
task.ContinueWith(t =>
{
ThreadPool.QueueUserWorkItem(delegate
{
SynchronizationContext.SetSynchronizationContext(new
System.Windows.Threading.DispatcherSynchronizationContext(System.Windows.Application.Current.Dispatcher));
SynchronizationContext.Current.Post(pl =>
{
foreach (var error in ErrorMsg)
{
taskMessage.DetailMessages.Add(error);
}
if (ErrorMsg != null && ErrorMsg.Count > 0)
{
taskMessage.DetailMessages.Add("导入失败");
}
else
{
taskMessage.Progress = 100.00;
taskMessage.DetailMessages.Add("导入成功");
// 刷新项目列表
}
}, null);
});
});
}
catch (Exception ex)
{
throw ex;
}
}
