Partager via


Statusing.SetAssignmentWorkData - Méthode

Définit les durées de travail restant, total et réel d'une affectation.

Espace de noms :  WebSvcStatusing
Assembly :  ProjectServerServices (dans ProjectServerServices.dll)

Syntaxe

'Déclaration
<SoapDocumentMethodAttribute("https://schemas.microsoft.com/office/project/server/webservices/Statusing/SetAssignmentWorkData", RequestNamespace := "https://schemas.microsoft.com/office/project/server/webservices/Statusing/",  _
    ResponseNamespace := "https://schemas.microsoft.com/office/project/server/webservices/Statusing/",  _
    Use := SoapBindingUse.Literal, ParameterStyle := SoapParameterStyle.Wrapped)> _
Public Function SetAssignmentWorkData ( _
    changeXML As String _
) As Integer
'Utilisation
Dim instance As Statusing
Dim changeXML As String
Dim returnValue As Integer

returnValue = instance.SetAssignmentWorkData(changeXML)
[SoapDocumentMethodAttribute("https://schemas.microsoft.com/office/project/server/webservices/Statusing/SetAssignmentWorkData", RequestNamespace = "https://schemas.microsoft.com/office/project/server/webservices/Statusing/", 
    ResponseNamespace = "https://schemas.microsoft.com/office/project/server/webservices/Statusing/", 
    Use = SoapBindingUse.Literal, ParameterStyle = SoapParameterStyle.Wrapped)]
public int SetAssignmentWorkData(
    string changeXML
)

Paramètres

  • changeXML
    Type : System.String

    Chaîne XML définissant les modifications.

Valeur renvoyée

Type : System.Int32

Remarques

SetAssignmentWorkData is designed to be used from the Microsoft Office Outlook 2007 add-in for Project. The XML string in the changeXML parameter must conform to the structure defined by the SetAssignmentWorkData.xsd schema. For more information, see the SetAssignmentWorkData Schema Reference.

Notes

Si vous utilisez SetAssignmentWorkData pour modifier la durée d'une tâche, envoyer la mise à jour au responsable de projet. Lorsque le chef de projet approuve la mise à jour, la modification est enregistrée uniquement dans la base de données provisoire. Le composant WebPart Centre de projets dans Project Web App n'affiche pas la durée modifiée jusqu'à ce que le projet est publié.

Autorisations Project Server

Autorisation

Description

LogOn

Autorise l'utilisateur à se connecter au serveur. Autorisation globale.

Exemples

L'exemple de code suivant crée un exemple de projet avec l'utilisateur actuel en tant que disponible ressource affectée à une tâche. Il génère une chaîne changeXML spécification d'une mise à jour à l'état de l'affectation, puis appelle la méthode SetAssignmentWorkData pour valider les mises à jour.

For critical information about running this code example, see Prerequisites for ASMX-Based Code Samples.

using System;
using System.Collections.Generic;
using System.Text;
using System.Net;
using System.Data;
using System.Web.Services.Protocols;
using System.Threading;
using PSLibrary = Microsoft.Office.Project.Server.Library;

