public void SetPSAMInProjectName()
{
projContext.Load(projContext.Projects);
projContext.ExecuteQuery();
foreach (var pubProj in projContext.Projects)
{
int planZakazNumber = 0;
try
{
planZakazNumber = Convert.ToInt32(pubProj.Name.Substring(0, 4));
}
catch
{
}
string rsamName = "";
if (planZakazNumber > 0)
{
rsamName = GetRSAMName(planZakazNumber).Replace("_", "-");
}
if (planZakazNumber > 1156 && rsamName != "" && pubProj.Name.Length == pubProj.Name.Replace("PCAM", "").Length&& GetVipusk(planZakazNumber) == false)
{
try
{
DraftProject projectDraft = pubProj.CheckOut();
projContext.Load(projectDraft);
projContext.ExecuteQuery();
projectDraft.Name += " " + rsamName;
Console.WriteLine(projectDraft.Name);
QueueJob job = projectDraft.Update();
job = projectDraft.Publish(true);
}
catch { }
}
}
}
private static void UpdateProjectCustomField(Guid ProjectId)
{
DraftProject projCheckedOut = null;
try
{
Dictionary <string, object> projDict = new Dictionary <string, object>();
using (ProjectContext projContext = new ProjectContext(PWAUrl))
{
projContext.ExecutingWebRequest += claimsHelper.clientContext_ExecutingWebRequest;
var PrjList = projContext.LoadQuery(projContext.Projects.Where(proj => proj.Name == ""));
projContext.ExecuteQuery();
Guid pGuid = PrjList.First().Id;
PublishedProject proj2Edit = PrjList.First();
projCheckedOut = proj2Edit.CheckOut().IncludeCustomFields;
projContext.Load(projCheckedOut);
projContext.ExecuteQuery();
var cflist = projContext.LoadQuery(projContext.CustomFields.Where(cf => cf.Name == "Testcol"));
projContext.ExecuteQuery();
projCheckedOut.SetCustomFieldValue(cflist.FirstOrDefault().InternalName, "Entry_c8f0abff70f5e51180cc00155dd45b0a");
QueueJob qJob = projCheckedOut.Publish(true);
JobState jobState = projContext.WaitForQueue(qJob, 70);
}
}
catch (Exception ex)
{
}
}
private static void UpdateTaskCF()
{
projectContext.Load(projectContext.Projects); //Load Projects from PWA
projectContext.ExecuteQuery();
projectContext.Load(projectContext.CustomFields); //Load Custom Fields from PWA
projectContext.ExecuteQuery();
Guid ProjectGuid = new Guid("3531cb1f - 51ce - 4a27 - a45a - 590339b99aed");
Guid TaskGuid = new Guid("56b0ba40 - da78 - e611 - 80cb - 00155da4672c");
Guid CustomFieldGuid = new Guid("3c3dfd8b - da78 - e611 - 80cb - 00155da4672c");
var project = projectContext.Projects.GetByGuid(ProjectGuid);
DraftProject draftProject = project.CheckOut(); //CheckOut Project to make it editable
projectContext.Load(draftProject.Tasks); //Load tasks of Project
projectContext.ExecuteQuery();
var taskToEdit = draftProject.Tasks.First(task => task.Id == TaskGuid);//Get the task to be updated, Here you can also use the property task.Name
var CustomField = projectContext.CustomFields.First(CF => CF.Id == CustomFieldGuid);
var CustomFieldValue = "New Value";
string internalName = CustomField.InternalName.ToString(); //Get internal name of custom field
taskToEdit[internalName] = CustomFieldValue; //Set custom field value
draftProject.Publish(true); //Publish and Check-in the project
projectContext.ExecuteQuery();
}
public DraftProject CheckOutProject(PublishedProject publishedProject)
{
logger.LogAndSendMessage(null, "CheckOutProject",
publishedProject.Id, winServiceIterationUid,
$"CheckOutProject START publishedProject.Id: {publishedProject.Id}",
false, null);
DraftProject draftProject = publishedProject.CheckOut();
try
{
draftProject = GetDraftProject(draftProject, publishedProject.Id);
}
catch (Exception exception)
{
logger.LogAndSendMessage(null, "CheckOutProject",
publishedProject.Id, winServiceIterationUid,
$"CheckOutProject publishedProject.Id: {publishedProject.Id}",
false, exception);
if (draftProject != null)
{
QueueJob job = draftProject.CheckIn(true);
JobState jobState;
WaitForQueue(job, publishedProject.Id, draftProject, out jobState);
draftProject = null;
}
//ExecuteQuery();
}
logger.LogAndSendMessage(null, "CheckOutProject",
publishedProject.Id, winServiceIterationUid,
$"CheckOutProject END publishedProject.Id: {publishedProject.Id}",
false, null);
return(draftProject);
}
internal System.Threading.Tasks.Task PublishAndUpdate(DraftProject draftProject, string projectName)
{
if (draftProject == null)
{
throw new ArgumentNullException(nameof(draftProject));
}
try
{
return(System.Threading.Tasks.Task.Run(() => {
// https://nearbaseline.com/2014/08/ciconotcheckedout-queue-errors-when-updating-projects-via-jsom/
// TODO: Do I need to do update and publish?
var queuedJob = draftProject.Publish(false);
WaitForQueuedJobToComplete(queuedJob, $"publishing a change in a project with name {projectName}");
//queuedJob = _projectContext.Projects.Update();
//WaitForQueuedJobToComplete(queuedJob, $"updating a project with name {projectName}");
}));
}
catch (Exception ex)
{
// TODO: LOG ERROR!
throw new CsomClientException($"Unexcepted error publishing and updating draft project. " +
$"draft project id is {draftProject.Id}. " +
$"Project context url is {_projectContext.Url}.", ex);
}
}
public void TestConstructor()
{
var name = "name";
var description = "description";
var program = new Program
{
ProgramId = 1
};
var user = new User(1);
var draftProject = new DraftProject(
createdBy: user,
name: name,
description: description,
programId: program.ProgramId
);
Assert.AreEqual(name, draftProject.Name);
Assert.AreEqual(description, draftProject.Description);
Assert.AreEqual(program.ProgramId, draftProject.ProgramId);
Assert.AreEqual(ProjectStatus.Draft.Id, draftProject.StatusId);
Assert.IsInstanceOfType(draftProject.Audit, typeof(Create));
var create = draftProject.Audit as Create;
Assert.AreEqual(user.Id, create.User.Id);
DateTimeOffset.UtcNow.Should().BeCloseTo(create.Date, DbContextHelper.DATE_PRECISION);
}
public async Task <DraftProject> CheckOutAsync(PublishedProject publishedProject)
{
if (publishedProject == null)
{
throw new ArgumentNullException(nameof(publishedProject));
}
DraftProject draftProject = null;
try
{
await System.Threading.Tasks.Task.Run(() =>
{
draftProject = publishedProject.CheckOut();
});
}
catch (Exception ex)
{
// TODO: LOG ERROR!
throw new CsomClientException($"Unexcepted error checking out a project. " +
$"project id is {publishedProject.Id}. " +
$"Project context url is {_projectContext.Url}.", ex);
}
return(draftProject);
}
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");
}
public void CheckInDraftProject(DraftProject draft)
{
QueueJob publishJob = draft.Publish(true);
JobState result = projContext.WaitForQueue(publishJob, 3600);
Console.WriteLine("publish job state is {0}", result);
}
public void RenameTasks()
{
DateTime dateTimeControl = new DateTime(2018, 9, 26);
var list = _dbPortal.RenameTasksKBM.ToList();
var projCollection = projContext.LoadQuery(projContext.Projects.Where(d => d.CreatedDate > dateTimeControl));
projContext.ExecuteQuery();
foreach (var prj in projCollection)
{
PublishedProject project = prj;
DraftProject draft = project.CheckOut();
projContext.Load(draft, p => p.Tasks);
projContext.ExecuteQuery();
if (draft.Tasks.Count > 0)
{
foreach (var task in draft.Tasks.ToList())
{
foreach (var baseTask in list)
{
if (baseTask.@base == task.Name)
{
task.Name = baseTask.@this;
}
}
}
}
draft.Update();
Console.WriteLine(prj.Name);
JobState jobState = projContext.WaitForQueue(draft.Publish(true), 20);
}
}
public JobState CheckInProjectForce(DraftProject draft)
{
//CheckIn
QueueJob publishJob = draft.CheckIn(true);
JobState result = projContext.WaitForQueue(publishJob, 3600);
return(result);
}
public bool WaitForQueue(QueueJob job, Guid projectUid, DraftProject draftProject, out JobState jobState)
{
logger.LogAndSendMessage(null, "WaitForQueue",
projectUid, winServiceIterationUid,
$"WaitForQueue {projectUid}",
false, null);
jobState = ProjectContext.WaitForQueue(job, WaitForQueueTimeout);
return(jobState == JobState.Success);
}
public bool Create(ProjectModel model)
{
if (model == null)
{
throw new ArgumentException("The ProjectModel is null.");
}
else
{
IEnumerable <PublishedProject> projects = GetEntities();
this.availableResources = new ResourceCSOMClient().GetEntities();
for (int i = 0; i < model.Count; i++)
{
string projectName = model.NamePrefix + i.ToString();
if (projects.Any(item => item.Name == projectName))
{
// No need to do anything currently
}
else
{
try
{
// Create an empty project
PublishedProject project = CreateEmptyProject(projectName);
// Check out the project
DraftProject draftProject = CheckOutProject(project);
// Get resource for project
List <EnterpriseResource> projectResources = new List <EnterpriseResource>();
int[] resourcesIndex = RandomHelper.GetRandomIndex(model.ProjectTeamCount, this.availableResources.Count() - 1);
foreach (int index in resourcesIndex)
{
projectResources.Add(this.availableResources.ElementAt(index));
}
// Build team
BuildTeam(draftProject, projectResources);
// Create task
IEnumerable <IEnumerable <TaskCreationInformation> > tasks = CreateTask(model.TaskModel);
// Add task
AddTaskToProject(draftProject, tasks, projectResources, model.TaskModel.Assignments);
// Publish
PublishProject(draftProject);
}
catch (Exception ex)
{
LoggerHelper.Instance.Fail(string.Format("Filed to create Project: {0}.\nMessage: {1}. \nMore:{2} \nRetrying...", projectName, ex.Message, ex.StackTrace));
}
}
}
}
return(true);
}
public DraftProject CheckOutProject(PublishedProject publishedProject, string systemNames, Guid projectUid)
{
DraftProject draftProject = null;
try
{
if (publishedProject.IsCheckedOut)
{
if (isOnline)
{
if (publishedProject.IsCheckedOut && publishedProject.CheckedOutBy?.Email != null)
{
EmailSender emailSender = new EmailSender();
emailSender.SendNotificationEmail(publishedProject.CheckedOutBy.Email,
$"Check-in project {publishedProject.Name} request",
$"Hello, {publishedProject.CheckedOutBy.Title}. This is 60i Administrator. I've found that several tasks in project {publishedProject.Name} should be synchronized with {systemNames}. " +
"Howerver I need to change some properties of these tasks, but project is checked-out to you. Please check-in it for a little time so I can do neccessary operations.");
return(null);
}
}
return(null);
}
draftProject = CheckOutProject(publishedProject);
return(draftProject);
}
//catch (PropertyOrFieldNotInitializedException exception)
//{
// logger.LogAndSendMessage($"CheckOutProject ProjectUid: {projectUid}");
// logger.LogAndSendMessage(exception);
// if (draftProject != null)
// {
// logger.LogAndSendMessage("ForceCheckInProject");
// QueueJob job = draftProject.CheckIn(true);
// WaitForQueue(job, projectUid, draftProject);
// //ExecuteQuery();
// }
//}
catch (Exception exception)
{
logger.LogAndSendMessage(null, "CheckOutProject",
projectUid, winServiceIterationUid,
$"CheckOutProject ProjectUid: {projectUid}",
false, exception);
if (draftProject != null)
{
logger.LogAndSendMessage(null, "ForceCheckInProject",
projectUid, winServiceIterationUid,
$"ForceCheckInProject {draftProject.Id}",
false, null);
QueueJob job = draftProject.CheckIn(true);
JobState jobState;
WaitForQueue(job, projectUid, draftProject, out jobState);
}
}
return(null);
}
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 void PublishProject(DraftProject draftProject, List <StagingDTO> affectedStagings)
{
if (draftProject == null)
{
return;
}
JobState state = JobState.Unknown;
logger.LogAndSendMessage(null, "PublishProject",
draftProject.Id, winServiceIterationUid,
$"PublishProject START projectGuid: {draftProject.Id}",
false, null, CommonConstants.Epm, CommonConstants.Start);
try
{
QueueJob job = draftProject.Publish(false);
WaitForQueue(job, draftProject.Id, draftProject, out state);
logger.LogAndSendMessage(null, "PublishProject Publish WaitForQueue",
draftProject.Id, winServiceIterationUid,
$"PublishProject Publish WaitForQueue {draftProject.Id}",
false, null);
if (state == JobState.Success)
{
if (affectedStagings != null)
{
foreach (StagingDTO affectedStaging in affectedStagings)
{
affectedStaging.RecordStateGeneral = RecordStateConst.Published;
}
}
}
else
{
logger.LogAndSendMessage(null, "PublishProject Publish WaitForQueue",
draftProject.Id, winServiceIterationUid,
$"PublishProject Publish WaitForQueue job failed. Project UID: {draftProject.Id}; jobState: {state}",
true, null);
}
}
catch (Exception exception)
{
logger.LogAndSendMessage(null, "PublishProject",
draftProject.Id, winServiceIterationUid,
$"PublishProject {draftProject.Id} JobState: {state}",
false, exception);
}
logger.LogAndSendMessage(null, "PublishProject",
draftProject.Id, winServiceIterationUid,
$"PublishProject END projectGuid: {draftProject.Id}",
false, null, CommonConstants.Epm, CommonConstants.End);
}
public void UpdateCriticalDateClose()
{
NetworkCredential cred = new NetworkCredential();
cred.Domain = "KATEK";
cred.UserName = "******";
cred.Password = "******";
projContext.Credentials = cred;
projContext.Load(projContext.Projects);
projContext.Load(projContext.CustomFields);
projContext.ExecuteQuery();
foreach (var pubProj in projContext.Projects)
{
int planZakazNumber = 0;
try
{
planZakazNumber = Convert.ToInt32(pubProj.Name.Substring(0, 4));
}
catch
{
}
if (planZakazNumber != 0 && planZakazNumber > 1734)
{
try
{
Console.WriteLine("Update: {0}", planZakazNumber);
PZ_PlanZakaz pZ_PlanZakaz = _dbPortal.PZ_PlanZakaz.First(d => d.PlanZakaz == planZakazNumber);
if (pZ_PlanZakaz.dataOtgruzkiBP > DateTime.Now)
{
DateTime criticalDateClose = _dbPortal.PZ_PlanZakaz.First(d => d.PlanZakaz == planZakazNumber).DateSupply;
DraftProject projectDraft = pubProj.CheckOut();
projContext.Load(projectDraft);
projContext.Load(projectDraft.CustomFields);
projContext.ExecuteQuery();
CustomField cField = projContext.CustomFields.First(c => c.Name == "CriticalDateClose");
projectDraft[cField.InternalName] = criticalDateClose;
projectDraft.Update();
QueueJob job = projectDraft.Update();
job = projectDraft.Publish(true);
projContext.ExecuteQuery();
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
}
}
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 int CreateTasksInProject(IGrouping <Guid, ProjectServer_CreateTasks> data)
{
try
{
using (ProjectContext projectCont1 = new ProjectContext(PwaPath))
{
string nameProject = _db.PWA_EmpProject.First(d => d.ProjectUID == data.Key).ProjectName;
var projCollection = projectCont1.LoadQuery(projectCont1.Projects.Where(p => p.Name == nameProject));
projectCont1.ExecuteQuery();
PublishedProject proj2Edit = projCollection.First();
DraftProject projCheckedOut = proj2Edit.CheckOut();
foreach (var taskInList in _db.ProjectServer_CreateTasks.Where(d => d.ProjectUID == data.Key).ToList())
{
Guid taskId = Guid.NewGuid();
Task task = projCheckedOut.Tasks.Add(new TaskCreationInformation()
{
Id = taskId,
Name = taskInList.TaskName,
Notes = "new Task",
IsManual = false,
Duration = "1d",
Start = DateTime.Now
});
projCheckedOut.Update();
// Create a local resource and assign the task to him
projCheckedOut.Update();
Guid resourceGuid =
(Guid)_db.AspNetUsers.First(d => d.Email == taskInList.Resource).ResourceUID;
DraftAssignment assignment = projCheckedOut.Assignments.Add(new AssignmentCreationInformation()
{
ResourceId = resourceGuid,
TaskId = taskId
});
projCheckedOut.Update();
}
projCheckedOut.Publish(true);
QueueJob qJob = projectCont1.Projects.Update();
JobState jobState = projectCont1.WaitForQueue(qJob, 20);
}
return(1);
}
catch
{
return(0);
}
}
public void CheckInProject(DraftProject draftProject, Guid projectGuid)
{
if (draftProject == null)
{
return;
}
QueueJob job;
JobState jobState;
logger.LogAndSendMessage(null, "CheckInProject",
projectGuid, winServiceIterationUid,
$"CheckInProject START projectGuid: {projectGuid}",
false, null, CommonConstants.Epm, CommonConstants.Start);
try
{
logger.LogAndSendMessage(null, "CheckInProject CheckIn",
projectGuid, winServiceIterationUid,
$"CheckInProject CheckIn projectGuid: {projectGuid}",
false, null);
job = draftProject.CheckIn(false);
if (!WaitForQueue(job, draftProject.Id, draftProject, out jobState))
{
logger.LogAndSendMessage(null, "CheckInProject CheckIn WaitForQueue",
projectGuid, winServiceIterationUid,
$"CheckInProject CheckIn WaitForQueue job failed. Project UID: {projectGuid}; " +
$"jobState: {jobState}",
true, null);
}
}
catch (Exception exception)
{
logger.LogAndSendMessage(null, "CheckInProject",
projectGuid, winServiceIterationUid,
$"CheckInProject Exception {projectGuid}",
false, exception);
logger.LogAndSendMessage(null, "ForceCheckInProject",
projectGuid, winServiceIterationUid,
$"ForceCheckInProject projectGuid: {projectGuid}",
false, null);
job = draftProject.CheckIn(true);
WaitForQueue(job, draftProject.Id, draftProject, out jobState);
}
logger.LogAndSendMessage(null, "CheckInProject",
projectGuid, winServiceIterationUid,
$"CheckInProject END projectGuid: {projectGuid}",
false, null, CommonConstants.Epm, CommonConstants.End);
}
private int ReadAndUpdateProject()
{
try
{
var tasksList = _db.ProjectServer_UpdateMustStartOn.ToList();
if (tasksList.Count > 0)
{
try
{
foreach (var dataList in tasksList)
{
ProjectContext context = new ProjectContext(PwaPath);
string nameProject = _db.PWA_EmpProject.First(d => d.ProjectUID == dataList.ProjectUID).ProjectName;
var projCollection = context.LoadQuery(context.Projects.Where(p => p.Name == nameProject));
context.ExecuteQuery();
PublishedProject project = projCollection.First();
DraftProject draft = project.CheckOut();
context.Load(draft, p => p.StartDate,
p => p.Description);
string taskName = _db.PWA_EmpTaskAll.First(d => d.TaskUID == dataList.TaskUID).TaskName;
context.Load(draft.Tasks, dt => dt.Where(t => t.Name == taskName));
context.Load(draft.Assignments, da => da.Where(a => a.Task.Name == taskName));
context.ExecuteQuery();
DraftTask task = draft.Tasks.First();
task.ConstraintType = ConstraintType.MustStartOn;
task.ConstraintStartEnd = dataList.ActualStart;
draft.Update();
JobState jobState = context.WaitForQueue(draft.Publish(true), 20);
}
return(1);
}
catch
{
return(0);
}
}
else
{
return(0);
}
}
catch
{
return(0);
}
}
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 JobState PublishAndCheckInProject(DraftProject draft)
{
QueueJob publishJob = null;
JobState result = JobState.Failed;
// Update
publishJob = draft.Update();
result = projContext.WaitForQueue(publishJob, 3600);
// Publish
publishJob = draft.Publish(true);
result = projContext.WaitForQueue(publishJob, 3600);
; result = this.CheckInProjectForce(draft);
Console.WriteLine("publish job state is {0}", result);
return(result);
}
/// <sumary>
/// Funcion que permite actualizar las tareas en Project Server
/// </summary>
/// <param gui="String">Identificar Grafico Unico de proyecto de Project Server </param>
/// <param fi="Date"> Fecha Inicial de Tarea</param>
/// <param ff="Date"> Fecha Final de Tarea</param>
/// <param porcent="Int"> Valor numerico de porcentaje de progreso de la tarea</param>
private void UddateTask(string gui, string fi, string ff, int porcent)
{
using (ProjectCont1)
{
Guid ProjectGuid = new Guid(gui);
var projCollection = ProjectCont1.LoadQuery(
ProjectCont1.Projects
.Where(p => p.Id == ProjectGuid));
ProjectCont1.ExecuteQuery();
if (projCollection != null)
{
csom.PublishedProject proj2Edit = projCollection.First();
DraftProject draft2Edit = proj2Edit.CheckOut();
ProjectCont1.Load(draft2Edit);
ProjectCont1.Load(draft2Edit.Tasks);
ProjectCont1.ExecuteQuery();
var tareas = draft2Edit.Tasks;
foreach (DraftTask tsk in tareas)
{
tsk.Start = Convert.ToDateTime(fi);
tsk.Finish = Convert.ToDateTime(ff);
tsk.PercentComplete = porcent;
}
draft2Edit.Publish(true);
csom.QueueJob qJob = ProjectCont1.Projects.Update();
csom.JobState jobState = ProjectCont1.WaitForQueue(qJob, 200);
qJob = ProjectCont1.Projects.Update();
jobState = ProjectCont1.WaitForQueue(qJob, 20);
if (jobState == JobState.Success)
{
coleccion_vacia = false;
}
}
else
{
coleccion_vacia = true;
}
}
}
public void UpdateTasksInProject()
{
ProjectContext projContext = new ProjectContext("http://tpserver/pwa/");
var projCollection = projContext.LoadQuery(projContext.Projects.Where(p => p.Name == "Test"));
projContext.ExecuteQuery();
foreach (PublishedProject pubProj in projCollection)
{
DraftProject projCheckedOut = pubProj.CheckOut();
TaskCreationInformation newTask = new TaskCreationInformation();
newTask.Name = "Тестовая задача Андрея";
newTask.IsManual = false;
newTask.Duration = "3d";
newTask.Start = DateTime.Today;
projCheckedOut.Tasks.Add(newTask);
projCheckedOut.StartDate = DateTime.Now.AddYears(1);
projCheckedOut.Publish(true);
QueueJob qJob = projContext.Projects.Update();
JobState jobState = projContext.WaitForQueue(qJob, 10);
}
}
public DraftProject GetDraftProject(PublishedProject published)
{
DraftProject draft = null;
try
{
if (published.Draft.IsCheckedOut)
{
return(draft);
}
draft = published.CheckOut();
}
catch (Exception)
{
projContext.Load(published, P1 => P1.Draft);
projContext.ExecuteQuery();
return(GetDraftProject(published));
}
projContext.Load(draft);
projContext.ExecuteQuery();
return(draft);
}
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));
}
public DraftProject GetDraftProject(DraftProject draftProject, Guid projectUid)
{
logger.LogAndSendMessage(null, "GetDraftProject",
projectUid, winServiceIterationUid,
$"GetDraftProject START projectUid: {projectUid}",
false, null, CommonConstants.Epm, CommonConstants.Start);
ProjectContext.Load(draftProject);
ProjectContext.Load(draftProject.Tasks);
//ProjectContext.Load(draftProject.Assignments);
//ProjectContext.Load(draftProject.Assignments,
// a => a.IncludeWithDefaultProperties(assignment => assignment.Owner));
ProjectContext.Load(draftProject.ProjectResources);
ProjectContext.Load(draftProject.Tasks,
c => c.IncludeWithDefaultProperties(t => t.Assignments,
t => t.Assignments.IncludeWithDefaultProperties(a => a.Resource)));
//ProjectContext.Load(draftProject.Tasks,
// c => c.IncludeWithDefaultProperties(t => t.Assignments));
ExecuteQuery();
logger.LogAndSendMessage(null, "GetDraftProject",
draftProject.Id, winServiceIterationUid,
$"GetDraftProject END draftProject.Id: {draftProject.Id}",
false, null, CommonConstants.Epm, CommonConstants.End);
return(draftProject);
}
private int UpdateTasksInProject(IGrouping <Guid, ProjectServer_UpdateTasks> data)
{
try
{
using (ProjectContext projectCont1 = new ProjectContext(PwaPath))
{
string nameProject = _db.PWA_EmpProject.First(d => d.ProjectUID == data.Key).ProjectName;
var projCollection = projectCont1.LoadQuery(projectCont1.Projects.Where(p => p.Name == nameProject));
projectCont1.ExecuteQuery();
PublishedProject proj2Edit = projCollection.First();
DraftProject projCheckedOut = proj2Edit.CheckOut();
projectCont1.Load(projCheckedOut.Tasks);
projectCont1.ExecuteQuery();
DraftTaskCollection catskill = projCheckedOut.Tasks;
foreach (DraftTask task in catskill)
{
try
{
if (task.Name != null && task.Id == _db.ProjectServer_UpdateTasks.First(d => d.taskUID == task.Id).taskUID)
{
ProjectServer_UpdateTasks projectServer_UpdateTasks = _db.ProjectServer_UpdateTasks.First(d => d.taskUID == task.Id);
var nk = projectServer_UpdateTasks.nk;
if (nk != null)
{
int time = (int)nk;
projectCont1.Load(task.CustomFields);
projectCont1.ExecuteQuery();
foreach (CustomField cus in task.CustomFields)
{
if (cus.Name == "НК")
{
string intname = cus.InternalName;
task[intname] = time;
}
}
if (task.PercentComplete == 0)
{
task.Work = time + "ч";
}
else
{
int factWork = Convert.ToInt32(task.Work.Substring(0, task.Work.Length - 1)) - Convert.ToInt32(task.RemainingWork.Substring(0, task.RemainingWork.Length - 1));
if (factWork < time)
{
task.Work = time - factWork + "ч";
}
}
QueueJob qJob1 = projCheckedOut.Update();
JobState jobState1 = projectCont1.WaitForQueue(qJob1, 10);
}
else
{
ProjectServer_UpdateTasks pTask = _db.ProjectServer_UpdateTasks.First(d => d.taskUID == task.Id);
if (pTask.percentComplited != null)
{
task.PercentComplete = (int)pTask.percentComplited;
}
if (pTask.finishDate != null)
{
task.Finish = (DateTime)pTask.finishDate;
}
if (task.IsMilestone == true)
{
task.Start = (DateTime)pTask.finishDate;
}
QueueJob qJob1 = projCheckedOut.Update();
JobState jobState1 = projectCont1.WaitForQueue(qJob1, 10);
}
}
}
catch
{
}
}
projCheckedOut.Publish(true);
QueueJob qJob = projectCont1.Projects.Update();
JobState jobState = projectCont1.WaitForQueue(qJob, 20);
}
return(1);
}
catch
{
return(0);
}
}
private void Modify()
{
string g = "";
using (ProjectCont1)
{
ProjectCont1.Load(ProjectCont1.Projects, c => c.IncludeWithDefaultProperties(pr => pr.CustomFields,
prop => prop.IncludeCustomFields, pr => pr.IncludeCustomFields.CustomFields));
ProjectCont1.ExecuteQuery();
foreach (PublishedProject item in ProjectCont1.Projects)
{
if (item.Name == "PROYECTO TEST MOISES")
{
foreach (var customfield in item.IncludeCustomFields.FieldValues)
{
string k = customfield.Key;
if (k == "Custom_b18d6d025dcee911b08f00155db46231")
{
var lookup = ProjectCont1.LoadQuery(ProjectCont1.LookupTables.Where(x => x.Name == "Lineas de Acción"));
ProjectCont1.ExecuteQuery();
string lookuptypeCustomFieldValue = string.Empty;
DraftProject draft2Edit = item.CheckOut();
var projECFs = item.IncludeCustomFields.CustomFields;
foreach (CustomField cf in projECFs)
{
if (k == cf.InternalName.ToString())
{
draft2Edit.SetCustomFieldValue(cf.InternalName, "Entry_b3eae594becde911b08000155db84c31");
}
}
var publishJob = draft2Edit.Publish(true);
foreach (LookupTable tb in lookup)
{
ProjectCont1.Load(tb.Entries);
ProjectCont1.ExecuteQuery();
foreach (LookupEntry en in tb.Entries)
{
for (int i = 0; i < ((string[])(customfield.Value)).Count(); i++)
{
string cmp = ((string[])(customfield.Value))[i].ToString();
string ent = en.Id.ToString().Replace("-", "");
if (cmp != "Entry_" + ent)
{
lookuptypeCustomFieldValue = en.FullValue;
escribir_log(lookuptypeCustomFieldValue + "," + cmp + "," + ent, "," + cmp + "," + ent);
}
}
}
}
}
}
}
}
}
}
