Production Manager API

Download the Relativity SDK and the Productions SDK. See Download the SDKs and NuGet packages.

• Obtain access to an instance of Relativity used for development purposes.
• Enable Developer mode in your development instance of Relativity to simplify troubleshooting. For more information, see Set up your development environment.

You need to obtain the Artifact IDs of several items used by the Production API. Use these steps to obtain this information from the workspace database:

1. Log in to Relativity.
2. On the Workspace tab, locate the workspace that you want to use for automating a production workflow. Note the Case Artifact ID of the workspace.
3. On the Production tab, locate the production you want to use. Note the Artifact ID of the production.

Note: You can also retrieve the production Artifact ID values from the EDDSXXXXXX.Production Relativity database table.

using Relativity.Productions.Services;
using Relativity.Services.ServiceProxy;
using Relativity.Services.Exceptions;

public partial class Example
{
    public async Task GetAllProductions_Example()
    {

        int workspaceId = 12345;            // Workspace Production(s) exist in 

        var userEmail   = "user@test.com";  // User's login 
        var password    = "abc123456!";     // User's password 

        var relativityRestUri     = "http://localhost/relativity.rest/api";

        var usernamePasswordCredentials = new UsernamePasswordCredentials(userEmail, password);

        ServiceFactorySettings settings = new ServiceFactorySettings(new Uri(relativityRestUri), usernamePasswordCredentials);

        ServiceFactory serviceFactory   = new ServiceFactory(settings);

        using (IProductionManager productionManager = serviceFactory.CreateProxy<IProductionManager>())
        {
            try
            {
                // Capture list of all productions in workspace for which the user has permissions. 
                // List can be iterated over to inspect productions, see which are ready to be produced, etc. 
                var productionList = await productionManager.GetAllAsync(workspaceId);

                foreach (var production in productionList)
                {
                    Console.WriteLine("Production Name: {0}", production.Name);
                }
            }
            catch (ValidationException e)
            {
                // Log validation exception details
                Console.WriteLine("There were validation errors: {0}", e.Message);
            }
            catch (ServiceException es)
            {
                // Log service exception details
                Console.WriteLine("There were errors: {0}", es.Message);
            }
        }
    }
}

public async Task GetProducedProductionsFromDocumentIds_Example()
        {
            int workspaceId = 12345;         // Workspace Productions exist in
            int documentId1 = 123;           // Document1's ArtifactID
            int documentId2 = 456;           // Document2's ArtifactID
            int documentId3 = 789;           // Document3's ArtifactID
 
            var userEmail = "user@test.com";  // User's login
            var password = "abc123456!";     // User's password
 
            var relativityRestUri = "http://localhost/relativity.rest/api";
 
            var usernamePasswordCredentials = new UsernamePasswordCredentials(userEmail, password);

            ServiceFactorySettings settings = new ServiceFactorySettings(new Uri(relativityRestUri), usernamePasswordCredentials);
            
            ServiceFactory serviceFactory = new ServiceFactory(settings);
 
            using (IProductionManager productionManager = serviceFactory.CreateProxy<IProductionManager>())
            {
                try
                {
                    List<int> documentIds = new List<int>
                    {
                        documentId1,
                        documentId2,
                        documentId3
                    };
 
                    //This list contains every produced production that contains at least one of the above documents.
                    List<ProductionSlim> producedProductions = await productionManager.GetProducedProductionsFromDocumentsAsync(workspaceId, documentIds);
 
                    foreach (ProductionSlim producedProduction in producedProductions)
                    {
                        Console.WriteLine($"This is the artifactId of the produced production: {producedProduction.ArtifactID}");
                        Console.WriteLine($"This is the name of the produced production: {producedProduction.Name}");
                        Console.WriteLine($"This is the first bates value of the produced production: {producedProduction.FieldValues["BeginBates"]}");
                        Console.WriteLine($"This is the last bates value of the produced production: {producedProduction.FieldValues["EndBates"]}");
                        Console.WriteLine($"This is the date produced of the produced production: {producedProduction.FieldValues["DateProduced"]}");
                    }
                }
                catch (ValidationException e)
                {
                    // Log validation exception details
                    Console.WriteLine("There were validation errors: {0}", e.Message);
                }
                catch (ServiceException es)
                {
                    // Log service exception details
                    Console.WriteLine("There were errors: {0}", es.Message);
                }
            }
        }

