public async Task <IEnumerable <PublishedAssignment> > GetAllAsync(PublishedTask publishedTask)
{
if (publishedTask == null)
{
throw new ArgumentNullException(nameof(publishedTask));
}
IEnumerable <PublishedAssignment> assignments = new List <PublishedAssignment>();
try
{
_projectContext.Load(publishedTask.Assignments);
await _projectContext.ExecuteQueryAsync();
// Force a new list to avoid returning same list than stored in context
assignments = new List <PublishedAssignment>(publishedTask.Assignments.ToArray());
}
catch (Exception ex)
{
// TODO: LOG ERROR!
throw new CsomClientException($"Unexcepted error getting all task assignments. " +
$"Published task name is {publishedTask.Name}. " +
$"Project context url is {_projectContext.Url}.", ex);
}
return(assignments);
}
public GivenAnAssignmentClientInstance()
{
IApplicationContext applicationContext = new ApplicationContext();
IConfigurationRoot configurationRoot = ConfigurationRootFactory.Create(applicationContext);
IConfigurationGetter configurationGetter = new ConfigurationGetter(configurationRoot);
var projectContextOptions = configurationGetter.GetOptions <ProjectContextOptions>();
var clientOptions = configurationGetter.GetOptions <CsomClientOptions>();
var projectContext = ProjectContextFactory.Build(projectContextOptions);
_projectClient = new ProjectClient(projectContext, clientOptions);
_taskClient = new TaskClient(projectContext, clientOptions);
_resourceClient = new EnterpriseResourceClient(projectContext, clientOptions);
_client = new AssignmentClient(projectContext, clientOptions);
_publishedProject = CreateTestProject().Result;
_publishedTask = CreateTestTask().Result;
_enterpriseResource = CreateTestResource().Result;
_enterpriseResource2 = CreateTestResource().Result;
_publishedProject = _projectClient.LinkToEnterpriseResources(_publishedProject, new [] { _enterpriseResource, _enterpriseResource2 }).Result;
}
public async Task <bool> RemoveAsync(PublishedProject publishedProject, PublishedTask publishedTask)
{
if (publishedProject == null)
{
throw new ArgumentNullException(nameof(publishedProject));
}
if (publishedTask == null)
{
throw new ArgumentNullException(nameof(publishedTask));
}
bool result = false;
try
{
// Ensure the task with the same id exist
var task = _projectContext.LoadQuery(publishedProject.Tasks.
Where(pr => pr.Id == publishedTask.Id));
await _projectContext.ExecuteQueryAsync();
if (task.Any())
{
// Ensure I have it check it out
await _projectClient.CheckInAsync(publishedProject);
var draftProject = await _projectClient.CheckOutAsync(publishedProject);
_projectContext.Load(draftProject.Tasks);
var draftTask = _projectContext.LoadQuery(draftProject.Tasks.Where(pr => pr.Id == publishedTask.Id));
await _projectContext.ExecuteQueryAsync();
var clientResult = draftProject.Tasks.Remove(draftTask.First());
await _projectClient.PublishAndUpdate(draftProject, publishedProject.Name);
await _projectClient.CheckInAsync(publishedProject);
result = clientResult.Value;
}
}
catch (Exception ex)
{
// TODO: LOG ERROR!
throw new CsomClientException($"Unexcepted error removing a task. " +
$"project id is {publishedProject.Id}. " +
$"Project context url is {_projectContext.Url}.", ex);
}
return(result);
}
public void PublishDelayedTask(TaskBase task, DateTime publishDate, string createdBy)
{
Logger.Info(
"{createdBy} publish delayed (@{publishDate}) task {@task}",
createdBy,
publishDate,
task);
PublishedTask publishedTask = databases.Snittlistan.PublishedTasks.Add(
PublishedTask.CreateDelayed(
task,
currentTenant.TenantId,
correlationId,
causationId,
publishDate,
createdBy));
Logger.Info("added delayed task {@publishedTask}", publishedTask);
}
public async Task <PublishedTask> GetByIdAsync(PublishedProject publishedProject, Guid id, bool includeCustomFields = false)
{
if (publishedProject == null)
{
throw new ArgumentNullException(nameof(publishedProject));
}
if (id == null)
{
throw new ArgumentNullException(nameof(id));
}
PublishedTask publishedTask = null;
try
{
IEnumerable <PublishedTask> publishedTasks = _projectContext.LoadQuery(
publishedProject.Tasks.Where(t => t.Id == id));
await _projectContext.ExecuteQueryAsync();
if (publishedTasks.Any())
{
publishedTask = publishedTasks.FirstOrDefault();
if (includeCustomFields)
{
await LoadCustomFields(publishedTask);
}
}
}
catch (Exception ex)
{
// TODO: LOG ERROR!
throw new CsomClientException($"Unexcepted error getting a task by id. " +
$"id searched is {id}. " +
$"Published project name is {publishedProject.Name}. " +
$"Project context url is {_projectContext.Url}.", ex);
}
return(publishedTask);
}
static void Main(string[] args)
{
// Lists out the LCFs for a specific project in the PWA instance, consisting of the
// field type, field name, whether a lookup table is used, and the value and description of each each LCF entry.
// This app does the following:
// 1. Retrieves a specific project, task(s), and custom fields associated with the tasks in the project
// 2. Place the custom field key/value pairs in a dictionary
// 3. Do the following for each Local Custom Field:
// A. Distinguish between simple values and values that use a lookup table for
// the friendly values.
// B. Filter out partial entries.
// C. List the friendly value for the user (simple values)
// D. List the friendly value for the user (lookup tables)
using (projContext)
{
// Get login cookie using WebLogin
var cookies = WebLogin.GetWebLoginCookie(new Uri(SiteUrl));
projContext.ExecutingWebRequest += delegate(object sender, WebRequestEventArgs e)
{
e.WebRequestExecutor.WebRequest.CookieContainer = new CookieContainer();
e.WebRequestExecutor.WebRequest.CookieContainer.SetCookies(new Uri(SiteUrl), cookies);
};
// 1. Retrieve the project, tasks, etc.
var projColl = projContext.LoadQuery(projContext.Projects
.Where(p => p.Name == SampleProjectName)
.Include(
p => p.Id,
p => p.Name,
p => p.Tasks,
p => p.Tasks.Include(
t => t.Id,
t => t.Name,
t => t.CustomFields,
t => t.CustomFields.IncludeWithDefaultProperties(
cf => cf.LookupTable,
cf => cf.LookupEntries
)
)
)
);
projContext.ExecuteQuery();
PublishedProject theProj = projColl.First();
Console.WriteLine("Name:\t{0}", theProj.Name);
Console.WriteLine("Id:\t{0}", theProj.Id);
Console.WriteLine("Tasks count: {0}", theProj.Tasks.Count);
Console.WriteLine(" -----------------------------------------------------------------------------");
PublishedTaskCollection taskColl = theProj.Tasks;
PublishedTask theTask = taskColl.First();
CustomFieldCollection LCFColl = theTask.CustomFields;
// 2. Place the task-specific custom field key/value pairs in a dictionary
Dictionary <string, object> taskCF_Dict = theTask.FieldValues;
if (LCFColl.Count > 0)
{
Console.WriteLine("\n\tType\t Name\t\t L.UP Value Description");
Console.WriteLine("\t-------- ------------ ---- -------------------- -----------");
// 3. For each custom field, do the follwoing:
foreach (CustomField cf in LCFColl)
{
// 3A. Distinguish LCF values that are simple from those that use lookup tables.
if (!cf.LookupTable.ServerObjectIsNull.HasValue ||
(cf.LookupTable.ServerObjectIsNull.HasValue && cf.LookupTable.ServerObjectIsNull.Value))
{
if (taskCF_Dict[cf.InternalName] == null)
{ // 3B. Partial implementation. Not usable.
String textValue = "is not set";
Console.WriteLine("\t{0} {1} {2}", cf.FieldType, cf.Name, textValue);
}
else // 3C. Friendly value for the user (simple).
{
String textValue = taskCF_Dict[cf.InternalName].ToString();
Console.WriteLine("\t{0, -8} {1, -15} {2}", cf.FieldType, cf.Name, textValue);
}
}
else //3D. Friendly value for the user that uses a Lookup table.
{
Console.Write("\t{0, -8} {1, -15}", cf.FieldType, cf.Name);
String[] entries = (String[])taskCF_Dict[cf.InternalName];
foreach (String entry in entries)
{
var luEntry = projContext.LoadQuery(cf.LookupTable.Entries
.Where(e => e.InternalName == entry));
projContext.ExecuteQuery();
Console.WriteLine("Yes {0, -22} {1}", luEntry.First().FullValue, luEntry.First().Description);
}
}
} // End foreach CustomField
}
}
Console.Write("\nPress any key to exit: ");
Console.ReadKey(false);
} // End of Main
private async System.Threading.Tasks.Task LoadCustomFields(PublishedTask publishedTask)
{
_projectContext.Load(publishedTask.CustomFields);
await _projectContext.ExecuteQueryAsync();
}
protected override async Task OnSetUp(IWindsorContainer container)
{
// Arrange
await Transact(session =>
{
session.Store(new WebsiteConfig(new[] { new WebsiteConfig.TeamNameAndLevel("FIF", "A") }, false, 1660, 2012));
Player[] players = new[]
{
new Player("Christer Liedholm", "*****@*****.**", Player.Status.Active, 0, null, new string[0], new PlayerItem {
LicNbr = "M131061CHR01"
}),
new Player("Mathias Ernest", "*****@*****.**", Player.Status.Active, 0, null, new string[0], new PlayerItem {
LicNbr = "M131061CHR01"
}),
new Player("Torbjörn Jensen", "*****@*****.**", Player.Status.Active, 0, null, new string[0], new PlayerItem {
LicNbr = "M131061CHR01"
}),
new Player("Alf Kindblom", "*****@*****.**", Player.Status.Active, 0, null, new string[0], new PlayerItem {
LicNbr = "M131061CHR01"
}),
new Player("Peter Sjöberg", "*****@*****.**", Player.Status.Active, 0, null, new string[0], new PlayerItem {
LicNbr = "M131061CHR01"
}),
new Player("Lars Öberg", "*****@*****.**", Player.Status.Active, 0, null, new string[0], new PlayerItem {
LicNbr = "M131061CHR01"
}),
new Player("Mikael Axelsson", "*****@*****.**", Player.Status.Active, 0, null, new string[0], new PlayerItem {
LicNbr = "M131061CHR01"
}),
new Player("Hans Norbeck", "*****@*****.**", Player.Status.Active, 0, null, new string[0], new PlayerItem {
LicNbr = "M131061CHR01"
}),
new Player("Lennart Axelsson", "*****@*****.**", Player.Status.Active, 0, null, new string[0], new PlayerItem {
LicNbr = "M131061CHR01"
})
};
foreach (Player player in players)
{
session.Store(player);
}
Roster roster = new(
2012,
1,
3048746,
"Fredrikshof IF",
"A",
"Bowl-O-Rama",
"Högdalen BK",
new DateTime(2013, 4, 27),
false,
OilPatternInformation.Empty)
{
Players = players.Select(x => x.Id).ToList()
};
session.Store(roster);
rosterId = roster.Id;
return(Task.CompletedTask);
});
IBitsClient bitsClient = Mock.Of <IBitsClient>();
_ = Mock.Get(bitsClient)
.Setup(x => x.GetMatchResults(3048746))
.Returns(BitsGateway.GetMatchResults(3048746));
_ = Mock.Get(bitsClient)
.Setup(x => x.GetMatchScores(3048746))
.Returns(BitsGateway.GetMatchScores(3048746));
_ = Mock.Get(bitsClient)
.Setup(x => x.GetHeadInfo(3048746))
.Returns(BitsGateway.GetHeadInfo(3048746));
_ = Mock.Get(bitsClient)
.Setup(x => x.GetHeadResultInfo(3048746))
.Returns(BitsGateway.GetHeadResultInfo(3048746));
_ = container.Register(Component.For <IBitsClient>().Instance(bitsClient));
task = new(rosterId !, 123);
PublishedTask publishedTask = Databases.Snittlistan.PublishedTasks.Add(
PublishedTask.CreateImmediate(
task,
1,
Guid.NewGuid(),
null,
"test"));
envelope = new(
task,
publishedTask.TenantId,
"",
publishedTask.CorrelationId,
null,
publishedTask.MessageId);
}
public void PublishTask(TaskBase task, string createdBy)
{
Logger.Info("{createdBy} publish task {@task}", createdBy, task);
PublishedTask publishedTask = databases.Snittlistan.PublishedTasks.Add(
PublishedTask.CreateImmediate(
task,
currentTenant.TenantId,
correlationId,
causationId,
createdBy));
try
{
HostingEnvironment.QueueBackgroundWorkItem(ct =>
PublishMessage(currentTenant, publishedTask.MessageId, ct));
}
catch (Exception ex)
{
Logger.Error(
ex,
"QueueBackgroundWorkItem failed, using fallback (publish immediately)");
try
{
DoPublishMessage(currentTenant, publishedTask);
}
catch (Exception ex2)
{
Logger.Error(ex2);
}
}
async void PublishMessage(Tenant tenant, Guid messageId, CancellationToken ct)
{
const int MaxTries = 10;
using IDisposable logScope = NestedDiagnosticsLogicalContext.Push("QueueBackgroundWork");
using SnittlistanContext context = new();
try
{
for (int i = 0; i < MaxTries; i++)
{
Logger.Info("try #{try}", i);
PublishedTask?publishedTask =
await context.PublishedTasks.SingleOrDefaultAsync(x => x.MessageId == messageId);
if (publishedTask == null)
{
Logger.Warn("message not found: {messageId}", messageId);
await Task.Delay(300);
}
else
{
DoPublishMessage(tenant, publishedTask);
return;
}
}
throw new Exception($"max tries reached: {MaxTries}");
}
catch (Exception ex)
{
Logger.Error(ex, "failed to publish message");
}
}
void DoPublishMessage(Tenant tenant, PublishedTask publishedTask)
{
using MsmqGateway msmqGateway = msmqFactory.Create();
using MsmqGateway.MsmqTransactionScope scope = msmqGateway.Create();
MessageEnvelope message = new(
publishedTask.Task,
publishedTask.TenantId,
tenant.Hostname,
publishedTask.CorrelationId,
publishedTask.CausationId,
publishedTask.MessageId);
scope.Send(message);
scope.Commit();
Logger.Info("published message {@message}", message);
}
}
EnterpriseManagementObject buildTaskActivity(PublishedTask task,
EnterpriseManagementObject releaseRecord,
EnterpriseManagementObject taskActivity,
EnterpriseManagementObject project,
ref int sequenceId)
{
var activityClass = mpcClasses.First(mpc => mpc.Name == "Cireson.ProjectAutomation.ProjectTask.Activity");
#region set properties
if (taskActivity.IsNew)
{
taskActivity[activityClass, "Id"].Value = sTaskActivityPrefix + taskActivity[activityClass, "Id"].Value as string;
taskActivity[activityClass, "TaskGUID"].Value = task.Id;
if (releaseRecord[null, "Status"].Value == releaseStatusEnums.First(e => e.Name == "ReleaseStatusEnum.InProgress")) //if RR in progress, set initial status to pending.
{
taskActivity[activityClass, "Status"].Value = activityStatusEnums.First(e => e.Name == "ActivityStatusEnum.Ready");
}
else if (releaseRecord[null, "Status"].Value == releaseStatusEnums.First(e => e.Name == "ReleaseStatusEnum.Editing")) // if RR in editing mode, set initial status to on-hold.
{
taskActivity[activityClass, "Status"].Value = activityStatusEnums.First(e => e.Name == "ActivityStatusEnum.OnHold");
}
}
taskActivity[activityClass, "PercentComplete"].Value = task.PercentComplete as int?;
taskActivity[activityClass, "Title"].Value = task.Name + " : " + taskActivity[activityClass, "PercentComplete"].Value + "% " +
mpManagementPacks.First(mp => mp.Name == "Cireson.ProjectAutomation.Library").GetStringResource("strComplete").DisplayName;
taskActivity[activityClass, "Description"].Value = task.Notes;
taskActivity[activityClass, "ScheduledStartDate"].Value = task.ScheduledStart;
taskActivity[activityClass, "ScheduledEndDate"].Value = task.ScheduledFinish;
taskActivity[activityClass, "SequenceId"].Value = sequenceId;
taskActivity[activityClass, "DisplayName"].Value = taskActivity[activityClass, "Id"].Value;
#endregion
#region status enums
//set a status
//Activity Status (System.WorkItem.Activity.Library) (ActivityStatusEnum) (57db4880-000e-20bb-2f9d-fe4e8aca3cf6)
//Cancelled (System.WorkItem.Activity.Library) (ActivityStatusEnum.Cancelled) (89465302-2a23-d2b6-6906-74f03d9b7b41)
//Completed (System.WorkItem.Activity.Library) (ActivityStatusEnum.Completed) (9de908a1-d8f1-477e-c6a2-62697042b8d9)
//Failed (System.WorkItem.Activity.Library) (ActivityStatusEnum.Failed) (144bcd52-a710-2778-2a6e-c62e0c8aae74)
//In Progress (System.WorkItem.Activity.Library) (ActivityStatusEnum.Active) (11fc3cef-15e5-bca4-dee0-9c1155ec8d83)
//On Hold (System.WorkItem.Activity.Library) (ActivityStatusEnum.OnHold) (d544258f-24da-1cf3-c230-b057aaa66bed)
//Pending (System.WorkItem.Activity.Library) (ActivityStatusEnum.Ready) (50c667cf-84e5-97f8-f6f8-d8acd99f181c)
//Rerun (System.WorkItem.Activity.Library) (ActivityStatusEnum.Rerun) (baa948b5-cc6a-57d7-4b56-d2012721b2e5)
//Skipped (System.WorkItem.Activity.Library) (ActivityStatusEnum.Skipped) (eaec5899-b13c-d107-3e1a-955da6bf9fa7)
if (task.PercentComplete == 100 && releaseRecord[null, "Status"].Value == releaseStatusEnums.First(e => e.Name == "ReleaseStatusEnum.InProgress")) // only set status if RR is in progress
{
taskActivity[activityClass, "Status"].Value = activityStatusEnums.First(e => e.Name == "ActivityStatusEnum.Completed");
}
#endregion
#region set workitem and CI relationships
CreatableEnterpriseManagementRelationshipObject cemroReleaseContainsActivity = new CreatableEnterpriseManagementRelationshipObject(
emg, mprRelationships.First(r => r.Name == "System.WorkItemContainsActivity"));
cemroReleaseContainsActivity.SetSource(releaseRecord);
cemroReleaseContainsActivity.SetTarget(taskActivity);
iddBucket.Add(cemroReleaseContainsActivity);
CreatableEnterpriseManagementRelationshipObject cemroActivityHasProject = new CreatableEnterpriseManagementRelationshipObject(
emg, mprRelationships.First(r => r.Name == "Cireson.ProjectAutomation.WorkItemHasProject"));
cemroActivityHasProject.SetSource(taskActivity);
cemroActivityHasProject.SetTarget(project);
iddBucket.Add(cemroActivityHasProject);
CreatableEnterpriseManagementRelationshipObject cemroRelatedProject = new CreatableEnterpriseManagementRelationshipObject(
emg, mprRelationships.First(r => r.Name == "Cireson.ProjectAutomation.ProjectHasTask"));
cemroRelatedProject.SetSource(project);
cemroRelatedProject.SetTarget(taskActivity);
iddBucket.Add(cemroRelatedProject);
#endregion
#region set activity implemeter and resources
var userClass = mpcClasses.First(mpc => mpc.Name == "Microsoft.AD.UserBase");
var taskOwner = task.Assignments.FirstOrDefault();
if (taskOwner != null && taskOwner.Resource.DefaultAssignmentOwner.ServerObjectIsNull != true) //bug fix. We needed to check the server if the default owner is null too.
{
string activityImplementerSID = taskOwner.Resource.DefaultAssignmentOwner.UserId.NameId;
EnterpriseManagementObjectCriteria emoCriteria = new EnterpriseManagementObjectCriteria(string.Format(xmlResourceCriteria, activityImplementerSID),
userClass, mpManagementPacks.First(mp => mp.Name == "Microsoft.Windows.Library"), emg);
EnterpriseManagementObject emoImplementer = emg.EntityObjects.GetObjectReader <EnterpriseManagementObject>(emoCriteria, ObjectQueryOptions.Default).FirstOrDefault();
if (emoImplementer != null && (bool)emoProjectAutomationSettings[null, "CanAssignActivityImplementer"].Value)
{
CreatableEnterpriseManagementRelationshipObject cemroActivityImplementer = new CreatableEnterpriseManagementRelationshipObject(
emg, mprRelationships.First(r => r.Name == "System.WorkItemAssignedToUser"));
cemroActivityImplementer.SetSource(taskActivity);
cemroActivityImplementer.SetTarget(emoImplementer);
iddBucket.Add(cemroActivityImplementer);
}
foreach (var assignment in task.Assignments)
{
//get the user SID
if (assignment.Resource.DefaultAssignmentOwner.ServerObjectIsNull == true)
{
continue;
}
var resourceSid = assignment.Resource.DefaultAssignmentOwner.UserId.NameId;
emoCriteria = new EnterpriseManagementObjectCriteria(string.Format(xmlResourceCriteria, resourceSid),
userClass, mpManagementPacks.First(mp => mp.Name == "Microsoft.Windows.Library"), emg);
EnterpriseManagementObject emoResource = emg.EntityObjects.GetObjectReader <EnterpriseManagementObject>(emoCriteria, ObjectQueryOptions.Default).FirstOrDefault();
if (emoResource != null)
{
CreatableEnterpriseManagementRelationshipObject cemroResource = new CreatableEnterpriseManagementRelationshipObject(
emg, mprRelationships.First(r => r.Name == "System.WorkItemRelatesToConfigItem"));
cemroResource.SetSource(taskActivity);
cemroResource.SetTarget(emoResource);
iddBucket.Add(cemroResource);
}
}
}
#endregion
sequenceId++;
return(taskActivity);
}