namespace Microsoft.SDK.Project.Samples.SetAssignmentWorkData
{
    class Program
    {
        [STAThread]
        static void Main()
        {
            try
            {
                #region Setup
                const string PROJECT_SERVER_URI = "http://devdocpj12/pwa/"; // <<--Change to match your project server and directory
                const string STATUSING_SERVICE_PATH = "_vti_bin/psi/statusing.asmx";
                const string PROJECT_SERVICE_PATH = "_vti_bin/psi/project.asmx";
                const string RESOURCE_SERVICE_PATH = "_vti_bin/psi/resource.asmx";
                const string QUEUESYSTEM_SERVICE_PATH = "_vti_bin/psi/queuesystem.asmx";


                // Set up the services.
                SvcStatusing.Statusing statusingSvc = new SvcStatusing.Statusing();
                statusingSvc.UseDefaultCredentials = true;
                statusingSvc.Url = PROJECT_SERVER_URI + STATUSING_SERVICE_PATH;

                SvcProject.Project projectSvc = new SvcProject.Project();
                projectSvc.Url = PROJECT_SERVER_URI + PROJECT_SERVICE_PATH;
                projectSvc.UseDefaultCredentials = true;

                SvcResource.Resource resourceSvc = new SvcResource.Resource();
                resourceSvc.Url = PROJECT_SERVER_URI + RESOURCE_SERVICE_PATH;
                resourceSvc.UseDefaultCredentials = true;

                SvcQueueSystem.QueueSystem q = new SvcQueueSystem.QueueSystem();
                q.Url = PROJECT_SERVER_URI + QUEUESYSTEM_SERVICE_PATH;
                q.UseDefaultCredentials = true;

                Guid myUid = resourceSvc.GetCurrentUserUid();
                SvcStatusing.StatusingDataSet statusingDs;


                //Create sample project.
                Console.WriteLine("Creating the project");
                Guid projectUid = CodeSampleUtilities.CreateSampleProject(projectSvc, q, resourceSvc);
                
                // Read project back in.
                SvcProject.ProjectDataSet projectDs = projectSvc.ReadProject(projectUid, SvcProject.DataStoreEnum.PublishedStore);
                Guid assn = Guid.Empty;

                // Get assignment for current user.
                for (int i = 0; i < projectDs.Assignment.Count; i++)
                {
                    if (projectDs.Assignment[i].RES_UID == myUid)
                    {
                        assn = projectDs.Assignment[i].ASSN_UID;
                        break;
                    }
                }

                if (assn == Guid.Empty)
                {
                    throw (new ApplicationException("No assignments were found for the current user"));
                }


                //Display on console so we can see references.
                Console.ForegroundColor = ConsoleColor.DarkYellow;
                Console.WriteLine("".PadRight(Console.BufferWidth, '='));
                Console.ResetColor();

                Console.WriteLine("Before: ");
                CodeSampleUtilities.WriteTablesToConsole(projectDs.Tables);
                Console.ForegroundColor = ConsoleColor.DarkYellow;
                Console.WriteLine("".PadRight(Console.BufferWidth, '='));
                Console.ResetColor();
                #endregion

                #region Create updates to assignments
                //Create ChangeXML.
                StringBuilder changeXml = new StringBuilder();
                changeXml.AppendFormat("<Changes><Proj ID=\"{0}\">", projectUid.ToString());
                changeXml.AppendFormat("<Assn ID=\"{0}\">", assn.ToString());
                changeXml.AppendFormat("<Change><ActualWork>{0}</ActualWork>", 60 * 1000 * 8); //8 hours
                changeXml.AppendFormat("<RemainingWork>{0}</RemainingWork>", 60 * 1000 * 24); //16 hours
                changeXml.AppendFormat("<TotalWork>{0}</TotalWork>", 60 * 1000 * 24); //24 hours
                changeXml.AppendFormat("<Comments>{0}</Comments>", "I started this early because I didn't have enough to do"); //comments are added to the Task Note
                changeXml.AppendFormat("<Status>{0}</Status>", "Early");
                changeXml.AppendFormat("<StatusGuid>{0}</StatusGuid>", "00001441-3cf6-4710-b877-2e17914fa97c");              
                changeXml.Append("</Change></Assn></Proj></Changes>");
                Console.WriteLine("Updating Status");
                #endregion

                #region Update Status
                statusingSvc.SetAssignmentWorkData(changeXml.ToString());
                #endregion

                #region Display Results
                // Read the new assignment status.
                statusingDs = statusingSvc.ReadStatus(assn, DateTime.MinValue, DateTime.MaxValue);
                Console.ForegroundColor = ConsoleColor.DarkYellow;
                Console.WriteLine("".PadRight(Console.BufferWidth, '='));
                Console.ResetColor();

                CodeSampleUtilities.WriteTablesToConsole(statusingDs.Tables);

                Console.ForegroundColor = ConsoleColor.DarkYellow;
                Console.WriteLine("".PadRight(Console.BufferWidth, '='));
                Console.ResetColor();
                #endregion
                #region Submit assignment updates
                statusingSvc.SubmitStatus(new Guid[] { assn }, "Assignment work data update from code");

                Console.WriteLine("Updates to assignments are processed and submitted for approval.");
                #endregion
            }
            catch (SoapException ex)
            {
                ExceptionHandlers.HandleSoapException(ex);
            }
            catch (WebException ex)
            {
                ExceptionHandlers.HandleWebException(ex);
            }
            catch (Exception ex)
            {
                ExceptionHandlers.HandleException(ex);
            }
            finally
            {
                ExceptionHandlers.ResetConsole();
            }
        }
    }