public async Task GetProducedProductionsFromDocumentIds_ExcludeNonReproducible_Example()
        {
            int workspaceId = 12345;         // Workspace Productions exist in
            int documentId1 = 123;           // Document1's ArtifactID
            int documentId2 = 456;           // Document2's ArtifactID
            int documentId3 = 789;           // Document3's ArtifactID
 
            var userEmail = "user@test.com";  // User's login
            var password = "abc123456!";     // User's password
 
            var relativityRestUri = "http://localhost/relativity.rest/api";
 
            var usernamePasswordCredentials = new UsernamePasswordCredentials(userEmail, password);
            ServiceFactorySettings settings = new ServiceFactorySettings(new Uri(relativityRestUri), usernamePasswordCredentials);
            ServiceFactory serviceFactory = new ServiceFactory(settings);
 
            using (IProductionManager productionManager = serviceFactory.CreateProxy<IProductionManager>())
            {
                try
                {
                    List<int> documentIds = new List<int>
                    {
                        documentId1,
                        documentId2,
                        documentId3
                    };
 
                    //This list contains every produced production that contains at least one of the above documents, and can be re-produced.
                    List<ProductionSlim> producedProductions = await productionManager.GetProducedProductionsFromDocumentsAsync(workspaceId, documentIds, true);
 
                    foreach (ProductionSlim producedProduction in producedProductions)
                    {
                        Console.WriteLine($"This is the artifactId of the produced production: {producedProduction.ArtifactID}");
                        Console.WriteLine($"This is the name of the produced production: {producedProduction.Name}");
                        Console.WriteLine($"This is the first bates value of the produced production: {producedProduction.FieldValues["BeginBates"]}");
                        Console.WriteLine($"This is the last bates value of the produced production: {producedProduction.FieldValues["EndBates"]}");
                        Console.WriteLine($"This is the date produced of the produced production: {producedProduction.FieldValues["DateProduced"]}");
                    }
                }
                catch (ValidationException e)
                {
                    // Log validation exception details
                    Console.WriteLine("There were validation errors: {0}", e.Message);
                }
                catch (ServiceException es)
                {
                    // Log service exception details
                    Console.WriteLine("There were errors: {0}", es.Message);
                }
            }
        }

public async Task GetProducedProductionsFromMassOpDatabaseToken_Example()
{
    int workspaceId = 12345;                                             // Workspace Productions exist in
    string databaseToken = "D6F3A251-2B5F-483E-B245-E9E7D5FC9560";       // Database Token retrieved from mass operation.
 
    var userEmail = "user@test.com";  // User's login
    var password = "abc123456!";     // User's password
 
    var relativityRestUri = "http://localhost/relativity.rest/api";
 
    var usernamePasswordCredentials = new UsernamePasswordCredentials(userEmail, password);

    ServiceFactorySettings settings = new ServiceFactorySettings(new Uri(relativityRestUri), usernamePasswordCredentials);
    ServiceFactory serviceFactory = new ServiceFactory(settings);
 
    using (IProductionManager productionManager = serviceFactory.CreateProxy<IProductionManager>())
    {
        try
        {
            //This list contains every produced production that contains at least of the above documents.
            List<ProductionSlim> producedProductions = await productionManager.GetProducedProductionsFromDocumentsAsync(workspaceId, databaseToken);
 
            foreach (ProductionSlim producedProduction in producedProductions)
            {
                Console.WriteLine($"This is the artifactId of the produced production: {producedProduction.ArtifactID}");
                Console.WriteLine($"This is the name of the produced production: {producedProduction.Name}");
                Console.WriteLine($"This is the first bates value of the produced production: {producedProduction.FieldValues["BeginBates"]}");
                Console.WriteLine($"This is the last bates value of the produced production: {producedProduction.FieldValues["EndBates"]}");
                Console.WriteLine($"This is the date produced of the produced production: {producedProduction.FieldValues["DateProduced"]}");
            }
        }
        catch (ValidationException e)
        {
            // Log validation exception details
            Console.WriteLine("There were validation errors: {0}", e.Message);
        }
        catch (ServiceException es)
        {
            // Log service exception details
            Console.WriteLine("There were errors: {0}", es.Message);
        }
    }
}

public async Task GetProducedProductionsFromMassOpDatabaseToken_ExcludeNonReproducible_Example()
{
    int workspaceId = 12345;                                             // Workspace Productions exist in
    string databaseToken = "D6F3A251-2B5F-483E-B245-E9E7D5FC9560";       // Database Token retrieved from mass operation.
 
    var userEmail = "user@test.com";  // User's login
    var password = "abc123456!";     // User's password
 

    var relativityRestUri = "http://localhost/relativity.rest/api";
 
    var usernamePasswordCredentials = new UsernamePasswordCredentials(userEmail, password);

     ServiceFactorySettings settings = new ServiceFactorySettings(new Uri(relativityRestUri), usernamePasswordCredentials);
    ServiceFactory serviceFactory = new ServiceFactory(settings);
 
    using (IProductionManager productionManager = serviceFactory.CreateProxy<IProductionManager>())
    {
        try
        {
            //This list contains every produced production that contains at least one of the above documents, and can be re-produced.
            List<ProductionSlim> producedProductions = await productionManager.GetProducedProductionsFromDocumentsAsync(workspaceId, databaseToken, true);
 
            foreach (ProductionSlim producedProduction in producedProductions)
            {
                Console.WriteLine($"This is the artifactId of the produced production: {producedProduction.ArtifactID}");
                Console.WriteLine($"This is the name of the produced production: {producedProduction.Name}");
                Console.WriteLine($"This is the first bates value of the produced production: {producedProduction.FieldValues["BeginBates"]}");
                Console.WriteLine($"This is the last bates value of the produced production: {producedProduction.FieldValues["EndBates"]}");
                Console.WriteLine($"This is the date produced of the produced production: {producedProduction.FieldValues["DateProduced"]}");
            }
        }
        catch (ValidationException e)
        {
            // Log validation exception details
            Console.WriteLine("There were validation errors: {0}", e.Message);
        }
        catch (ServiceException es)
        {
            // Log service exception details
            Console.WriteLine("There were errors: {0}", es.Message);
        }
    }
}

