private void BwRunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
{
//Logger.Write("Entering BwRunWorkerCompleted method");
if (e.Cancelled == true)
{
}
else if (e.Error != null)
{
//Logger.Write(string.Format("Exception: {0}", e.Error.Message));
MessageBox.Show(string.Format("Error: {0}", e.Error.Message));
}
else
{
var newWorkItems = (ObservableCollection <WorkItem>)e.Result;
//Logger.Write(string.Format("Work items loaded: {0}", newWorkItems.Count));
foreach (var item in newWorkItems)
{
WorkItems.Add(item);
}
listView.SelectAll();
}
progress.Visibility = Visibility.Collapsed;
// Any pending requests?
if (pendingRequest != string.Empty)
{
QueriesSelectionChanged((string)pendingRequest.Clone());
pendingRequest = string.Empty;
}
}
public DispatcherOperation BeginInvoke(Action action)
{
var operation = new Operation <VoidResult>(WrapVoid(action));
WorkItems.Add(operation); // BeginInvoke is *always* async
return(operation);
}
public int InsertWorkItem(IWorkflowItem entity)
{
return(LockExecute <int>(() =>
{
if (!string.IsNullOrEmpty(entity.Alias) && entity.Alias.IndexOf('.') > 0)
{
entity.Alias = entity.Alias.Substring(entity.Alias.LastIndexOf('.') + 1);
}
if (entity.ItemId >= 10000)
{
WorkItemsRead.Add(entity);
return Dao.Get().Insert <WorkflowItemRead>(entity);
}
else
{
WorkflowEventManager.RaiseWorkItemEvent(EventStep.Before, ItemActionType.Insert, this, entity);
WorkItems.Add(entity);
int result = Dao.Get().Insert <WorkflowItem>(entity);
if (result > 0)
{
WorkflowEventManager.RaiseWorkItemEvent(EventStep.After, ItemActionType.Insert, this, entity);
}
return result;
}
}));
}
public DispatcherOperation <T> BeginInvoke <T>(Func <T> action)
{
var operation = new Operation <T>(action);
WorkItems.Add(operation); // BeginInvoke is *always* async
return(operation);
}
private void StartOrInvokeInline(IOperation operation)
{
if (Thread.CurrentThread.ManagedThreadId == thread.ManagedThreadId)
{
operation.Invoke(Logger);
}
else
{
WorkItems.Add(operation);
}
}
private void RefreshSelectedDefinitionWorkItems()
{
this.Logger().Trace("RefreshSelectedDefinitionWorkItems");
if (SelectedWorkItemQueryDefinition == null)
{
return;
}
WorkItemCollection workItemCollection;
if (teamPilgrimServiceModelProvider.TryGetQueryDefinitionWorkItemCollection(out workItemCollection,
_projectCollectionServiceModel.TfsTeamProjectCollection,
SelectedWorkItemQueryDefinition.QueryDefinition,
SelectedWorkItemQueryDefinition.Project.Name))
{
var currentWorkItems = workItemCollection.Cast <WorkItem>().ToArray();
var modelIntersection = WorkItems == null
? new WorkItemModel[0]
: WorkItems
.Join(currentWorkItems, model => model.WorkItem.Id,
workItem => workItem.Id,
(model, change) => model)
.ToArray();
var modelsToRemove = WorkItems.Where(model => !modelIntersection.Contains(model)).ToArray();
var selectedWorkItemCheckinActionEnum = TeamPilgrimPackage.TeamPilgrimSettings.SelectedWorkItemCheckinAction;
var modelsToAdd = currentWorkItems
.Where(workItem => !modelIntersection.Select(workItemModel => workItemModel.WorkItem.Id).Contains(workItem.Id))
.Select(workItem => new WorkItemModel(workItem)
{
WorkItemCheckinAction = selectedWorkItemCheckinActionEnum
}).ToArray();
_backgroundFunctionPreventDataUpdate = true;
foreach (var modelToAdd in modelsToAdd)
{
WorkItems.Add(modelToAdd);
}
foreach (var modelToRemove in modelsToRemove)
{
WorkItems.Remove(modelToRemove);
}
_backgroundFunctionPreventDataUpdate = false;
WorkItemsOnCollectionChanged();
}
}
private void WorkItemChangedEventHandler(WorkItem changedItem)
{
if (addWorkItem)
{
WorkItems.Add(changedItem);
addWorkItem = false;
}
else
{
SelectedWorkItem.Update(changedItem);
RaisePropertyChanged(nameof(SelectedWorkItem));
}
RaisePropertiesChanged();
}
private void UpdateWorkItemCollection(WorkItemViewModel viewModel, bool updateObservables)
{
int index = WorkItems.FindIndex(w => w.Id == viewModel.Id);
if (index > -1)
{
WorkItems[index] = viewModel.WorkItem;
}
else
{
WorkItems.Add(viewModel.WorkItem);
}
if (updateObservables)
{
SetObservableWorkItems();
}
}
public int UpdateWorkItem(IWorkflowItem entity)
{
return(LockExecute <int>(() =>
{
if (entity.ItemId >= 10000)
{
WorkItemsRead.Remove(entity);
WorkItemsRead.Add(entity);
return Dao.Get().Update <WorkflowItemRead>(entity);
}
else
{
WorkItems.Remove(entity);
WorkItems.Add(entity);
return Dao.Get().Update <WorkflowItem>(entity);
}
}));
}
public void ResetWorkItemTimesForMonthView()
{
WorkItems.Clear();
TempDragItems.ForEach(wi =>
{
WorkScheduleItem temp = new WorkScheduleItem
{
Id = wi.Id,
Color = wi.Color,
Department = wi.Department,
From = wi.From,
To = wi.From + (wi.OriginalEndDate - wi.OriginalStartDate),
ItemName = wi.ItemName,
FromTime = wi.FromTime,
ToTime = wi.ToTime,
Description = wi.Description,
IsAllDay = wi.IsAllDay,
EstimatedBoardFeet = wi.EstimatedBoardFeet
};
WorkItems.Add(temp);
});
}
private async void Refresh(object sender, RoutedEventArgs e)
{
foreach (var item in WorkItems)
{
item.PropertyChanged -= new PropertyChangedEventHandler(OnWorkItemCostingPropertyChanged);
}
WorkItems.Clear();
CompletedWorkItems.Clear();
var result = _lastResult = await Logic.GetWorkItemsByQuery();
if (result != null)
{
// Combine both source lists into a single WorkItems list
foreach (var item in result.WorkItems)
{
WorkItems.Add(item);
item.PropertyChanged += new PropertyChangedEventHandler(OnWorkItemCostingPropertyChanged);
}
foreach (var item in result.CompletedWorkItems)
{
WorkItems.Add(item);
item.PropertyChanged += new PropertyChangedEventHandler(OnWorkItemCostingPropertyChanged);
}
AuditIssues.Clear();
foreach (var issue in result.AuditIssues)
{
AuditIssues.Add(issue);
}
}
UpdateCosts();
Regroup();
UpdateDirty();
}
public int UpdateWorkItem(IList <IWorkflowItem> entities)
{
return(LockExecute <int>(() =>
{
int effectCount = 0;
foreach (var entity in entities)
{
if (entity.ItemId >= 10000)
{
WorkItemsRead.Remove(entity);
WorkItemsRead.Add(entity);
effectCount += Dao.Get().Update <WorkflowItemRead>(entity);
}
else
{
WorkItems.Remove(entity);
WorkItems.Add(entity);
effectCount += Dao.Get().Update <WorkflowItem>(entity);
}
}
return effectCount;
}));
}
/// <summary>
/// Creates a new <see cref="IWorkItem"/> object in this document.
/// </summary>
/// <param name="configuration">The configuration of the work item to create</param>
/// <returns>The new <see cref="IWorkItem"/> object or null if the adapter failed to create work item.</returns>
public IWorkItem CreateNewWorkItem(IConfigurationItem configuration)
{
Guard.ThrowOnArgumentNull(configuration, "configuration");
SyncServiceTrace.D(Resources.CreateWorkItemBasedOnTemplate + configuration.RelatedTemplateFile);
SyncServiceTrace.D("Assembly is " + Assembly.GetExecutingAssembly().Location);
if (!File.Exists(configuration.RelatedTemplateFile))
{
SyncServiceTrace.E(Resources.LogService_Export_NoFile);
return(null);
}
// Check if cursor is not in table, add new paragraph
var selection = Document.ActiveWindow.Selection;
if (selection == null)
{
SyncServiceTrace.E(Resources.SelectionNotExists);
return(null);
}
if (WordSyncHelper.IsCursorBehindTable(selection))
{
selection.TypeParagraph();
}
if (WordSyncHelper.IsCursorInTable(selection))
{
return(null);
}
// insert template. Selection is collapsed to end when inserting,
// so note old start to get range where file is inserted
var fullPath = Path.GetFullPath(configuration.RelatedTemplateFile);
SyncServiceTrace.D(Resources.FullPathOfTemplateFile + fullPath);
var oldStart = selection.Start;
if (!File.Exists(fullPath))
{
SyncServiceTrace.E(Resources.LogService_Export_NoFile);
return(null);
}
selection.InsertFile(fullPath, ConfirmConversions: false);
Range tableRange = Document.Range(oldStart, selection.End);
Table table = tableRange.Tables.Cast <Table>().FirstOrDefault();
if (table == null)
{
SyncServiceTrace.E(Resources.LogService_Export_NoTable);
}
else
{
// Add table marker if none is defined
var tableRange2 = WordSyncHelper.GetCellRange(table, configuration.ReqTableCellRow, configuration.ReqTableCellCol);
if (tableRange2 != null)
{
if (tableRange2.Text.Replace("\r\a", string.Empty).Length == 0)
{
tableRange2.Text = configuration.WorkItemType + "\r\a";
}
}
var newItem = new WordTableWorkItem(table, configuration.WorkItemType, Configuration, configuration);
WorkItems.Add(newItem);
return(newItem);
}
return(null);
}
private void RefreshSelectedDefinitionWorkItems()
{
this.Logger().Trace("RefreshSelectedDefinitionWorkItems");
if (SelectedWorkItemQueryDefinition == null)
{
return;
}
WorkItemCollection workItemCollection = null;
var successResult = teamPilgrimServiceModelProvider.TryGetQueryDefinitionWorkItemCollection(out workItemCollection, _projectCollectionServiceModel.TfsTeamProjectCollection, SelectedWorkItemQueryDefinition.QueryDefinition, SelectedWorkItemQueryDefinition.Project.Name);
if (!successResult)
{
return;
}
Debug.Assert(workItemCollection != null, "workItemCollection != null");
var currentWorkItems = workItemCollection.Cast <WorkItem>().ToArray();
var intersections = WorkItems
.Join(currentWorkItems, model => model.WorkItem.Id, workItem => workItem.Id,
(model, workitem) => new { model, workitem })
.ToArray();
var intersectedModels =
intersections
.Select(arg => arg.model)
.ToArray();
var modelsToRemove = WorkItems.Where(model => !intersectedModels.Contains(model)).ToArray();
var selectedWorkItemCheckinActionEnum =
TeamPilgrimPackage.TeamPilgrimSettings.SelectedWorkItemCheckinAction;
var modelsToAdd = currentWorkItems
.Where(
workItem =>
!intersectedModels.Select(workItemModel => workItemModel.WorkItem.Id).Contains(workItem.Id))
.Select(
workItem =>
new WorkItemModel(workItem)
{
WorkItemCheckinAction = selectedWorkItemCheckinActionEnum
})
.ToArray();
_backgroundFunctionPreventDataUpdate = true;
foreach (var intersectedModel in intersections)
{
intersectedModel.model.WorkItem = intersectedModel.workitem;
}
foreach (var modelToAdd in modelsToAdd)
{
WorkItems.Add(modelToAdd);
}
foreach (var modelToRemove in modelsToRemove)
{
WorkItems.Remove(modelToRemove);
}
_backgroundFunctionPreventDataUpdate = false;
WorkItemsOnCollectionChanged();
}
/// <summary>
/// Add a workItem
/// </summary>
/// <param name="workItem">the workItem</param>
public void AddWorkItem(WorkItem workItem)
{
WorkItems.Add(workItem);
}
async private void listWorkItemQueues_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
try
{
var wiq = listWorkItemQueues.SelectedItem as OpenRPA.WorkitemQueue;
try
{
if (wiq != null && RobotInstance.instance.Workflows != null)
{
foreach (var wf in RobotInstance.instance.Workflows)
{
if (wf._id == wiq.workflowid)
{
wiq.workflowid = wf.ProjectAndName;
}
if (wf.RelativeFilename == wiq.workflowid)
{
wiq.workflowid = wf.ProjectAndName;
}
}
}
foreach (OpenRPA.WorkitemQueue d in WorkItemQueues.ToList())
{
if (d.isDirty)
{
await d.Save();
}
}
}
catch (Exception ex)
{
Log.Error(ex.ToString());
}
if (wiq == null)
{
return;
}
if (global.webSocketClient == null || !global.webSocketClient.isConnected)
{
//RobotInstance.instance.Workitems.Clear();
//RobotInstance.instance.Workitems.UpdateCollectionById(RobotInstance.instance.dbWorkitems.FindAll().OrderBy(x => x.name));
// _WorkItems.Refresh();
if (WorkItems != null)
{
WorkItems.Clear();
}
_WorkItems = new FilteredObservableCollection <IWorkitem>(RobotInstance.instance.Workitems, wifilter);
return;
}
var server_workitems = await global.webSocketClient.Query <Workitem>("workitems", "{\"_type\": 'workitem',\"wiqid\": '" + wiq._id + "'}", "{\"name\": 1,\"state\": 1,\"_modified\": 1}", top : 100);
if (WorkItems != null)
{
WorkItems.Clear();
}
foreach (var workitem in server_workitems)
{
WorkItems.Add(workitem);
}
}
catch (Exception ex)
{
Log.Error(ex.ToString());
}
}