    class ExceptionHandlers
    {

        public static void HandleSoapException(SoapException ex)
        {
            PSLibrary.PSClientError error = new PSLibrary.PSClientError(ex);
            PSLibrary.PSErrorInfo[] errors = error.GetAllErrors();
            string errMess = "==============================\r\nError: \r\n";
            for (int i = 0; i < errors.Length; i++)
            {
                errMess += "\n" + ex.Message.ToString() + "\r\n";
                errMess += "".PadRight(30, '=') + "\r\nPSCLientError Output:\r\n \r\n";
                errMess += errors[i].ErrId.ToString() + "\n";

                for (int j = 0; j < errors[i].ErrorAttributes.Length; j++)
                {
                    errMess += "\r\n\t" + errors[i].ErrorAttributeNames()[j] + ": "
                       + errors[i].ErrorAttributes[j];
                }
                errMess += "\r\n".PadRight(30, '=');
            }
            Console.ForegroundColor = ConsoleColor.Red;
            Console.WriteLine(errMess);
        }

        public static void HandleWebException(WebException ex)
        {
            string errMess = ex.Message.ToString() +
               "\n\nLog on, or check the Project Server Queuing Service";
            Console.ForegroundColor = ConsoleColor.Red;
            Console.WriteLine("Error: " + errMess);
        }

        public static void HandleException(Exception ex)
        {
            Console.ForegroundColor = ConsoleColor.Red;
            Console.WriteLine("Error: " + ex.Message);
        }