public async Task GetProductionImagesWithDocuments_Example()
        {
            int workspaceId = 12345;          // Workspace Production exists in
            int productionId = 11111;         // Production's ArtifactID
            int documentId1 = 22222;          // ArtifactID of a document in the Production
            int documentId2 = 33333;          // ArtifactID of another document in the Production
 
            var userEmail = "user@test.com";  // User's login
            var password = "abc123456!";      // User's password
 

            var relativityRestUri = "http://localhost/relativity.rest/api";
 
            var usernamePasswordCredentials = new UsernamePasswordCredentials(userEmail, password);

            ServiceFactorySettings settings = new ServiceFactorySettings(new Uri(relativityRestUri), usernamePasswordCredentials);
            ServiceFactory serviceFactory = new ServiceFactory(settings);
 
            using (IProductionManager productionManager = serviceFactory.CreateProxy<IProductionManager>())
            {
                try
                {
                    List<int> documents = new List<int>()
                    {
                        documentId1,
                        documentId2
                    };
 
                    ImageFilesResult result = await productionManager.GetProductionImagesAsync(workspaceId, productionId, documents);
 
                    foreach (ImageFile imageFile in result.ImageFiles)
                    {
                        Console.WriteLine($"FileID: {imageFile.FileID}");
                        Console.WriteLine($"FileGuid: {imageFile.FileGuid}");
                        Console.WriteLine($"DocumentID: {imageFile.DocumentID}");
                        Console.WriteLine($"PageNumber: {imageFile.PageNumber}");
                        Console.WriteLine($"HasRedactions: {imageFile.HasRedactions}");
                    }
                }
                catch (ValidationException e)
                {
                    // Log validation exception details
                    Console.WriteLine("There were validation errors: {0}", e.Message);
                }
                catch (ServiceException es)
                {
                    // Log service exception details
                    Console.WriteLine("There were errors: {0}", es.Message);
                }
            }
        }

public async Task GetProductionImagesWithPagination_Example()
        {
            int workspaceId = 12345;          // Workspace Production exists in
            int productionId = 11111;         // Production's ArtifactID
 
            var userEmail = "user@test.com";  // User's login
            var password = "abc123456!";      // User's password
 

            var relativityRestUri = "http://localhost/relativity.rest/api";
 
            var usernamePasswordCredentials = new UsernamePasswordCredentials(userEmail, password);
            ServiceFactorySettings settings = new ServiceFactorySettings(new Uri(relativityRestUri), usernamePasswordCredentials);
            ServiceFactory serviceFactory = new ServiceFactory(settings);
 
            using (IProductionManager productionManager = serviceFactory.CreateProxy<IProductionManager>())
            {
                try
                {
                    int start = 1;      // StartIndex of the result set.
                    int length = 1000;  // Number of total results to fetch.
                    int pageSize = 100; // Number of results to fetch per page.
 
                    PagedImageFilesResult result = await productionManager.GetProductionImagesAsync(workspaceId, productionId, start, length, pageSize);
 
                    Console.WriteLine($"This is the start index of the current page: {result.StartIndex}.");
                    Console.WriteLine($"This is the count of the entire result set: {result.TotalResultSet}.");
                    Console.WriteLine($"This is the count of the result set on the current page: {result.ResultCount}.");
 
                    foreach (ImageFile imageFile in result.ImageFiles)
                    {
                        Console.WriteLine($"FileID: {imageFile.FileID}");
                        Console.WriteLine($"FileGuid: {imageFile.FileGuid}");
                        Console.WriteLine($"DocumentID: {imageFile.DocumentID}");
                        Console.WriteLine($"PageNumber: {imageFile.PageNumber}");
                        Console.WriteLine($"HasRedactions: {imageFile.HasRedactions}");
                    }
 
                    if (result.NextUri != null)
                    {
                        PagedImageFilesResult nextResult = await productionManager.GetProductionImagesAsync(result.NextUri);
                    }
 
                    if (result.PreviousUri != null)
                    {
                        PagedImageFilesResult previousResult = await productionManager.GetProductionImagesAsync(result.PreviousUri);
                    }
                }
                catch (ValidationException e)
                {
                    // Log validation exception details
                    Console.WriteLine("There were validation errors: {0}", e.Message);
                }
                catch (ServiceException es)
                {
                    // Log service exception details
                    Console.WriteLine("There were errors: {0}", es.Message);
                }
            }
        }

