void ISharePointDataProvider.UpdateLateCompleteReasonWithCompleteFlag(IEnumerable<TaskItem> tasks)
{
string url = this.ConstructUrlParams(IIsAction.UPDATELATEINCOMPLETEREASON, null, tasks.Count());
EndpointAddress addr = new EndpointAddress(url);
BasicHttpBinding bnd = new BasicHttpBinding();
bnd.MaxBufferSize = InitParams.Current.MaxBufferSize;
bnd.MaxReceivedMessageSize = bnd.MaxBufferSize;
BCheckLists.ListsSoapClient changeTaskUsersClient = new BCheck.Data.BCheckLists.ListsSoapClient(bnd, addr);
changeTaskUsersClient.UpdateListItemsCompleted +=
new EventHandler<BCheck.Data.BCheckLists.UpdateListItemsCompletedEventArgs>(assignedTasksUpdateClient_UpdateListItemsCompleted);
string xmlUdpates;
xmlUdpates = CamlHelper.QueryUpdateLateIncompleteReasonWithCompleteStatus(tasks);
XElement updateQuery = XElement.Parse(xmlUdpates);
changeTaskUsersClient.UpdateListItemsAsync(InitParams.Current.ListName, updateQuery);
}
public void FetchAlertsForOverLoadCondition()
{
string url = this.ConstructUrlParams(IIsAction.ALERTS, null, 0);
EndpointAddress addr = new EndpointAddress(url);//URL params injected, Mar 29
BasicHttpBinding bnd = new BasicHttpBinding();
bnd.MaxBufferSize = InitParams.Current.MaxBufferSize; ;
bnd.MaxReceivedMessageSize = bnd.MaxBufferSize;
BCheckLists.ListsSoapClient taskAlertsClientAssignedTasks = new BCheck.Data.BCheckLists.ListsSoapClient(bnd, addr);
taskAlertsClientAssignedTasks.GetListItemsCompleted += new EventHandler<BCheck.Data.BCheckLists.GetListItemsCompletedEventArgs>(taskAlertsClientAssignedTasks_GetListItemsCompleted);
string queryXml = CamlHelper.QueryMyTasksDueToday(); ;
XElement query = XElement.Parse(queryXml);
string viewFieldsXml = CamlHelper.VIEWFIELDS_ASSIGNEDTASKSALERTS;
XElement viewFields = XElement.Parse(viewFieldsXml);
string queryOptionsXml = "<QueryOptions><DateInUtc>TRUE</DateInUtc></QueryOptions>";
XElement queryOptions = XElement.Parse(queryOptionsXml);
taskAlertsClientAssignedTasks.GetListItemsAsync(InitParams.Current.ListName, "", query, viewFields, "150", queryOptions, null);
//fetch maanged tasks alerts
BCheckLists.ListsSoapClient taskAlertsClientManagedTasks = new BCheck.Data.BCheckLists.ListsSoapClient(bnd, addr);
taskAlertsClientManagedTasks.GetListItemsCompleted += new EventHandler<BCheck.Data.BCheckLists.GetListItemsCompletedEventArgs>(taskAlertsClientManagedTasks_GetListItemsCompleted);
viewFieldsXml = CamlHelper.VIEWFIELDS_MANAGEDTASKSALERTS;
queryXml = CamlHelper.QueryManagedTaskAlertsDueToday();
query = XElement.Parse(queryXml);
taskAlertsClientManagedTasks.GetListItemsAsync(InitParams.Current.ListName, "", query, viewFields, "150", queryOptions, null);
}
/// <summary>
/// Updates the Comments for the specified Tasks
/// April 21
/// </summary>
/// <param name="tasks"></param>
public void UpdateComments(IEnumerable<TaskItem> tasks)
{
string url = this.ConstructUrlParams(IIsAction.UPDATECOMMENTS, null, tasks.Count());
EndpointAddress addr = new EndpointAddress(url);//URL params injected, Mar 29
BasicHttpBinding bnd = new BasicHttpBinding();
bnd.MaxBufferSize = InitParams.Current.MaxBufferSize;
bnd.MaxReceivedMessageSize = bnd.MaxBufferSize;
BCheckLists.ListsSoapClient changeTaskUsersClient = new BCheck.Data.BCheckLists.ListsSoapClient(bnd, addr);
changeTaskUsersClient.UpdateListItemsCompleted +=
new EventHandler<BCheck.Data.BCheckLists.UpdateListItemsCompletedEventArgs>(assignedTasksUpdateClient_UpdateListItemsCompleted);
string xmlUdpates;
xmlUdpates = CamlHelper.QueryUpdateComments(tasks);
XElement updateQuery = XElement.Parse(xmlUdpates);
changeTaskUsersClient.UpdateListItemsAsync(InitParams.Current.ListName, updateQuery);
}
void ISharePointDataProvider.FetchBusinessAreas()
{
string url = ViewModel.OrgStructureUrl;
EndpointAddress addr = new EndpointAddress(url);
BasicHttpBinding bnd = new BasicHttpBinding();
bnd.ReceiveTimeout = TimeSpan.FromMinutes(6);
bnd.SendTimeout = TimeSpan.FromMinutes(6);
bnd.OpenTimeout = TimeSpan.FromMinutes(6);
bnd.CloseTimeout = TimeSpan.FromMinutes(6);
bnd.MaxBufferSize = InitParams.Current.MaxBufferSize;
bnd.MaxReceivedMessageSize = bnd.MaxBufferSize;
string queryXml = CamlHelper.QueryBusinessAreasFromList();
string viewFieldsXml = CamlHelper.VIEWFIELDS_BUSINESSAREAS;
BCheckLists.ListsSoapClient listClient = new BCheck.Data.BCheckLists.ListsSoapClient(bnd, addr);
listClient.GetListItemsCompleted += new EventHandler<BCheck.Data.BCheckLists.GetListItemsCompletedEventArgs>(listClient_GetListItemsOrgCompleted);
XElement query = XElement.Parse(queryXml);
XElement viewFields = XElement.Parse(viewFieldsXml);
string queryOptionsXml = "<QueryOptions><DateInUtc>FALSE</DateInUtc><IncludeAttachmentUrls>FALSE</IncludeAttachmentUrls><IncludeMandatoryColumns>FALSE</IncludeMandatoryColumns></QueryOptions>";
XElement queryOptions = XElement.Parse(queryOptionsXml);
string maxrows = "1000";
listClient.GetListItemsAsync(InitParams.Current.OrgListName, "", query, viewFields, maxrows, queryOptions, null);
}
/// <summary>
/// Callback handler when a Task has been updated.
/// Rationale: needed a place holder from where another query could be issued to fetch the updated Task item.
/// Important to re-issue web service to fetch the Task, rather than rely on the XML fragment returned after UpdateListItem
/// because of UTC options
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
void UpdateSingleTaskItemCompletedHandler(
object sender,
BCheck.Data.BCheckLists.UpdateListItemsCompletedEventArgs e)
{
if ((e.Cancelled) || (e.Error != null))
{
TaskItemUpdateCompleteEventArgs args = new TaskItemUpdateCompleteEventArgs(e.Error, e.Cancelled, null);
Deployment.Current.Dispatcher.BeginInvoke(delegate()
{
TaskUpdateCompleteEvent(this, args);
});
return;
}
/*
* loop throuhg the returned XML
* find out if there were any errors
* Issue another web service query to fetch complete data for the TaskItem that has got updated
*/
XElement xresults = e.Result;
XNamespace nsRow = "#RowsetSchema";
XNamespace nsResults = "http://schemas.microsoft.com/sharepoint/soap/";
var query = from x in xresults.Descendants()
where x.Name == nsResults + "Result"
select x;
List<int> updatedtaskIDs = new List<int>();
List<string> errorcodes = new List<string>();
List<int> erroredtaskIDs = new List<int>();
foreach (XElement result in query)
{
XElement error = result.Element(nsResults + "ErrorCode");
string errorCode = error.Value;
if (errorCode.Equals("0x00000000"))
{
XElement row = result.Element(nsRow + "row");
int taskid = (int?)row.Attribute("ows_ID") ?? 0;
updatedtaskIDs.Add(taskid);
}
else
{
//get the ErrorText element
XElement errorTxt = result.Element(nsResults + "ErrorText");
if (errorTxt != null) errorcodes.Add(errorTxt.Value);
}
}
IEnumerable<TaskItem> updatedTasks = XmlToTaskObjects(xresults);
foreach (TaskItem t in updatedTasks)
{
t.SetInitializationComplete();
}
Exception errors;
if (errorcodes.Count != 0)
{
errors = new Exception(string.Format("Errors while updating {0} Task items, erorcode:{1}", errorcodes.Count, errorcodes[0]));
TaskItemUpdateCompleteEventArgs evargs = new TaskItemUpdateCompleteEventArgs(errors, false, null);
evargs.Errors = errorcodes;
foreach (TaskItem t in updatedTasks) { evargs.UpdatedTasks.Add(t); }
Deployment.Current.Dispatcher.BeginInvoke(delegate()
{
TaskUpdateCompleteEvent(this, evargs);
});
return;
}
if (updatedTasks.Count() == 0)
{
TaskItemUpdateCompleteEventArgs evargs = new TaskItemUpdateCompleteEventArgs(null, false, null);
evargs.Errors = new List<string>();
Deployment.Current.Dispatcher.BeginInvoke(delegate()
{
TaskUpdateCompleteEvent(this, evargs);
});
return;
}
//re-fetch the TaskItem data once more
string url = this.ConstructUrlParams(IIsAction.QUERYSINGLE, null, 0);
TaskItem firstTask = updatedTasks.First();
EndpointAddress addr = new EndpointAddress(url);//URL params injected, Mar 29
BasicHttpBinding bnd = new BasicHttpBinding();
bnd.MaxBufferSize = InitParams.Current.MaxBufferSize;
bnd.MaxReceivedMessageSize = bnd.MaxBufferSize;
BCheckLists.ListsSoapClient listClient = new BCheck.Data.BCheckLists.ListsSoapClient(bnd, addr);
string queryOptionsXml = "<QueryOptions><DateInUtc>TRUE</DateInUtc><IncludeAttachmentUrls>TRUE</IncludeAttachmentUrls><IncludeMandatoryColumns>FALSE</IncludeMandatoryColumns></QueryOptions>";
XElement queryOptions = XElement.Parse(queryOptionsXml);
string maxrows = BCheck.Data.InitParams.Current.MaxCamlRows.ToString();
string queryXml = "";
queryXml = CamlHelper.QueryFetchTaskWithID(firstTask.ID);
XElement queryXe = XElement.Parse(queryXml);
string viewFieldsXml = "";
viewFieldsXml = CamlHelper.VIEWFIELDS_MYTASKSVERBOSE;
XElement viewFields = XElement.Parse(viewFieldsXml);
//listClient.GetListItemsCompleted +=
// delegate(object sender, BCheck.Data.BCheckLists.GetListItemsCompletedEventArgs e)
// {
// };
listClient.GetListItemsCompleted += new EventHandler<BCheck.Data.BCheckLists.GetListItemsCompletedEventArgs>(listClient_GetListItemsCompleted);
//this.FetchTasksCompleteEvent +=
// delegate(object sender1, TaskFetchCompletedEventArgs args1)
// {
// TaskItemUpdateCompleteEventArgs evargs = new TaskItemUpdateCompleteEventArgs(null, false, null);
// evargs.UpdatedTasks = args1.Tasks;
// Deployment.Current.Dispatcher.BeginInvoke(delegate()
// {
// TaskUpdateCompleteEvent(this, evargs);
// });
// };
//objectstate=QUERYSINGLE, so that the event handler knows to invoke the right call back
TaskUpdateCompleteEvent(this, null);
//listClient.GetListItemsAsync(
// InitParams.Current.ListName, "", queryXe, viewFields,
// maxrows, queryOptions, null, IIsAction.QUERYSINGLE);
}
/// <summary>
/// Method for updating the ownership of specified Tasks
/// </summary>
/// <param name="tasks"></param>
/// <param name="assignToSelf">If set to True then the current user is made the owner</param>
public void UpdateTasksOwnership(IEnumerable<TaskItem> tasks, bool assignToSelf)
{
string url = this.ConstructUrlParams(IIsAction.UPDATEOWNERSHIP, null, tasks.Count());
var addr = new EndpointAddress(url);//URL params injected, Mar 29
var bnd = new BasicHttpBinding { MaxBufferSize = InitParams.Current.MaxBufferSize };
bnd.MaxReceivedMessageSize = bnd.MaxBufferSize;
var changeTaskUsersClient = new BCheck.Data.BCheckLists.ListsSoapClient(bnd, addr);
//if more than 1 Task is being updated then treat it like a bulk update, otherwise single Task update , i.e. no refresh of current view
if (tasks.Count() > 1)
{
changeTaskUsersClient.UpdateListItemsCompleted +=
assignedTasksUpdateClient_UpdateListItemsCompleted;
}
else
{
changeTaskUsersClient.UpdateListItemsCompleted +=
UpdateSingleTaskItemCompletedHandler;
}
string xmlUdpates = CamlHelper.QueryUpdateTaskOwnership(tasks, assignToSelf);
XElement updateQuery = XElement.Parse(xmlUdpates);
changeTaskUsersClient.UpdateListItemsAsync(InitParams.Current.ListName, updateQuery);
}
public void UpdateTaskItem(TaskItem t)
{
string url = this.ConstructUrlParams(IIsAction.UPDATESINGLE, null, 0);
EndpointAddress addr = new EndpointAddress(url);//URL params injected, Mar 29
BasicHttpBinding bnd = new BasicHttpBinding();
bnd.MaxBufferSize = InitParams.Current.MaxBufferSize;
bnd.MaxReceivedMessageSize = bnd.MaxBufferSize;
BCheckLists.ListsSoapClient taskeditClient = new BCheck.Data.BCheckLists.ListsSoapClient(bnd, addr);
taskeditClient.UpdateListItemsCompleted +=
new EventHandler<BCheck.Data.BCheckLists.UpdateListItemsCompletedEventArgs>(UpdateSingleTaskItemCompletedHandler);
string xmlUdpates = "";
int role = 0x0; //use bit mask. 0x1=assigned, 0x2=manager
if (TaskItem.IsUserInAssignedTo(ViewModel.Current.WssUserId, t)) role = role | 0x1;//sep 20
if (TaskItem.IsUserManager(ViewModel.Current.WssUserId, t)) role = role | 0x2;//sep 20
if (role == 0x1)
{
ViewModel.Current.Status.AddToLog(string.Format("Updating Task item '{0}' as an assigned user", t.TaskName), false);
xmlUdpates = CamlHelper.QueryUpdateTaskEdit(t, View.vwAssignedTasks, TaskItem.IsUserInAssignedTo(ViewModel.Current.WssUserId, t), TaskItem.IsUserManager(ViewModel.Current.WssUserId, t));
}
if ((role & 0x2) > 0)
{
ViewModel.Current.Status.AddToLog(string.Format("Updating Task item '{0}' as a manager user", t.TaskName), false);
xmlUdpates = CamlHelper.QueryUpdateTaskEdit(t, View.vwManagedTasks, TaskItem.IsUserInAssignedTo(ViewModel.Current.WssUserId, t), TaskItem.IsUserManager(ViewModel.Current.WssUserId, t));
}
if (role == 0x0)
{
throw new InvalidOperationException(string.Format("The Task '{0}' cannot be udpated because the user is neither an assigned to or a manager", t.TaskName));
}
XElement updateQuery = XElement.Parse(xmlUdpates);
taskeditClient.UpdateListItemsAsync(InitParams.Current.ListName, updateQuery);
}
public virtual void FetchTasks(View vw, SearchParams paramSearch)
{
string queryXml = "";
string viewFieldsXml = "";
#region Old CamlCreator
//switch (vw)
//{
// case View.vwOpsChecklistLoad:
// //queryXml = CamlHelper.QueryMyTasksOnLoad();
// //viewFieldsXml = CamlHelper.VIEWFIELDS_MYTASKSVERBOSE;
// queryXml = CamlHelper.QueryMyTasksDueToday();
// viewFieldsXml = CamlHelper.VIEWFIELDS_MYTASKSVERBOSE;
// break;
// case View.vwDueToday | View.vwAssignedTasks:
// queryXml = CamlHelper.QueryMyTasksDueToday();
// viewFieldsXml = CamlHelper.VIEWFIELDS_MYTASKSVERBOSE;
// break;
// case View.vwOverDue | View.vwAssignedTasks:
// queryXml = CamlHelper.QueryMyTasksOverdue();
// viewFieldsXml = CamlHelper.VIEWFIELDS_MYTASKSVERBOSE;
// break;
// case View.vwCompletedApproved | View.vwAssignedTasks:
// queryXml = CamlHelper.QueryMyTasksApprovedComplete();
// viewFieldsXml = CamlHelper.VIEWFIELDS_MYTASKSVERBOSE;
// break;
// case View.vwDueToday | View.vwManagedTasks:
// queryXml = CamlHelper.QueryManagedTasksDueToday();
// viewFieldsXml = CamlHelper.VIEWFIELDS_MYTASKSVERBOSE;
// break;
// case View.vwOverDue | View.vwManagedTasks:
// queryXml = CamlHelper.QueryManagedTasksIncomplete();
// viewFieldsXml = CamlHelper.VIEWFIELDS_MYTASKSVERBOSE;
// break;
// case View.vwCompletedApproved | View.vwManagedTasks:
// queryXml = CamlHelper.QueryManagedTasksCompleted();
// viewFieldsXml = CamlHelper.VIEWFIELDS_MYTASKSVERBOSE;
// break;
// case View.vwCustomSearch:
// queryXml = CamlHelper.QueryCustomSearch(paramSearch);
// viewFieldsXml = CamlHelper.VIEWFIELDS_MYTASKSVERBOSE;
// break;
// case View.vwArchiveView:
// // If its the custom search do nothing, we just use the different service to query
// break;
// case View.vwAssignedTasks | View.vwNotApplicable:
// queryXml = CamlHelper.QueryAssignedTasksNotApplicable();
// viewFieldsXml = CamlHelper.VIEWFIELDS_MYTASKSVERBOSE;
// break;
// case View.vwManagedTasks | View.vwNotApplicable:
// queryXml = CamlHelper.QueryManagedTasksNotApplicable();
// viewFieldsXml = CamlHelper.VIEWFIELDS_MYTASKSVERBOSE;
// break;
// default:
// queryXml = "";
// throw new NotImplementedException("this view has not been implemented:" + vw.ToString());
// //break;
//}
//queryXml = queryXml.Replace("&", "&");
#endregion
UserTasks taskids = MasterLookupService.Current.GetUserTaskIDs();
if (vw == View.vwArchiveView || vw == View.vwCustomSearch)
{
//int hoursOffset = -12;
//EndpointAddress addr = new EndpointAddress(ViewModel.OMDQueryAsmxUrl);
//BasicHttpBinding bnd = new BasicHttpBinding();
//bnd.ReceiveTimeout = TimeSpan.FromMinutes(6);
//bnd.SendTimeout = TimeSpan.FromMinutes(6);
//bnd.OpenTimeout = TimeSpan.FromMinutes(6);
//bnd.CloseTimeout = TimeSpan.FromMinutes(6);
//bnd.MaxBufferSize = InitParams.Current.MaxBufferSize;
//bnd.MaxReceivedMessageSize = bnd.MaxBufferSize;
//OMDQuerySoapClient omdQuery = new OMDQuerySoapClient(bnd, addr);
//DateTime? startDate = paramSearch.StartDate;
//DateTime? endDate = paramSearch.EndDate;
//if (paramSearch.StartDate != null)
// startDate = ((DateTime)paramSearch.StartDate).AddHours(hoursOffset);
//if (paramSearch.EndDate != null)
// endDate = ((DateTime)paramSearch.EndDate).AddDays(1).AddHours(hoursOffset).AddMinutes(-1);
//omdQuery.QueryTasksCompleted += new EventHandler<BCheck.Data.BCheckOMDQuery.QueryTasksCompletedEventArgs>(omdBridge_QueryTasksCompleted);
//omdQuery.QueryTasksAsync(ArchiveHelper.GetUserSearchText(paramSearch.AssignedTo), paramSearch.TaskName, ArchiveHelper.GetUserSearchText(paramSearch.Manager),
// paramSearch.StartDate, endDate, null);
TaskFetchCompletedEventArgs args = new TaskFetchCompletedEventArgs();
args.Tasks = new List<TaskItem>();
FetchedTasks = new List<bCheckV2.Helpers.Definitions.TaskItem>();
OpsChecklistDataAgentService opschecklistdataservice = new OpsChecklistDataAgentService();
opschecklistdataservice.GetArchivedTasks(results =>
{
FetchedTasks.AddRange(results);
foreach (bCheckV2.Helpers.Definitions.TaskItem task in results)
{
args.Tasks.Add(FormatTaskItem(task, View.vwAssignedTasks));
}
Deployment.Current.Dispatcher.BeginInvoke(delegate()
{
FetchTasksCompleteEvent(this, args);
return;
});
}, ArchiveHelper.GetUserSearchText(paramSearch.AssignedTo), paramSearch.TaskName, ArchiveHelper.GetUserSearchText(paramSearch.Manager), paramSearch.StartDate.Value.ToString(), paramSearch.EndDate.Value.ToString(), paramSearch.Functional, paramSearch.BusinessArea, paramSearch.Status);
}
else if (vw == View.vwCustomSearch)
{
string url = this.ConstructUrlParams(IIsAction.QUERY, vw, 0);
EndpointAddress addr = new EndpointAddress(url);//URL params injected, Mar 29
BasicHttpBinding bnd = new BasicHttpBinding();
bnd.ReceiveTimeout = TimeSpan.FromMinutes(6);
bnd.SendTimeout = TimeSpan.FromMinutes(6);
bnd.OpenTimeout = TimeSpan.FromMinutes(6);
bnd.CloseTimeout = TimeSpan.FromMinutes(6);
bnd.MaxBufferSize = InitParams.Current.MaxBufferSize;
bnd.MaxReceivedMessageSize = bnd.MaxBufferSize;
BCheckLists.ListsSoapClient listClient = new BCheck.Data.BCheckLists.ListsSoapClient(bnd, addr);
listClient.GetListItemsCompleted += new EventHandler<BCheck.Data.BCheckLists.GetListItemsCompletedEventArgs>(listClient_GetListItemsCompleted);
XElement query = XElement.Parse(queryXml);
XElement viewFields = XElement.Parse(viewFieldsXml);
string queryOptionsXml = "<QueryOptions><DateInUtc>TRUE</DateInUtc><IncludeAttachmentUrls>TRUE</IncludeAttachmentUrls><IncludeMandatoryColumns>FALSE</IncludeMandatoryColumns></QueryOptions>";
XElement queryOptions = XElement.Parse(queryOptionsXml);
string maxrows = BCheck.Data.InitParams.Current.MaxCamlRows.ToString();
listClient.GetListItemsAsync(InitParams.Current.ListName, "", query, viewFields, maxrows, queryOptions, null);
}
else
{
TaskFetchCompletedEventArgs args = new TaskFetchCompletedEventArgs();
args.Tasks = new List<TaskItem>();
FetchedTasks = new List<bCheckV2.Helpers.Definitions.TaskItem>();
OpsChecklistDataAgentService opschecklistdataservice = new OpsChecklistDataAgentService();
if (vw == (View.vwAssignedTasks | View.vwDueToday) || vw == View.vwOpsChecklistLoad)
{
opschecklistdataservice.GetAssignedTasksDueToday(results =>
{
FetchedTasks.AddRange(results);
foreach (bCheckV2.Helpers.Definitions.TaskItem task in results)
{
args.Tasks.Add(FormatTaskItem(task, View.vwAssignedTasks));
}
Deployment.Current.Dispatcher.BeginInvoke(delegate()
{
FetchTasksCompleteEvent(this, args);
return;
});
});
}
if (vw == (View.vwAssignedTasks | View.vwNotApplicable))
{
opschecklistdataservice.GetAssignedTasksNotApplicable(results =>
{
FetchedTasks.AddRange(results);
foreach (bCheckV2.Helpers.Definitions.TaskItem task in results)
{
args.Tasks.Add(FormatTaskItem(task, View.vwAssignedTasks));
}
Deployment.Current.Dispatcher.BeginInvoke(delegate()
{
FetchTasksCompleteEvent(this, args);
return;
});
});
}
if (vw == (View.vwManagedTasks | View.vwNotApplicable))
{
opschecklistdataservice.GetAssignedTasksNotApplicable(results =>
{
FetchedTasks.AddRange(results);
foreach (bCheckV2.Helpers.Definitions.TaskItem task in results)
{
args.Tasks.Add(FormatTaskItem(task, View.vwManagedTasks));
}
Deployment.Current.Dispatcher.BeginInvoke(delegate()
{
FetchTasksCompleteEvent(this, args);
return;
});
});
}
if (vw == (View.vwAssignedTasks | View.vwOverDue))
{
opschecklistdataservice.GetAssignedTasksOverdue(results =>
{
FetchedTasks.AddRange(results);
foreach (bCheckV2.Helpers.Definitions.TaskItem task in results)
{
args.Tasks.Add(FormatTaskItem(task, View.vwAssignedTasks));
}
Deployment.Current.Dispatcher.BeginInvoke(delegate()
{
FetchTasksCompleteEvent(this, args);
return;
});
});
}
if (vw == (View.vwAssignedTasks | View.vwCompletedApproved))
{
opschecklistdataservice.GetAssignedTasksCompleted(results =>
{
FetchedTasks.AddRange(results);
foreach (bCheckV2.Helpers.Definitions.TaskItem task in results)
{
args.Tasks.Add(FormatTaskItem(task, View.vwAssignedTasks));
}
Deployment.Current.Dispatcher.BeginInvoke(delegate()
{
FetchTasksCompleteEvent(this, args);
return;
});
});
}
if (vw == (View.vwManagedTasks | View.vwDueToday))
{
opschecklistdataservice.GetManagedTasksDueToday(results =>
{
FetchedTasks.AddRange(results);
foreach (bCheckV2.Helpers.Definitions.TaskItem task in results)
{
args.Tasks.Add(FormatTaskItem(task, View.vwManagedTasks));
}
Deployment.Current.Dispatcher.BeginInvoke(delegate()
{
FetchTasksCompleteEvent(this, args);
return;
});
});
}
if (vw == (View.vwManagedTasks | View.vwOverDue))
{
opschecklistdataservice.GetManagedTasksOverdue(results =>
{
FetchedTasks.AddRange(results);
foreach (bCheckV2.Helpers.Definitions.TaskItem task in results)
{
args.Tasks.Add(FormatTaskItem(task, View.vwManagedTasks));
}
Deployment.Current.Dispatcher.BeginInvoke(delegate()
{
FetchTasksCompleteEvent(this, args);
return;
});
});
}
if (vw == (View.vwManagedTasks | View.vwCompletedApproved))
{
opschecklistdataservice.GetManagedTasksApproved(results =>
{
FetchedTasks.AddRange(results);
foreach (bCheckV2.Helpers.Definitions.TaskItem task in results)
{
args.Tasks.Add(FormatTaskItem(task, View.vwManagedTasks));
}
Deployment.Current.Dispatcher.BeginInvoke(delegate()
{
FetchTasksCompleteEvent(this, args);
return;
});
});
}
/*
string TasksCAMLQuery = CreateCAMLQuery(vw, paramSearch, taskids);
if (TasksCAMLQuery != "Overload")
{
if (vw == View.vwOpsChecklistLoad || vw == (View.vwDueToday | View.vwAssignedTasks) || vw == (View.vwDueToday | View.vwManagedTasks))
{
TaskFetchCompletedEventArgs args;
TaskAlertsFetchCompletedEventArgs alertargs;
alertargs = new TaskAlertsFetchCompletedEventArgs();
args = new TaskFetchCompletedEventArgs();
args.Tasks = new List<TaskItem>();
alertargs.AssignedTasks = new List<TaskItem>();
alertargs.ManagedTasks = new List<TaskItem>();
MasterLookupService.Current.GetTasksWithDetails(TasksCAMLQuery, tasks =>
{
alertargs.HasAssignedTasks = false;
List<String> assignedtaskidstocheck = new List<String>();
taskids.AssignedTasksDueToday.ForEach(tid => assignedtaskidstocheck.Add(tid));
taskids.AssignedTasksOverdue.ForEach(tid => assignedtaskidstocheck.Add(tid));
taskids.AssignedTasksCompletedApproved.ForEach(tid => assignedtaskidstocheck.Add(tid));
taskids.AssignedTasksNotApplicable.ForEach(tid => assignedtaskidstocheck.Add(tid));
foreach (var taskid in assignedtaskidstocheck)
{
var tasksassigned = tasks.Where(t => t.ID == int.Parse(taskid));
if (tasksassigned.Count() > 0)
{
TaskItem t = tasksassigned.First();
t.SetInitializationComplete();
if ((vw & View.vwAssignedTasks) == View.vwAssignedTasks || vw == View.vwOpsChecklistLoad)
{
args.Tasks.Add(t);
}
alertargs.AssignedTasks.Add(t);
alertargs.HasAssignedTasks = true;
}
}
alertargs.HasManagedTasks = false;
List<String> managedtaskstocheck = new List<string>();
taskids.ManagedTasksDueToday.ForEach(tid => managedtaskstocheck.Add(tid));
taskids.ManagedTasksIncomplete.ForEach(tid => managedtaskstocheck.Add(tid));
taskids.ManagedTasksCompleted.ForEach(tid => managedtaskstocheck.Add(tid));
taskids.ManagedTasksNotApplicable.ForEach(tid => managedtaskstocheck.Add(tid));
foreach (var taskid in managedtaskstocheck)
{
var tasksmanaged = tasks.Where(t => t.ID == int.Parse(taskid));
if (tasksmanaged.Count() > 0)
{
TaskItem t = tasksmanaged.First();
t.SetInitializationComplete();
if ((vw & View.vwManagedTasks) == View.vwManagedTasks)
{
args.Tasks.Add(t);
}
alertargs.ManagedTasks.Add(t);
alertargs.HasManagedTasks = true;
}
}
Deployment.Current.Dispatcher.BeginInvoke(delegate()
{
FetchTasksCompleteEvent(this, args);
FetchTaskAlertsCompleteEvent(this, alertargs);
return;
});
});
}
else
{
TaskFetchCompletedEventArgs args;
args = new TaskFetchCompletedEventArgs();
//string TasksCAMLQuery = CreateCAMLQuery(vw, paramSearch, taskids);
args.Tasks = new List<TaskItem>();
//Adding tasks which have been returned in the query, the task filtering happens in the CAML helper
MasterLookupService.Current.GetTasksWithDetails(TasksCAMLQuery, tasks =>
{
// if ((vw == (View.vwOverDue | View.vwAssignedTasks)) || (vw == (View.vwOverDue | View.vwManagedTasks)))
if ((vw & View.vwOverDue) == View.vwOverDue )
{
foreach (var task in tasks)
{
if (task.CreatedUtc < RegionalSetting.GetRegionalMidnightToUtc())
{
task.SetInitializationComplete();
args.Tasks.Add(task);
}
}
}
else
{
foreach (var task in tasks)
{
task.SetInitializationComplete();
args.Tasks.Add(task);
}
}
Deployment.Current.Dispatcher.BeginInvoke(delegate()
{
FetchTasksCompleteEvent(this, args);
return;
});
});
}
}
else
{
string url = this.ConstructUrlParams(IIsAction.QUERY, vw, 0);
EndpointAddress addr = new EndpointAddress(url);//URL params injected, Mar 29
BasicHttpBinding bnd = new BasicHttpBinding();
bnd.ReceiveTimeout = TimeSpan.FromMinutes(6);
bnd.SendTimeout = TimeSpan.FromMinutes(6);
bnd.OpenTimeout = TimeSpan.FromMinutes(6);
bnd.CloseTimeout = TimeSpan.FromMinutes(6);
bnd.MaxBufferSize = InitParams.Current.MaxBufferSize;
bnd.MaxReceivedMessageSize = bnd.MaxBufferSize;
BCheckLists.ListsSoapClient listClient = new BCheck.Data.BCheckLists.ListsSoapClient(bnd, addr);
listClient.GetListItemsCompleted += new EventHandler<BCheck.Data.BCheckLists.GetListItemsCompletedEventArgs>(listClient_GetListItemsCompleted);
XElement query = XElement.Parse(queryXml);
XElement viewFields = XElement.Parse(viewFieldsXml);
string queryOptionsXml = "<QueryOptions><DateInUtc>TRUE</DateInUtc><IncludeAttachmentUrls>TRUE</IncludeAttachmentUrls><IncludeMandatoryColumns>FALSE</IncludeMandatoryColumns></QueryOptions>";
XElement queryOptions = XElement.Parse(queryOptionsXml);
string maxrows = BCheck.Data.InitParams.Current.MaxCamlRows.ToString();
listClient.GetListItemsAsync(InitParams.Current.ListName, "", query, viewFields, maxrows, queryOptions, null);
FetchAlertsForOverLoadCondition();
}*/
}
}
public void AddAttachment(TaskItem t, string attachmentName, Stream contents)
{
string url = this.ConstructUrlParams(IIsAction.ADDATTACHMENT, null, 0);
EndpointAddress addr = new EndpointAddress(url);//URL params injected, Mar 29
BasicHttpBinding bnd = new BasicHttpBinding();
bnd.MaxBufferSize = InitParams.Current.MaxBufferSize;
bnd.MaxReceivedMessageSize = bnd.MaxBufferSize;
BCheckLists.ListsSoapClient attachmentsClient = new BCheck.Data.BCheckLists.ListsSoapClient(bnd, addr);
attachmentsClient.AddAttachmentCompleted += new EventHandler<BCheck.Data.BCheckLists.AddAttachmentCompletedEventArgs>(attachmentsClient_AddAttachmentCompleted);
System.IO.MemoryStream memstm = (MemoryStream)contents;
object[] userparams = { t, attachmentName };
byte[] buff = new byte[memstm.Length];
memstm.Read(buff, 0, (int)memstm.Length);
attachmentsClient.AddAttachmentAsync(
InitParams.Current.ListName,
t.ID.ToString(), attachmentName, buff, userparams);
}
public void GetAttachments(TaskItem t)
{
BCheck.Data.ViewModel.Current.SelectedTask.AttachmentsURLs = null;
BCheck.Data.ViewModel.Current.IsUpdating = true;
string url = this.ConstructUrlParams(IIsAction.GETATTACHMENTS, null, 0);
EndpointAddress addr = new EndpointAddress(url);//URL params injected, Mar 29
BasicHttpBinding bnd = new BasicHttpBinding();
bnd.MaxBufferSize = InitParams.Current.MaxBufferSize;
bnd.MaxReceivedMessageSize = bnd.MaxBufferSize;
BCheckLists.ListsSoapClient attachmentsClient = new BCheck.Data.BCheckLists.ListsSoapClient(bnd, addr);
attachmentsClient.GetAttachmentCollectionCompleted += new EventHandler<BCheck.Data.BCheckLists.GetAttachmentCollectionCompletedEventArgs>(attachmentsClient_GetAttachmentCollectionCompleted);
attachmentsClient.GetAttachmentCollectionAsync(
InitParams.Current.ListName,
t.ID.ToString());
}
public void DeleteAttachment(TaskItem t, object attachmentidentifier)
{
string url = this.ConstructUrlParams(IIsAction.DELETEATTACHMENT, null, 0);
EndpointAddress addr = new EndpointAddress(url);//URL params injected, Mar 29
BasicHttpBinding bnd = new BasicHttpBinding();
bnd.MaxBufferSize = InitParams.Current.MaxBufferSize;
bnd.MaxReceivedMessageSize = bnd.MaxBufferSize;
BCheckLists.ListsSoapClient attachmentsDeleteClient = new BCheck.Data.BCheckLists.ListsSoapClient(bnd, addr);
attachmentsDeleteClient.DeleteAttachmentCompleted += new EventHandler<System.ComponentModel.AsyncCompletedEventArgs>(attachmentsDeleteClient_DeleteAttachmentCompleted);
object[] userparams = { t, (string)attachmentidentifier };
attachmentsDeleteClient.DeleteAttachmentAsync(
InitParams.Current.ListName,
t.ID.ToString(),
(string)attachmentidentifier, userparams);
}