        public static void ResetConsole()
        {
            Console.ResetColor();
            Console.WriteLine("\r\n\r\nPress any key...");
            Console.ReadKey();
        }
    }
    class CodeSampleUtilities
    {
        // Write all contents of a table collection to the console.
        public static void WriteTablesToConsole(System.Data.DataTableCollection theTables)
        {
            Console.ForegroundColor = ConsoleColor.DarkGreen;
            foreach (System.Data.DataTable table in theTables)
            {

                int[] columnWidths = new int[table.Columns.Count];
                int tableWidth = 0;
                string dataString;
                Console.WriteLine("Table: " + table.TableName);

                // Write out the column names and get their spacing.
                StringBuilder tableRow = new StringBuilder();
                for (int i = 0; i < table.Columns.Count; i++)
                {
                    columnWidths[i] = GetColumnWidth(table.Columns[i]);
                    tableRow.Append(table.Columns[i].ColumnName.PadRight(columnWidths[i]));

                    tableWidth += columnWidths[i];
                }
                // Add a space so it will not wrap.
                tableWidth += 1;
                // Make the console as wide as the widest table.
                Console.BufferWidth = (Console.BufferWidth > tableWidth ? Console.BufferWidth : tableWidth);
                tableRow.Append("\r\n");
                Console.Write(tableRow.ToString());

                // Write out the data.
                foreach (DataRow row in table.Rows)
                {
                    tableRow = new StringBuilder();
                    for (int i = 0; i < table.Columns.Count; i++)
                    {

                        dataString = row[i].ToString();
                        // Truncate output if it is wider than 
                        // the desired column width.
                        if (dataString.Length >= columnWidths[i])
                        {
                            dataString = dataString.Substring(0, columnWidths[i] - 1);
                        }
                        // Add the output to the stringbuilder and pad right to fill
                        // up to the column width.
                        tableRow.Append(dataString.PadRight(columnWidths[i]));
                    }
                    tableRow.Append("\r\n");
                    Console.Write(tableRow.ToString());
                }
                Console.Write("\r\n".PadLeft(tableWidth, '-'));
            }
            Console.ResetColor();
        }
        // Helper function for WriteTablesToConsole.
        private static int GetColumnWidth(DataColumn column)
        {
            // Note: Might not handle byte[]data types well.
            const int MAX_COL_WIDTH = 40;
            int dataWidth = 0;

            //Return 12 for numbers, 30 for dates, and string width for strings.
            switch (column.DataType.UnderlyingSystemType.ToString())
            {
                case "System.Boolean":
                case "System.Byte":
                case "System.Byte[]":
                case "System.Char":
                case "System.Decimal":
                case "System.Double":
                case "System.Int16":
                case "System.Int32":
                case "System.Int64":
                case "System.SByte":
                case "System.Single":
                case "System.UInt16":
                case "System.UInt32":
                case "System.UInt64":
                    dataWidth = 12;
                    break;
                case "System.DateTime":
                case "System.TimeSpan":
                    dataWidth = 30;
                    break;
                case "System.Guid":
                    dataWidth = 37;
                    break;
                case "System.String":
                    // If it has a maxlength, use it.
                    if (column.MaxLength > 0)
                    {
                        dataWidth = column.MaxLength;
                    }
                    else
                    {
                        // Otherwise, use the max col width.
                        dataWidth = MAX_COL_WIDTH;
                    }
                    break;
                default:
                    dataWidth = column.ColumnName.Length;
                    break;
            }
            // Truncate if over the maxlength.
            if (dataWidth > MAX_COL_WIDTH)
            {
                dataWidth = MAX_COL_WIDTH;
            }
            // Always be at least as wide as the colum name.
            return (column.ColumnName.Length > (dataWidth) ? column.ColumnName.Length + 1 : dataWidth);
        }
        // Wait for the job to finish.
        // Outputs job status to the console.
        static public void WaitForQueue(SvcQueueSystem.QueueSystem q, Guid jobId)
        {
            SvcQueueSystem.JobState jobState;
            const int QUEUE_WAIT_TIME = 1; // one second
            bool jobDone = false;
            string xmlError = string.Empty;
            int wait = 0;

            //Wait for the project to get through the queue.
            // - Get the estimated wait time in seconds.
            wait = q.GetJobWaitTime(jobId);

            // - Wait for it.
            Console.Write("Waiting on queue. Estimate: {0} seconds.\r\n ", wait);

            // - Wait until it is done.

            do
            {
                // - Get the job state.
                jobState = q.GetJobCompletionState(jobId, out xmlError);

                if (jobState == SvcQueueSystem.JobState.Success)
                {
                    jobDone = true;
                }
                else
                {
                    if (jobState == SvcQueueSystem.JobState.Unknown
                    || jobState == SvcQueueSystem.JobState.Failed
                    || jobState == SvcQueueSystem.JobState.FailedNotBlocking
                    || jobState == SvcQueueSystem.JobState.CorrelationBlocked
                    || jobState == SvcQueueSystem.JobState.Canceled)
                    {
                        // If the job failed, error out.
                        throw (new ApplicationException("Queue request " + jobState + " for Job ID " + jobId + ".\r\n" + xmlError));
                    }
                    else
                    {
                        //Console.WriteLine("Job State: " + jobState + " for Job ID: " + jobId);
                        Console.Write("~");
                        Thread.Sleep(QUEUE_WAIT_TIME * 1000);
                    }
                }
            }
            while (!jobDone);
            Console.Write("\r\n");

        }