public async Task GetProductionImagesWithPageUri_Example()
    {
 
        var userEmail = "user@test.com";  // User's login
        var password = "abc123456!";      // User's password
 

        var relativityRestUri = "http://localhost/relativity.rest/api";
        var pageUri = "Page Uri here";
 
        var usernamePasswordCredentials = new UsernamePasswordCredentials(userEmail, password);
        ServiceFactorySettings settings = new ServiceFactorySettings(new Uri(relativityRestUri), usernamePasswordCredentials);
        ServiceFactory serviceFactory = new ServiceFactory(settings);
 
        using (IProductionManager productionManager = serviceFactory.CreateProxy<IProductionManager>())
        {
            try
            {
                PagedImageFilesResult result = await productionManager.GetProductionImagesAsync(pageUri);
 
                Console.WriteLine($"This is the start index of the current page: {result.StartIndex}.");
                Console.WriteLine($"This is the count of the entire result set: {result.TotalResultSet}.");
                Console.WriteLine($"This is the count of the result set on the current page: {result.ResultCount}.");
 
                foreach (ImageFile imageFile in result.ImageFiles)
                {
                    Console.WriteLine($"FileID: {imageFile.FileID}");
                    Console.WriteLine($"FileGuid: {imageFile.FileGuid}");
                    Console.WriteLine($"DocumentID: {imageFile.DocumentID}");
                    Console.WriteLine($"PageNumber: {imageFile.PageNumber}");
                    Console.WriteLine($"HasRedactions: {imageFile.HasRedactions}");
                }
 
                if (result.NextUri != null)
                {
                    PagedImageFilesResult nextResult = await productionManager.GetProductionImagesAsync(result.NextUri);
                }
 
                if (result.PreviousUri != null)
                {
                    PagedImageFilesResult previousResult = await productionManager.GetProductionImagesAsync(result.PreviousUri);
                }
            }
            catch (ValidationException e)
            {
                // Log validation exception details
                Console.WriteLine("There were validation errors: {0}", e.Message);
            }
            catch (ServiceException es)
            {
                // Log service exception details
                Console.WriteLine("There were errors: {0}", es.Message);
            }
        }
    }
}

public async Task GetProductionStatusDetails_Example()
{
    int workspaceId = 12345;                                                    // Workspace Productions exist in
    int productionId = 22222;                                                   // Production artifact ID.
  
    var userEmail = "user@test.com";  // User's login
    var password = "abc123456!";     // User's password
  
    var relativityRestUri = "http://localhost/relativity.rest/api";
  
    var usernamePasswordCredentials = new UsernamePasswordCredentials(userEmail, password);

    ServiceFactorySettings settings = new ServiceFactorySettings(new Uri(relativityRestUri), usernamePasswordCredentials);
    ServiceFactory serviceFactory = new ServiceFactory(settings);
  
    using (IProductionManager productionManager = serviceFactory.CreateProxy<IProductionManager>())
    {
        try
        {
            ProductionStatusDetailsResult result = await productionManager.GetProductionStatusDetails(workspaceId, productionId);
        }
        catch (ValidationException e)
        {
            // Log validation exception details
            Console.WriteLine("There were validation errors: {0}", e.Message);
        }
        catch (ServiceException es)
        {
            // Log service exception details
            Console.WriteLine("There were errors: {0}", es.Message);
        }
    }
}

/// <summary>
/// Use this example if you are interested in creating a custom mass operation on the document object involving produced productions.
/// A primer on custom mass operations: When a user selects documents and presses the custom mass operation button, a database token will
/// be generated, corresponding to a table in the database that holds all of the selected documents. This API is designed to be used
/// for these scenarios to avoid a second server trip to retrieve the requested documentIds of the custom mass operation.
/// </summary>
/// <returns></returns>
public async Task GetProductionsEligibleForReproductions_Example()
{
    int workspaceId = 12345;                                                    // Workspace Productions exist in
    string databaseToken = "284EDA64-319D-4926-92AA-B30EB7C5AC95";              // Database Token retrieved from mass operation.
    ReproductionType reproductionType = ReproductionType.ReproduceDocument;     //The reproduction type to re-produce as.
 
    var userEmail = "user@test.com";  // User's login
    var password = "abc123456!";     // User's password
 
    var relativityRestUri = "http://localhost/relativity.rest/api";
 
    var usernamePasswordCredentials = new UsernamePasswordCredentials(userEmail, password);
    ServiceFactorySettings settings = new ServiceFactorySettings(new Uri(relativityRestUri), usernamePasswordCredentials);
    ServiceFactory serviceFactory = new ServiceFactory(settings);
 
    using (IProductionManager productionManager = serviceFactory.CreateProxy<IProductionManager>())
    {
        try
        {
            //This list contains every produced production that contains at least of the above documents.
            List<ProductionSlim> producedProductions = await productionManager.GetProductionsEligibleForReproductionAsync(workspaceId, databaseToken, reproductionType);
 
            foreach (ProductionSlim producedProduction in producedProductions)
            {
                Console.WriteLine($"This is the artifactId of the produced production: {producedProduction.ArtifactID}");
                Console.WriteLine($"This is the name of the produced production: {producedProduction.Name}");
                Console.WriteLine($"This is the first bates value of the produced production: {producedProduction.FieldValues["BeginBates"]}");
                Console.WriteLine($"This is the last bates value of the produced production: {producedProduction.FieldValues["EndBates"]}");
                Console.WriteLine($"This is the date produced of the produced production: {producedProduction.FieldValues["DateProduced"]}");
            }
        }
        catch (ValidationException e)
        {
            // Log validation exception details
            Console.WriteLine("There were validation errors: {0}", e.Message);
        }
        catch (ServiceException es)
        {
            // Log service exception details
            Console.WriteLine("There were errors: {0}", es.Message);
        }
    }
}

using System;
using System.Collections.Generic;
using System.Threading.Tasks;


namespace Relativity.Productions.Documentation.Samples.ProductionManager
{
    using Relativity.Productions.Services;
    using Relativity.Services.ServiceProxy;
    using Relativity.Services.Exceptions;

