private void AddLinkToProject(DraftProject project, IEnumerable <TaskCreationInformation> tasks)
{
// Load tasks
IEnumerable <DraftTask> draftTasks = BaseProjectContext.LoadQuery(project.Tasks);
BaseProjectContext.ExecuteQuery();
// Disorder the tasks
List <TaskCreationInformation> levelTasks = tasks.ToList();
List <TaskCreationInformation> linkTasks = new List <TaskCreationInformation>();
while (levelTasks.Count > 0)
{
int taskIndex = RandomHelper.Random(0, levelTasks.Count - 1);
linkTasks.Add(levelTasks[taskIndex]);
levelTasks.RemoveAt(taskIndex);
}
// Add links
for (int i = 0; i < linkTasks.Count - 1; i++)
{
TaskLinkCreationInformation linkInfo = NewFSTaskLink(linkTasks[i].Id, linkTasks[i + 1].Id);
DraftTask task = draftTasks.Where(item => item.Id == linkInfo.StartId).FirstOrDefault();
task.Successors.Add(linkInfo);
}
ExcuteJobWithRetries(() =>
{
QueueJob job = project.Update();
WaitForJobComplete(job);
BaseProjectContext.ExecuteQuery();
LoggerHelper.Instance.Comment(string.Format("Finish Adding Links to Project: {0}", project.Name));
}, "Add Links to project");
}
private void PublishProject(DraftProject project)
{
ExcuteJobWithRetries(() =>
{
LoggerHelper.Instance.Comment("About to Pubilsh Project with Name: " + project.Name);
QueueJob job = project.Publish(true);
BaseProjectContext.ExecuteQuery();
LoggerHelper.Instance.Comment("Finish Pubilsh Project with Name: " + project.Name);
}, "Publish Project");
}
public bool Create(CustomFieldModel model)
{
if (model == null)
{
throw new ArgumentException("The CustomFieldModel is null.");
}
else
{
if (GetEntities().Any(item => item.Name == model.Name))
{
// No need to do anything currently
}
else
{
LookupTable table = null;
switch (model.InputType.ToLower())
{
case "lookuptable":
table = new LookupTableCSOMClient().GetEntities().FirstOrDefault(item => item.Name == model.LookupTable);
model.Formula = null;
break;
case "freeform":
model.Formula = null;
break;
}
CustomFieldCreationInformation customFieldInfo = new CustomFieldCreationInformation()
{
Id = Guid.NewGuid(),
EntityType = GetEntityType(model.EntityType),
FieldType = model.ValueType.ConvertToCustomFieldType(),
LookupTable = table,
Formula = model.Formula,
Name = model.Name
};
// CSOM API doesn't support to create CustomFiled using multi threads
lock (CustomFieldCSOMClient.strLock)
{
bool result = ExcuteJobWithRetries(() =>
{
LoggerHelper.Instance.Comment("About to Create CustomField with Name: " + customFieldInfo.Name);
CustomField field = BaseProjectContext.CustomFields.Add(customFieldInfo);
BaseProjectContext.CustomFields.Update();
BaseProjectContext.ExecuteQuery();
LoggerHelper.Instance.Comment("Finish Creating CustomField with Name: " + customFieldInfo.Name);
},
"Create CustomField");
return(result);
}
}
}
return(true);
}
public IEnumerable <CustomField> GetEntities()
{
IEnumerable <CustomField> customFields = null;
ExcuteJobWithRetries(() =>
{
customFields = BaseProjectContext.LoadQuery(BaseProjectContext.CustomFields);
BaseProjectContext.ExecuteQuery();
},
"Query CustomField");
return(customFields ?? new List <CustomField>());
}
public IEnumerable <LookupTable> GetEntities()
{
IEnumerable <LookupTable> lookuptables = null;
ExcuteJobWithRetries(() =>
{
lookuptables = BaseProjectContext.LoadQuery(BaseProjectContext.LookupTables);
BaseProjectContext.ExecuteQuery();
},
"Query LookupTable");
return(lookuptables ?? new List <LookupTable>());
}
public IEnumerable <PublishedProject> GetEntities()
{
IEnumerable <PublishedProject> projects = null;
ExcuteJobWithRetries(() =>
{
projects = BaseProjectContext.LoadQuery(BaseProjectContext.Projects);
BaseProjectContext.ExecuteQuery();
},
"Query Project");
return(projects ?? new List <PublishedProject>());
}
public IEnumerable <EnterpriseResource> GetEntities()
{
IEnumerable <EnterpriseResource> resources = null;
ExcuteJobWithRetries(() =>
{
resources = BaseProjectContext.LoadQuery(BaseProjectContext.EnterpriseResources);
BaseProjectContext.ExecuteQuery();
resources = resources.Where(item => item.ResourceType != EnterpriseResourceType.NotSpecified);
},
"Query EnterpriseResource");
return(resources ?? new List <EnterpriseResource>());
}
public bool Delete(CustomFieldModel model)
{
return(ExcuteJobWithRetries(() =>
{
IEnumerable <CustomField> customFields = BaseProjectContext.LoadQuery(BaseProjectContext.CustomFields.Where(item => item.Name == model.Name));
BaseProjectContext.ExecuteQuery();
CustomField customField = customFields.FirstOrDefault();
BaseProjectContext.Load(customField);
customField.DeleteObject();
BaseProjectContext.ExecuteQuery();
},
"Delete CustomField"));
}
public bool Delete(ResourcePoolModel model)
{
IEnumerable <EnterpriseResource> resources = BaseProjectContext.LoadQuery(BaseProjectContext.EnterpriseResources.Where(item => item.Name.StartsWith(model.NamePrefix)));
BaseProjectContext.ExecuteQuery();
foreach (EnterpriseResource resource in resources)
{
BaseProjectContext.Load(resource);
resource.DeleteObject();
BaseProjectContext.ExecuteQuery();
}
return(true);
}
private DraftProject CheckOutProject(PublishedProject project)
{
DraftProject draftProject = null;
ExcuteJobWithRetries(() =>
{
LoggerHelper.Instance.Comment("About to Checkout Project with Name: " + project.Name);
draftProject = project.CheckOut();
BaseProjectContext.Load(draftProject);
BaseProjectContext.ExecuteQuery();
LoggerHelper.Instance.Comment("Finish Checkout Project with Name: " + project.Name);
},
"Checkout Project");
return(draftProject);
}
private void BuildTeam(DraftProject project, IEnumerable <EnterpriseResource> resources)
{
foreach (EnterpriseResource resource in resources)
{
LoggerHelper.Instance.Comment(string.Format("About to Add Resource: {0} to Project: {1}", resource.Name, project.Name));
project.ProjectResources.AddEnterpriseResource(resource);
}
ExcuteJobWithRetries(() =>
{
QueueJob job = project.Update();
WaitForJobComplete(job);
BaseProjectContext.ExecuteQuery();
LoggerHelper.Instance.Comment(string.Format("Finish Adding Resources to Project: {0}", project.Name));
},
"Add Resource to Project");
}
public bool Create(ResourcePoolModel model)
{
if (model == null)
{
throw new ArgumentException("The ResourcePoolModel is null.");
}
else
{
IEnumerable <EnterpriseResource> resources = GetEntities();
for (int i = 0; i < model.Count; i++)
{
string resourceName = model.NamePrefix + i.ToString();
if (resources.Any(item => item.Name == resourceName && item.ResourceType.ToString().ToLower() == model.Type.ToLower()))
{
// No need to do anything currently
}
else
{
EnterpriseResourceCreationInformation resourceInfo = new EnterpriseResourceCreationInformation()
{
Name = resourceName,
ResourceType = model.Type.ConvertToResourceType()
};
EnterpriseResource resource = BaseProjectContext.EnterpriseResources.Add(resourceInfo);
int executePoint = 1000;
if (i % executePoint == 0 || i == model.Count - 1)
{
ExcuteJobWithRetries(() =>
{
LoggerHelper.Instance.Comment("About to Create Resource with Name: " + resourceInfo.Name);
BaseProjectContext.EnterpriseResources.Update();
BaseProjectContext.ExecuteQuery();
LoggerHelper.Instance.Comment("Finish Creating Resource with Name: " + resourceInfo.Name);
},
"Create Resource");
}
}
}
BaseProjectContext.ExecuteQuery();
}
return(true);
}
public bool Delete(ProjectModel model)
{
IEnumerable <PublishedProject> projects = BaseProjectContext.LoadQuery(BaseProjectContext.Projects.Where(item => item.Name.StartsWith(model.NamePrefix)));
BaseProjectContext.ExecuteQuery();
foreach (PublishedProject project in projects)
{
BaseProjectContext.Load(project);
BaseProjectContext.ExecuteQuery();
if (project.IsCheckedOut)
{
QueueJob job = project.Draft.CheckIn(true);
BaseProjectContext.ExecuteQuery();
WaitForJobComplete(job);
}
project.DeleteObject();
BaseProjectContext.ExecuteQuery();
}
return(true);
}
public bool Create(LookupTableModel model)
{
if (model == null)
{
throw new ArgumentException("The LookupTableModel is null.");
}
else
{
if (GetEntities().Any(item => item.Name == model.Name))
{
// No need to do anything currently
}
else
{
IEnumerable <LookupEntryCreationInformation> lstLookupEntry = CreateLookupEntry(model);
IEnumerable <LookupMask> lstLookupMask = CreateLookupMask(model);
LookupTableCreationInformation newLookupTable = new LookupTableCreationInformation()
{
Id = Guid.NewGuid(),
Name = model.Name,
SortOrder = LookupTableSortOrder.Ascending,
Masks = lstLookupMask,
Entries = lstLookupEntry
};
bool result = ExcuteJobWithRetries(() =>
{
LoggerHelper.Instance.Comment("About to Create LookupTable with Name: " + newLookupTable.Name);
LookupTable table = BaseProjectContext.LookupTables.Add(newLookupTable);
BaseProjectContext.LookupTables.Update();
BaseProjectContext.ExecuteQuery();
LoggerHelper.Instance.Comment("Finish Creating LookupTable with Name: " + newLookupTable.Name);
},
"Create LookupTable");
return(result);
}
}
return(true);
}
private void AddTaskToProject(DraftProject project, IEnumerable <IEnumerable <TaskCreationInformation> > tasks, IEnumerable <EnterpriseResource> resources, int resourceCount)
{
foreach (TaskCreationInformation taskInfo in tasks.SelectMany(item => item))
{
LoggerHelper.Instance.Comment(string.Format("About to Add Task: {0} to Project: {1}", taskInfo.Name, project.Name));
DraftTask draftTask = project.Tasks.Add(taskInfo);
AddAssignmentToTask(draftTask, resources, resourceCount, taskInfo.Id);
}
ExcuteJobWithRetries(() =>
{
QueueJob job = project.Update();
WaitForJobComplete(job);
BaseProjectContext.ExecuteQuery();
LoggerHelper.Instance.Comment(string.Format("Finish Adding Task to Project: {0}", project.Name));
},
"Add Task to Project");
// Add tasks link
int levelIndex = RandomHelper.Random(0, tasks.Count() - 1);
AddLinkToProject(project, tasks.ElementAt(levelIndex));
}
private PublishedProject CreateEmptyProject(string projectName)
{
PublishedProject project = null;
ProjectCreationInformation creationInfo = new ProjectCreationInformation()
{
Name = projectName,
Start = DateTime.Now
};
ExcuteJobWithRetries(() =>
{
LoggerHelper.Instance.Comment("About to Create Project with Name: " + creationInfo.Name);
project = BaseProjectContext.Projects.Add(creationInfo);
QueueJob job = BaseProjectContext.Projects.Update();
this.WaitForJobComplete(job);
BaseProjectContext.Load(project);
BaseProjectContext.ExecuteQuery();
LoggerHelper.Instance.Comment("Finish Creating empty Project with Name: " + creationInfo.Name);
},
"Create Project");
return(project);
}
protected BaseRepository(BaseProjectContext context)
{
Context = context;
}
public UserRepository(BaseProjectContext dbContext) : base(dbContext)
{
}
public ExampleRepository(BaseProjectContext context)
: base(context)
{
}
public NoteItemRepository(BaseProjectContext dbContext) : base(dbContext)
{
}
public Repository(BaseProjectContext dbContext)
{
_dbContext = dbContext ?? throw new ArgumentNullException(nameof(dbContext));
}
protected BaseSummaryRepository(BaseProjectContext context)
: base(context)
{
}