        static public Guid CreateSampleProject(SvcProject.Project projectSvc, SvcQueueSystem.QueueSystem q, SvcResource.Resource resourceSvc)
        {
            SvcProject.ProjectDataSet projectDs = new SvcProject.ProjectDataSet();
            Guid jobId;
            Guid sessionUid = Guid.NewGuid();
            const string SESSION_DESC = "Test Utility";

            // Create the project.
            SvcProject.ProjectDataSet.ProjectRow projectRow = projectDs.Project.NewProjectRow();
            Guid projectId = Guid.NewGuid();
            projectRow.PROJ_UID = projectId;
            projectRow.PROJ_NAME = "Its a wonderful None project at " + DateTime.Now.ToShortDateString().Replace("/", "") + " " + DateTime.Now.ToShortTimeString().Replace(":", "") + " " + DateTime.Now.Millisecond.ToString();
            projectRow.PROJ_TYPE = (int)PSLibrary.Project.ProjectType.Project;
            projectDs.Project.AddProjectRow(projectRow);

            // Add some tasks.
            SvcProject.ProjectDataSet.TaskRow taskOne = projectDs.Task.NewTaskRow();
            taskOne.PROJ_UID = projectId;
            taskOne.TASK_UID = Guid.NewGuid();
            taskOne.TASK_NAME = "Task One";
            taskOne.TASK_DUR_FMT = (int)PSLibrary.Task.DurationFormat.Hour;
            taskOne.TASK_DUR = 10 * 60 * 8 * 3;//Three eight hour days
            taskOne.TASK_START_DATE = System.DateTime.Now.AddDays(1);
            projectDs.Task.AddTaskRow(taskOne);

            SvcProject.ProjectDataSet.TaskRow taskTwo = projectDs.Task.NewTaskRow();
            taskTwo.PROJ_UID = projectId;
            taskTwo.TASK_UID = Guid.NewGuid();
            taskTwo.TASK_NAME = "Task Two";
            taskTwo.TASK_DUR = 10 * 60 * 6;// 6 hours
            taskTwo.TASK_DUR_FMT = (int)PSLibrary.Task.DurationFormat.EHour; // Duration Estimate and shoudl be displayed in hours
            projectDs.Task.AddTaskRow(taskTwo);

            // Make second task dependent on first task. 
            SvcProject.ProjectDataSet.DependencyRow dependency = projectDs.Dependency.NewDependencyRow();
            dependency.LINK_UID = Guid.NewGuid();
            dependency.PROJ_UID = projectId;
            dependency.LINK_PRED_UID = taskOne.TASK_UID;
            dependency.LINK_SUCC_UID = taskTwo.TASK_UID;
            dependency.LINK_TYPE = 1;//Finish to Start
            dependency.LINK_LAG_FMT = (int)PSLibrary.Task.DurationFormat.Hour;
            dependency.LINK_LAG = 0;
            projectDs.Dependency.AddDependencyRow(dependency);

            // Add a summary task.
            SvcProject.ProjectDataSet.TaskRow taskOthers = projectDs.Task.NewTaskRow();
            taskOthers.PROJ_UID = projectId;
            taskOthers.TASK_UID = Guid.NewGuid();
            taskOthers.TASK_NAME = "Related Tasks";
            projectDs.Task.AddTaskRow(taskOthers);

            // Add some subtasks.
            SvcProject.ProjectDataSet.TaskRow taskThree = projectDs.Task.NewTaskRow();
            taskThree.PROJ_UID = projectId;
            taskThree.TASK_UID = Guid.NewGuid();
            taskThree.TASK_NAME = "Task Three";
            taskThree.TASK_PARENT_UID = taskOthers.TASK_UID;
            taskThree.TASK_OUTLINE_LEVEL = 2;
            taskThree.TASK_DUR = 9600; //Two days
            taskThree.TASK_DUR_FMT = (int)PSLibrary.Task.DurationFormat.Day;
            projectDs.Task.AddTaskRow(taskThree);

            SvcProject.ProjectDataSet.TaskRow taskFour = projectDs.Task.NewTaskRow();
            taskFour.PROJ_UID = projectId;
            taskFour.TASK_UID = Guid.NewGuid();
            taskFour.TASK_NAME = "Task Four";
            taskFour.TASK_PARENT_UID = taskOthers.TASK_UID;
            taskFour.TASK_DUR = 4800; //One day
            taskFour.TASK_DUR_FMT = (int)PSLibrary.Task.DurationFormat.Hour;
            taskFour.TASK_OUTLINE_LEVEL = 2;
            projectDs.Task.AddTaskRow(taskFour);


            // Make fourth task dependent on third task. 
            dependency = projectDs.Dependency.NewDependencyRow();
            dependency.LINK_UID = Guid.NewGuid();
            dependency.PROJ_UID = projectId;
            dependency.LINK_PRED_UID = taskThree.TASK_UID;
            dependency.LINK_SUCC_UID = taskFour.TASK_UID;
            dependency.LINK_TYPE = 1;//Finish to Start
            dependency.LINK_LAG = 0;
            projectDs.Dependency.AddDependencyRow(dependency);

            // Make other tasks dependent on second task. 
            dependency = projectDs.Dependency.NewDependencyRow();
            dependency.LINK_UID = Guid.NewGuid();
            dependency.PROJ_UID = projectId;
            dependency.LINK_PRED_UID = taskTwo.TASK_UID;
            dependency.LINK_SUCC_UID = taskOthers.TASK_UID;
            dependency.LINK_TYPE = 1;//Finish to Start
            dependency.LINK_LAG = 0;
            projectDs.Dependency.AddDependencyRow(dependency);

            //Add some local project resources.
            SvcProject.ProjectDataSet.ProjectResourceRow resourceOne = projectDs.ProjectResource.NewProjectResourceRow();
            resourceOne.PROJ_UID = projectId;
            resourceOne.RES_UID = Guid.NewGuid();
            resourceOne.RES_NAME = "Brynja Sigrídur Blomsterberg";
            resourceOne.RES_INITIALS = "BSB";
            projectDs.ProjectResource.AddProjectResourceRow(resourceOne);
            CreateAssignment(projectDs, taskOne.TASK_UID, resourceOne.RES_UID);
            CreateAssignment(projectDs, taskTwo.TASK_UID, resourceOne.RES_UID);

            SvcProject.ProjectDataSet.ProjectResourceRow resourceTwo = projectDs.ProjectResource.NewProjectResourceRow();
            resourceTwo.PROJ_UID = projectId;
            resourceTwo.RES_UID = Guid.NewGuid();
            resourceTwo.RES_NAME = "Ioannis Xylaras";
            resourceTwo.RES_INITIALS = "IX";
            projectDs.ProjectResource.AddProjectResourceRow(resourceTwo);
            CreateAssignment(projectDs, taskOne.TASK_UID, resourceTwo.RES_UID);
            CreateAssignment(projectDs, taskTwo.TASK_UID, resourceTwo.RES_UID);
            CreateAssignment(projectDs, taskThree.TASK_UID, resourceTwo.RES_UID);
            CreateAssignment(projectDs, taskFour.TASK_UID, resourceTwo.RES_UID);

            // Save the project to the database.
            jobId = Guid.NewGuid();
            projectSvc.QueueCreateProject(jobId, projectDs, false);
            CodeSampleUtilities.WaitForQueue(q, jobId);

            // Add or retrieve an enterprise resource.
            SvcResource.ResourceDataSet resourceDs = EnsureEnterpriseResource(resourceSvc);

            // Add the resource to the team.
            SvcProject.ProjectTeamDataSet projectTeamDs = new SvcProject.ProjectTeamDataSet();
            ProjectTeamAddResource(projectTeamDs, projectId, resourceDs.Resources[0].RES_UID, resourceDs.Resources[0].RES_UID);

            // Add the current user to the team.
            Guid myUid = resourceSvc.GetCurrentUserUid();
            ProjectTeamAddResource(projectTeamDs, projectId, myUid, myUid);
            projectSvc.CheckOutProject(projectId, sessionUid, SESSION_DESC);

            // Save the team!
            jobId = Guid.NewGuid();
            projectSvc.QueueUpdateProjectTeam(jobId, sessionUid, projectId, projectTeamDs);
            CodeSampleUtilities.WaitForQueue(q, jobId);

            // Read the project back in to get the updated team.
            projectDs = projectSvc.ReadProject(projectId, SvcProject.DataStoreEnum.WorkingStore);

            // Add the resource to an assignment
            CreateAssignment(projectDs, taskOne.TASK_UID, resourceDs.Resources[0].RES_UID, projectId);

            // Add the current user to an assignment.
            CreateAssignment(projectDs, taskThree.TASK_UID, myUid, projectId);

            // Save enterprise assignment.
            jobId = Guid.NewGuid();
            // Get only the added rows
            projectDs = (SvcProject.ProjectDataSet)projectDs.GetChanges(DataRowState.Added);
            projectSvc.QueueAddToProject(jobId, sessionUid, projectDs, false);
            CodeSampleUtilities.WaitForQueue(q, jobId);

            // Check in the project.
            jobId = Guid.NewGuid();
            projectSvc.QueueCheckInProject(jobId, projectId, false, sessionUid, SESSION_DESC);
            CodeSampleUtilities.WaitForQueue(q, jobId);

            // Publish the project.
            jobId = Guid.NewGuid();
            projectSvc.QueuePublish(jobId, projectId, false, String.Empty);
            CodeSampleUtilities.WaitForQueue(q, jobId);

            return projectRow.PROJ_UID;
        }
        // Helper function for CreateSampleProject.
        // Makes a simple assignment.
        private static void CreateAssignment(SvcProject.ProjectDataSet projectDs, Guid taskGuid, Guid resourceGuid)
        {
            CreateAssignment(projectDs, taskGuid, resourceGuid, projectDs.Project[0].PROJ_UID);
        }
        private static void CreateAssignment(SvcProject.ProjectDataSet projectDs, Guid taskGuid, Guid resourceGuid, Guid projectId)
        {
            SvcProject.ProjectDataSet.AssignmentRow assnRow = projectDs.Assignment.NewAssignmentRow();
            assnRow.PROJ_UID = projectId;
            assnRow.ASSN_UID = Guid.NewGuid();
            assnRow.TASK_UID = taskGuid;
            assnRow.RES_UID = resourceGuid;
            projectDs.Assignment.AddAssignmentRow(assnRow);
        }
        // Helper function for CreateSampleProject.
        // Adds an enterprise resource to the project
        // so it can be used on the project.
        public static void ProjectTeamAddResource(SvcProject.ProjectTeamDataSet projTeamDataSet, Guid projGuid, Guid resGuid, Guid newResGuid)
        {
            SvcProject.ProjectTeamDataSet.ProjectTeamRow projTeamRow = projTeamDataSet.ProjectTeam.NewProjectTeamRow();
            projTeamRow.PROJ_UID = projGuid;
            projTeamRow.RES_UID = resGuid;
            projTeamRow.NEW_RES_UID = newResGuid;
            projTeamDataSet.ProjectTeam.AddProjectTeamRow(projTeamRow);
        }
        // Helper function for CreateSampleProject.
        // Creates or retrieves an enterprise resource
        private static SvcResource.ResourceDataSet EnsureEnterpriseResource(SvcResource.Resource resourceSvc)
        {
            const string RES_NAME = "Lertchai Treetawatchaiwong";
            SvcResource.ResourceDataSet resourceDs = new SvcResource.ResourceDataSet();

            PSLibrary.Filter resourceFilter = new Microsoft.Office.Project.Server.Library.Filter();
            resourceFilter.FilterTableName = resourceDs.Resources.TableName;
            resourceFilter.Fields.Add(new PSLibrary.Filter.Field(resourceDs.Resources.TableName, resourceDs.Resources.RES_UIDColumn.ColumnName, PSLibrary.Filter.SortOrderTypeEnum.None));
            resourceFilter.Fields.Add(new PSLibrary.Filter.Field(resourceDs.Resources.TableName, resourceDs.Resources.RES_NAMEColumn.ColumnName, PSLibrary.Filter.SortOrderTypeEnum.None));
            resourceFilter.Fields.Add(new PSLibrary.Filter.Field(resourceDs.Resources.TableName, resourceDs.Resources.RES_INITIALSColumn.ColumnName, PSLibrary.Filter.SortOrderTypeEnum.None));
            resourceFilter.Fields.Add(new PSLibrary.Filter.Field(resourceDs.Resources.TableName, resourceDs.Resources.RES_TYPEColumn.ColumnName, PSLibrary.Filter.SortOrderTypeEnum.None));

            PSLibrary.Filter.FieldOperator existingResource = new PSLibrary.Filter.FieldOperator(PSLibrary.Filter.FieldOperationType.Equal, resourceDs.Resources.RES_NAMEColumn.ColumnName, RES_NAME);
            resourceFilter.Criteria = existingResource;
            resourceDs = resourceSvc.ReadResources(resourceFilter.GetXml(), false);
            if (resourceDs.Resources.Count >= 1)
            {
                return resourceDs;
            }
            else
            {
                resourceDs = new SvcResource.ResourceDataSet();
                SvcResource.ResourceDataSet.ResourcesRow resourceRow = resourceDs.Resources.NewResourcesRow();
                resourceRow.RES_UID = Guid.NewGuid();
                resourceRow.RES_NAME = RES_NAME;
                resourceRow.RES_INITIALS = "LT";
                resourceDs.Resources.AddResourcesRow(resourceRow);
                resourceSvc.CreateResources(resourceDs, false, true);
                return resourceDs;
            }
        }
    }
}

Voir aussi

Référence

Statusing classe

Statusing - Membres

WebSvcStatusing - Espace de noms