    public partial class Example
    {
		public async Task CreatePageLevelProduction_Example()
        {
            int workspaceId  = 12345;                   // ArtifactID of Workspace where Production will be saved
            var userName     = "user@test.com";         // User's login
            var userPassword = "abc123456!";            // User's password


            var relativityRestUri     = "http://localhost/relativity.rest/api";

            var usernamePasswordCredentials = new UsernamePasswordCredentials(userName, userPassword);
            ServiceFactorySettings settings = new ServiceFactorySettings(new Uri(relativityRestUri), usernamePasswordCredentials);
            ServiceFactory serviceFactory   = new ServiceFactory(settings);

            using (IProductionManager productionManager = serviceFactory.CreateProxy<IProductionManager>())
            {
                try
                {
                    // Construct the production object that you want to create
                    var production = new Production
                    {
                        Name = "Page Level Production Sample",
                        Details = new ProductionDetails
                        {
                            DateProduced      = new DateTime(2017, 10, 22),
                            EmailRecipients   = "pagelevelnumber@relativity.com; emosewa@gmail.com",
                            ScaleBrandingFont = true,
                            BrandingFontSize  = 25,
                            PlaceholderImageFormat = PlaceholderImageFormat.Tiff
                        },

                        Numbering = new PageLevelNumbering
                        {
                            BatesPrefix                        = "ADBE",
                            BatesSuffix                        = "DRAFT",
                            BatesStartNumber                   = 20,
                            NumberOfDigitsForDocumentNumbering = 5
                        },

                        Footers = new ProductionFooters
                        {
                            LeftFooter = new HeaderFooter("Left Footer")
                            {
                                Type     = HeaderFooterType.FreeText,
                                FreeText = "This is confidential page"
                            }
                        },

                        Keywords = "PageLevel, Complete Setting",
                        Notes    = "Page level numbering production"
                    };

                    // Save the production into the specified workspace
                    int productionId = await productionManager.CreateSingleAsync(workspaceId, production);

                    Console.WriteLine("The created production Id is {0}", productionId);
                }
                catch (ValidationException e)
                {
                    // Log validation exception details
                    Console.WriteLine("There were validation errors: {0}", e.Message);
                }
                catch (ServiceException es)
                {
                    // Log service exception details
                    Console.WriteLine("There were errors: {0}", es.Message);
                }
            }
        }
    }
}

using Relativity.Productions.Services;
using Relativity.Services.ServiceProxy;
using Relativity.Services.Exceptions;

public partial class Example
{
    public async Task CreateExistingProductionNumberingProduction_Example()
    {
        int workspaceId          = 12345;                   // ArtifactID of Workspace where Production will be saved 
        int existingProductionId = 234567;                  // ArtifactID of A Produced Production which can be used as an existing Production in create 
        var userName             = "user@test.com";         // User's login 
        var userPassword         = "abc123456!";            // User's password 


        var relativityRestUri     = "http://localhost/relativity.rest/api";

        var usernamePasswordCredentials = new UsernamePasswordCredentials(userName, userPassword);
        ServiceFactorySettings settings = new ServiceFactorySettings(new Uri(relativityRestUri), usernamePasswordCredentials);
        ServiceFactory serviceFactory   = new ServiceFactory(settings);

        using (IProductionManager productionManager = serviceFactory.CreateProxy<IProductionManager>())
        {
            try
            {
                var production = new Production
                {
                    Name = "Sample Production - Default Settings",
                    Numbering = new ExistingProductionNumbering()
                    {
                        ExistingProduction = new ProductionRef(existingProductionId)
                    }

                };
                // Save the production into the specified workspace 
                int productionId = await productionManager.CreateSingleAsync(workspaceId, production);    

                Console.WriteLine("The created production Id is {0}", productionId);
            }
            catch (ValidationException e)
            {
                // Log validation exception details
                Console.WriteLine("There were validation errors: {0}", e.Message);
            }
            catch (ServiceException es)
            {
                // Log service exception details
                Console.WriteLine("There were errors: {0}", es.Message);
            }
        }
    }
}

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Relativity.Productions.Services;

namespace Relativity.Productions.Documentation.Samples.ProductionManager
{
    public class ReadProduction
    {
        #region ReadProduction
        public async Task ReadProduction_Example()
        {
            int workspaceId = 12345;  // Workspace Production exists in
            int productionId = 11111;  // Production's ArtifactID

            var userEmail = "user@test.com";  // User's login
            var password = "abc123456!"; // User's password

            var usernamePasswordCredentials = new Relativity.Services.ServiceProxy.UsernamePasswordCredentials(userEmail, password);
            var relativityRestUri = "https://localhost/relativity.rest/api";

            Relativity.Services.ServiceProxy.ServiceFactorySettings settings = new Relativity.Services.ServiceProxy.ServiceFactorySettings(new Uri(relativityRestUri)
                , usernamePasswordCredentials);

            Relativity.Services.ServiceProxy.ServiceFactory serviceFactory = new Relativity.Services.ServiceProxy.ServiceFactory(settings);

            using (Relativity.Productions.Services.IProductionManager productionManager = serviceFactory.CreateProxy<Relativity.Productions.Services.IProductionManager>())
            {
                try
                {
                    Production production = await productionManager.ReadSingleAsync(workspaceId, productionId);

                    var productionStatus = production.ProductionMetadata.Status;
                    if (productionStatus == ProductionStatus.New)
                    {
                        // do something, like read this production
                    }
                }
                catch (Relativity.Services.Exceptions.ServiceException)
                {

                    // Log exception details
                }
            }
        }
        #endregion
    }
}

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Relativity.Productions.Services;

namespace Relativity.Productions.Documentation.Samples.ProductionManager
{
    public class StageProduction
    {
        #region StageProduction
        public async Task StageProduction_Example()
        {
            int workspaceId = 12345;  // Workspace Production exists in
            int productionId = 11111;  // Production's ArtifactID

            var userEmail = "user@test.com";  // User's login
            var password = "abc123456!"; // User's password

            var usernamePasswordCredentials = new Relativity.Services.ServiceProxy.UsernamePasswordCredentials(userEmail, password);
            var relativityRestUri = "https://localhost/relativity.rest/api";

            Relativity.Services.ServiceProxy.ServiceFactorySettings settings = new Relativity.Services.ServiceProxy.ServiceFactorySettings(new Uri(relativityRestUri)
                , usernamePasswordCredentials);

            Relativity.Services.ServiceProxy.ServiceFactory serviceFactory = new Relativity.Services.ServiceProxy.ServiceFactory(settings);

            using (Relativity.Productions.Services.IProductionManager productionManager = serviceFactory.CreateProxy<Relativity.Productions.Services.IProductionManager>())
            {
                try
                {
                    ProductionJobResult result = await productionManager.StageProductionAsync(workspaceId, productionId);

                    bool wasJobCreated = result.WasJobCreated;
                    int productionJobId = result.JobID;
                    List<string> messages = result.Messages;
                    List<string> errors = result.Errors;
                }
                catch (Relativity.Services.Exceptions.ServiceException)
                {
                    // Log exception details
                }
            }
        }
        #endregion
    }
}

using Relativity.Services.ServiceProxy;
using Relativity.Productions.Services;
using Relativity.Services.Exceptions;

public partial class Example
{
    public async Task RunProduction_Example()
    {
        int workspaceId  = 12345;            // Workspace Production exists in 
        int productionId = 11111;            // Production's ArtifactID 

        var userEmail    = "user@test.com";  // User's login 
        var password     = "abc123456!";     // User's password 

        var relativityRestUri     = "http://localhost/relativity.rest/api";

        var usernamePasswordCredentials = new UsernamePasswordCredentials(userEmail, password);
        ServiceFactorySettings settings = new ServiceFactorySettings(new Uri(relativityRestUri), usernamePasswordCredentials);
        ServiceFactory serviceFactory   = new ServiceFactory(settings);

        using (IProductionManager productionManager = serviceFactory.CreateProxy<IProductionManager>())
        {
            try
            {
                ProductionJobResult result = await productionManager.RunProductionAsync(workspaceId, productionId, false);

                bool wasJobCreated    = result.WasJobCreated;
                int productionJobId   = result.JobID;

                if (!wasJobCreated)
                {
                    Console.WriteLine(result.Errors);
                    Console.WriteLine(result.Warnings);
                    Console.WriteLine(result.Messages);

                    // Okay, so maybe you've looked at the errors and found some document conflicts 
                    // and you want to override it anyway. 

                    bool overrideConfilcts = true;
                    bool suppressWarnings = true;

                    result = await productionManager.RunProductionAsync(workspaceId, productionJobId, suppressWarnings, overrideConfilcts);
                }
            }
            catch (ValidationException e)
            {
                // Log validation exception details
                Console.WriteLine("There were validation errors: {0}", e.Message);
            }
            catch (ServiceException es)
            {
                // Log service exception details
                Console.WriteLine("There were errors: {0}", es.Message);
            }
        }
    }
}

public async Task MassStageAndRunProductions_WithProductionIds_Example()
{
    int workspaceId = 12345;            // Workspace Productions exist in
    int production1Id = 11111;          // Production 1's ArtifactID
    int production2Id = 22222;          // Production 2's ArtifactID
    int production3Id = 33333;          // Production 3's ArtifactID
 
    var userEmail = "user@test.com";    // User's login
    var password = "abc123456!";        // User's password
 
    var relativityRestUri = "http://localhost/relativity.rest/api";
 
    var usernamePasswordCredentials = new UsernamePasswordCredentials(userEmail, password);
    ServiceFactorySettings settings = new ServiceFactorySettings(new Uri(relativityRestUri), usernamePasswordCredentials);
    ServiceFactory serviceFactory = new ServiceFactory(settings);
 
    using (IProductionManager productionManager = serviceFactory.CreateProxy<IProductionManager>())
    {
        try
        {
            List<int> productionIds = new List<int>()
            {
                production1Id,
                production2Id,
                production3Id
            };
 
            IEnumerable<ProductionJobResult> results = await productionManager.MassStageAndRunProductionsAsync(workspaceId, productionIds);
 
            foreach (ProductionJobResult result in results)
            {
                bool wasJobCreated = result.WasJobCreated;
                int wsId = result.WorkspaceID; //The workspace the production belongs to.
                int productionId = result.ProductionID; //The artifactID of the production of the current result.
                int jobId = result.JobID; //The production set queue job id of the currently running production.
 
                if (!wasJobCreated)
                {
                    Console.WriteLine(result.Errors);
                    Console.WriteLine(result.Warnings);
                    Console.WriteLine(result.Messages);
                }
            }
        }
        catch (ValidationException e)
        {
            // Log validation exception details
            Console.WriteLine("There were validation errors: {0}", e.Message);
        }
        catch (ServiceException es)
        {
            // Log service exception details
            Console.WriteLine("There were errors: {0}", es.Message);
        }
    }
}

public async Task MassStageAndRunProductions_WithReproductionJobID_Example()
        {
            int workspaceId = 12345;            // Workspace Production exists in
            int reproductionJobId = 11111;      // ReproductionJobID of a Re-production job.
 
            var userEmail = "user@test.com";   // User's login
            var password = "abc123456!";       // User's password
 

            var relativityRestUri = "http://localhost/relativity.rest/api";
 
            var usernamePasswordCredentials = new UsernamePasswordCredentials(userEmail, password);
            ServiceFactorySettings settings = new ServiceFactorySettings(new Uri(relativityRestUri), usernamePasswordCredentials);
            ServiceFactory serviceFactory = new ServiceFactory(settings);
 
            using (IProductionManager productionManager = serviceFactory.CreateProxy<IProductionManager>())
            {
                try
                {
                    IEnumerable<ProductionJobResult> results = await productionManager.MassStageAndRunProductionsAsync(workspaceId, reproductionJobId);
 
                    foreach (ProductionJobResult result in results)
                    {
                        bool wasJobCreated = result.WasJobCreated;
                        int wsId = result.WorkspaceID; //The workspace the production belongs to.
                        int productionId = result.ProductionID; //The artifactID of the production of the current result.
                        int jobId = result.JobID; //The production set queue job id of the currently running production.
 
                        if (!wasJobCreated)
                        {
                            Console.WriteLine(result.Errors);
                            Console.WriteLine(result.Warnings);
                            Console.WriteLine(result.Messages);
                        }
                    }
                }
                catch (ValidationException e)
                {
                    // Log validation exception details
                    Console.WriteLine("There were validation errors: {0}", e.Message);
                }
                catch (ServiceException es)
                {
                    // Log service exception details
                    Console.WriteLine("There were errors: {0}", es.Message);
                }
            }
        }

using System;
using System.Threading.Tasks;
using Relativity.Productions.Services.Interfaces.DTOs;

namespace Relativity.Productions.Documentation.Samples.ProductionManager
{
    #region CancelProductionWithJobRef
    using Relativity.Services.ServiceProxy;
    using Relativity.Productions.Services;
    using Relativity.Services.Exceptions;

    public partial class Example
    {
        public async Task CancelProductionWithJobRef_Example()
        {
            int workspaceId = 12345;         // Workspace Production exists in
            int productionId = 11111;         // Production's ArtifactID

            var userEmail = "user@test.com";  // User's login
            var password = "abc123456!";     // User's password

            var relativityRestUri = "http://localhost/relativity.rest/api";

            var usernamePasswordCredentials = new UsernamePasswordCredentials(userEmail, password);
            ServiceFactorySettings settings = new ServiceFactorySettings(new Uri(relativityRestUri), usernamePasswordCredentials);
            ServiceFactory serviceFactory = new ServiceFactory(settings);

            using (IProductionManager productionManager = serviceFactory.CreateProxy<IProductionManager>())
            {
                try
                {
                    ProductionJobRef jobRef = new ProductionJobRef()
                    {
                        WorkspaceID = workspaceId,
                        ProductionID = productionId
                    };

                    await productionManager.CancelJobAsync(jobRef);
                }
                catch (ValidationException e)
                {
                    // Log validation exception details
                    Console.WriteLine("There were validation errors: {0}", e.Message);
                }
                catch (ServiceException es)
                {
                    // Log service exception details
                    Console.WriteLine("There were errors: {0}", es.Message);
                }
            }
        }
    }
    #endregion
}

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Relativity.Productions.Services.Interfaces.DTOs;

namespace Relativity.Productions.Documentation.Samples.ProductionManager
{

    #region Mass Cancel Productions
    using Relativity.Services.ServiceProxy;
    using Relativity.Productions.Services;
    using Relativity.Services.Exceptions;

    public partial class Example
    {
        public async Task MassCancelProductions_Example()
        {
            int workspaceIdJob1 = 12345;         // Workspace Production Job 1 exists in
            int productionIdJob1 = 11111;        // Production Job 1's ArtifactID

            int workspaceIdJob2 = 23456;         // Workspace Production Job 2 exists in
            int productionIdJob2 = 22222;        // Production Job 2's ArtifactID

            int productionJobId3 = 111;            // JobID of Production Job 3

            var userEmail = "user@test.com";  // User's login
            var password = "abc123456!";     // User's password

            var relativityRestUri = "http://localhost/relativity.rest/api";

            var usernamePasswordCredentials = new UsernamePasswordCredentials(userEmail, password);
            ServiceFactorySettings settings = new ServiceFactorySettings(new Uri(relativityRestUri), usernamePasswordCredentials);
            ServiceFactory serviceFactory = new ServiceFactory(settings);

            List<ProductionJobRef> jobsToBeCanceled = new List<ProductionJobRef>()
            {
                new ProductionJobRef()
                {
                    WorkspaceID = workspaceIdJob1,
                    ProductionID = productionIdJob1
                },
                new ProductionJobRef()
                {
                    WorkspaceID = workspaceIdJob2,
                    ProductionID = productionIdJob2
                },
                new ProductionJobRef()
                {
                    JobID = productionJobId3
                }
            };

            using (IProductionManager productionManager = serviceFactory.CreateProxy<IProductionManager>())
            {
                try
                {
                    await productionManager.MassCancelAsync(jobsToBeCanceled);
                }
                catch (ValidationException e)
                {
                    // Log validation exception details
                    Console.WriteLine("There were validation errors: {0}", e.Message);
                }
                catch (ServiceException es)
                {
                    // Log service exception details
                    Console.WriteLine("There were errors: {0}", es.Message);
                }
            }
        }
    }
    #endregion

}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Relativity.Productions.Services;

namespace Relativity.Productions.Documentation.Samples.ProductionManager
{
    class DeleteProduction
    {
        #region DeleteProduction
        public async Task DeleteProduction_Example()
        {
            int workspaceId = 12345;  // Workspace Production exists in
            int productionId = 11111;  // Production's ArtifactID

            var userEmail = "user@test.com";  // User's login
            var password = "abc123456!"; // User's password

            var usernamePasswordCredentials = new Relativity.Services.ServiceProxy.UsernamePasswordCredentials(userEmail, password);
            var relativityRestUri = "https://localhost/relativity.rest/api";

            Relativity.Services.ServiceProxy.ServiceFactorySettings settings = new Relativity.Services.ServiceProxy.ServiceFactorySettings(new Uri(relativityRestUri)
                , usernamePasswordCredentials);

            Relativity.Services.ServiceProxy.ServiceFactory serviceFactory = new Relativity.Services.ServiceProxy.ServiceFactory(settings);

            using (Relativity.Productions.Services.IProductionManager productionManager = serviceFactory.CreateProxy<Relativity.Productions.Services.IProductionManager>())
            {
                try
                {
                    await productionManager.DeleteSingleAsync(workspaceId, productionId);
                }
                catch (Relativity.Services.Exceptions.ServiceException)
                {

                    // Log exception details
                }
            }
        }
        #endregion
    }
}

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Relativity.Productions.Services.Interfaces.DTOs;

namespace Relativity.Productions.Documentation.Samples.ProductionManager
{

	#region Mass Retry Productions
	using Relativity.Services.ServiceProxy;
	using Relativity.Productions.Services;
	using Relativity.Services.Exceptions;

	public partial class Example
	{
		public async Task MassRetryProductions_Example()
		{
			int workspaceIdJob1 = 12345;         // Workspace Production Job 1 exists in
			int productionIdJob1 = 11111;        // Production Job 1's ArtifactID

			int workspaceIdJob2 = 23456;         // Workspace Production Job 2 exists in
			int productionIdJob2 = 22222;        // Production Job 2's ArtifactID

			int productionJobId3 = 111;            // JobID of Production Job 3

			var userEmail = "user@test.com";  // User's login
			var password = "abc123456!";     // User's password


			var relativityRestUri = "https://localhost/relativity.rest/api";

			var usernamePasswordCredentials = new UsernamePasswordCredentials(userEmail, password);
			ServiceFactorySettings settings = new ServiceFactorySettings(new Uri(relativityRestUri), usernamePasswordCredentials);
			ServiceFactory serviceFactory = new ServiceFactory(settings);

			List<ProductionJobRef> jobsToBeRetried = new List<ProductionJobRef>()
			{
				new ProductionJobRef()
				{
					WorkspaceID = workspaceIdJob1,
					ProductionID = productionIdJob1
				},
				new ProductionJobRef()
				{
					WorkspaceID = workspaceIdJob2,
					ProductionID = productionIdJob2
				},
				new ProductionJobRef()
				{
					JobID = productionJobId3
				}
			};

			MassRetryResult massRetryResult;
			using (IProductionManager productionManager = serviceFactory.CreateProxy<IProductionManager>())
			{
				massRetryResult = await productionManager.MassRetryAsync(jobsToBeRetried);
			}

			if (massRetryResult.Errors.Count > 0)
			{
				foreach (string error in massRetryResult.Errors)
				{
					Console.WriteLine("There were errors: {0}", error);
				}
			}

			if (massRetryResult.NumberOfJobsRetryWasRequestedSuccessfully != massRetryResult.NumberOfJobsRequestedForRetry)
			{
				// Print out errors for the jobs that did not retry successfully
				foreach (RetryJobResult retryJobResult in massRetryResult.RetryJobResults)
				{
					if (!retryJobResult.RetrySuccessfullySent)
					{
						Console.WriteLine("Errors for Production Job: WorkspaceID {0}, ProductionID {1}, JobID {2}", retryJobResult.WorkspaceID, retryJobResult.ProductionID, retryJobResult.JobID);
						foreach (string error in retryJobResult.Errors)
						{
							Console.WriteLine(error);
						}
					}
				}
			}
		}
	}
	#endregion

}