/// <summary>
        /// Method to validate the configured arguments for the step type.  The
        /// logic of this method depends on the implementation of the custom step
        /// but typically checks for proper argument names and syntax.
        /// </summary>
        /// <param name="argv">Array of arguments configured for the step type</param>
        /// <returns>Returns 'true' if arguments are valid, 'false' if otherwise</returns>
        public bool ValidateArguments(ref object[] argv)
        {
            IJTXDatabase pJTXDB = m_ipDatabase;

            // Get the arguments
            string sHoldTypeName = "";
            string sHoldRemarks  = "";

            bool bHoldType = StepUtilities.GetArgument(ref argv, "HoldType", true, out sHoldTypeName);

            if (!bHoldType)
            {
                MessageBox.Show("Invalid arguments entered. No hold type entered.");
                return(false);
            }
            bool bHoldRemarks = StepUtilities.GetArgument(ref argv, "HoldRemarks", true, out sHoldRemarks);

            // Get the hold type
            IJTXConfiguration pJTXConfig = pJTXDB.ConfigurationManager;
            IJTXHoldType      pHoldType  = pJTXConfig.GetHoldType(sHoldTypeName);

            if (pHoldType == null)
            {
                MessageBox.Show("Invalid hold type name entered: " + sHoldTypeName);
                return(false);
            }
            return(true);
        }
Exemplo n.º 2
0
        /// <summary>
        /// Called when a step of this type is executed in the workflow.
        /// </summary>
        /// <param name="JobID">ID of the job being executed</param>
        /// <param name="StepID">ID of the step being executed</param>
        /// <param name="argv">Array of arguments passed into the step's execution</param>
        /// <param name="ipFeedback">Feedback object to return status messages and files</param>
        /// <returns>Return code of execution for workflow path traversal</returns>
        public int Execute(int jobID, int stepID, ref object[] argv, ref IJTXCustomStepFeedback ipFeedback)
        {
            if (jobID <= 0)
            {
                throw (new ArgumentOutOfRangeException("JobID", jobID, "Job ID must be a positive value"));
            }

            string strNotifType   = "";
            string strSubscribers = "";

            if (!StepUtilities.GetArgument(ref argv, m_expectedArgs[0], true, out strNotifType))
            {
                throw new ArgumentNullException(m_expectedArgs[0], string.Format("\nMissing the {0} parameter!", m_expectedArgs[0]));
            }
            bool bSubscribers = StepUtilities.GetArgument(ref argv, m_expectedArgs[1], true, out strSubscribers);

            IJTXJob ipJob = m_ipDatabase.JobManager.GetJob(jobID);

            if (bSubscribers)
            {
                UpdateSubscriberList(strNotifType, strSubscribers, "add");
            }

            JTXUtilities.SendNotification(strNotifType, m_ipDatabase, ipJob, null);

            if (bSubscribers)
            {
                UpdateSubscriberList(strNotifType, strSubscribers, "remove");
            }

            return(0);
        }
Exemplo n.º 3
0
        /// <summary>
        /// Method to validate the configured arguments for the step type.  The
        /// logic of this method depends on the implementation of the custom step
        /// but typically checks for proper argument names and syntax.
        /// </summary>
        /// <param name="argv">Array of arguments configured for the step type</param>
        /// <returns>Returns 'true' if arguments are valid, 'false' if otherwise</returns>
        public bool ValidateArguments(ref object[] argv)
        {
            IJTXConfiguration ipConfig = m_ipDatabase.ConfigurationManager;

            string strAssignType = "";
            string strAssignTo   = "";

            if (!StepUtilities.GetArgument(ref argv, m_expectedArgs[0], true, out strAssignType))
            {
                throw new ArgumentNullException(m_expectedArgs[0], string.Format("\nMissing the {0} parameter!", m_expectedArgs[0]));
            }

            if (!StepUtilities.GetArgument(ref argv, m_expectedArgs[1], true, out strAssignTo))
            {
                throw new ArgumentNullException(m_expectedArgs[1], string.Format("\nMissing the {0} parameter!", m_expectedArgs[1]));
            }

            if (strAssignType == "group")
            {
                if (ipConfig.GetUserGroup(strAssignTo) == null)
                {
                    throw new ArgumentOutOfRangeException(m_expectedArgs[1], string.Format("\nThe group {0} is not a group defined in the JTX database!", strAssignTo));
                }
            }
            else
            {
                if (ipConfig.GetUser(strAssignTo) == null)
                {
                    throw new ArgumentOutOfRangeException(m_expectedArgs[1], string.Format("\nThe user {0} is not a user defined in the JTX database!", strAssignTo));
                }
            }
            return(true);
        }
Exemplo n.º 4
0
        /// <summary>
        /// Method to validate the configured arguments for the step type.  The
        /// logic of this method depends on the implementation of the custom step
        /// but typically checks for proper argument names and syntax.
        /// </summary>
        /// <param name="argv">Array of arguments configured for the step type</param>
        /// <returns>Returns 'true' if arguments are valid, 'false' if otherwise</returns>
        public bool ValidateArguments(ref object[] argv)
        {
            string strValue = "";

            if (!StepUtilities.GetArgument(ref argv, m_expectedArgs[0], true, out strValue))
            {
                return(false);
            }
            return(StepUtilities.AreArgumentNamesValid(ref argv, m_expectedArgs));
        }
Exemplo n.º 5
0
        public DialogResult ShowDialog(object[] argsIn, out object[] argsOut)
        {
            // Populate the combo boxes with the appropriate information
            IJTXConfiguration2 ipJTXConfig = m_ipDatabase.ConfigurationManager as IJTXConfiguration2;

            PopulateJobTypes(ipJTXConfig);
            PopulateUsers(ipJTXConfig);
            PopulateGroups(ipJTXConfig);

            // Populate the dialog with the existing argument information
            string strTemp = "";

            if (StepUtilities.GetArgument(ref argsIn, m_expectedArgs[0], true, out strTemp))
            {
                // Then the job type has been entered
                int         iJobTypeID = Convert.ToInt32(strTemp);
                IJTXJobType ipJobType  = ipJTXConfig.GetJobTypeByID(iJobTypeID);

                cmbJobTypes.SelectedItem = ipJobType.Name;
            }

            if (StepUtilities.GetArgument(ref argsIn, m_expectedArgs[1], true, out strTemp))
            {
                // Then a user group has been selected for the new job assignment
                chkGroup.Checked       = true;
                chkUser.Checked        = false;
                cmbUsers.Enabled       = false;
                cmbGroups.SelectedItem = strTemp;
            }

            if (StepUtilities.GetArgument(ref argsIn, m_expectedArgs[2], true, out strTemp))
            {
                // Then a user has been selected for the new job assignment
                chkGroup.Checked      = false;
                chkUser.Checked       = true;
                cmbGroups.Enabled     = false;
                cmbUsers.SelectedItem = strTemp;
            }

            // Show the dialog
            this.ShowDialog();

            argsOut = m_Arguments.ToArray();

            return(DialogResult);
        }
Exemplo n.º 6
0
        /// <summary>
        /// Called when a step of this type is executed in the workflow.
        /// </summary>
        /// <param name="JobID">ID of the job being executed</param>
        /// <param name="StepID">ID of the step being executed</param>
        /// <param name="argv">Array of arguments passed into the step's execution</param>
        /// <param name="ipFeedback">Feedback object to return status messages and files</param>
        /// <returns>Return code of execution for workflow path traversal</returns>
        public int Execute(int jobID, int stepID, ref object[] argv, ref IJTXCustomStepFeedback ipFeedback)
        {
            if (jobID <= 0)
            {
                throw (new ArgumentOutOfRangeException("JobID", jobID, "Job ID must be a positive value"));
            }

            System.Diagnostics.Debug.Assert(m_ipDatabase != null);

            IJTXJob pJob     = m_ipDatabase.JobManager.GetJob(jobID);
            string  strValue = "";

            if (StepUtilities.GetArgument(ref argv, m_expectedArgs[0], true, out strValue) ||
                StepUtilities.GetArgument(ref argv, m_expectedArgs[1], true, out strValue))
            {
                if (pJob.VersionExists())
                {
                    pJob.DeleteVersion(null);
                }
            }

            if (StepUtilities.GetArgument(ref argv, m_expectedArgs[2], true, out strValue) ||
                StepUtilities.GetArgument(ref argv, m_expectedArgs[3], true, out strValue))
            {
                if (pJob.MXDExists())
                {
                    pJob.DeleteMXD();
                }
            }

            if (StepUtilities.GetArgument(ref argv, m_expectedArgs[4], true, out strValue) ||
                StepUtilities.GetArgument(ref argv, m_expectedArgs[5], true, out strValue))
            {
                IJTXAttachmentSet attachments = pJob.Attachments;
                for (int i = attachments.Count - 1; i >= 0; i--)
                {
                    int id = (attachments.get_Item(i).ID);
                    pJob.DeleteAttachment(id);
                }
            }

            return(0);
        }
Exemplo n.º 7
0
        /// <summary>
        /// Called when a step of this type is executed in the workflow.
        /// </summary>
        /// <param name="JobID">ID of the job being executed</param>
        /// <param name="StepID">ID of the step being executed</param>
        /// <param name="argv">Array of arguments passed into the step's execution</param>
        /// <param name="ipFeedback">Feedback object to return status messages and files</param>
        /// <returns>Return code of execution for workflow path traversal</returns>
        public int Execute(int jobID, int stepID, ref object[] argv, ref IJTXCustomStepFeedback ipFeedback)
        {
            IJTXJobManager    ipJobManager = m_ipDatabase.JobManager;
            IJTXConfiguration ipConfig     = m_ipDatabase.ConfigurationManager;
            IJTXJob           ipJob        = ipJobManager.GetJob(jobID);

            string strAssignType = "";
            string strAssignTo   = "";

            if (!StepUtilities.GetArgument(ref argv, m_expectedArgs[0], true, out strAssignType))
            {
                throw new ArgumentNullException(m_expectedArgs[0], string.Format("\nMissing the {0} parameter!", m_expectedArgs[0]));
            }

            if (!StepUtilities.GetArgument(ref argv, m_expectedArgs[1], true, out strAssignTo))
            {
                throw new ArgumentNullException(m_expectedArgs[1], string.Format("\nMissing the {0} parameter!", m_expectedArgs[1]));
            }

            if (strAssignType == "group")
            {
                if (ipConfig.GetUserGroup(strAssignTo) == null)
                {
                    throw new ArgumentOutOfRangeException(m_expectedArgs[1], string.Format("\nThe group {0} is not a group defined in the JTX database!", strAssignTo));
                }

                ipJob.AssignedType = jtxAssignmentType.jtxAssignmentTypeGroup;
            }
            else
            {
                if (ipConfig.GetUser(strAssignTo) == null)
                {
                    throw new ArgumentOutOfRangeException(m_expectedArgs[1], string.Format("\nThe user {0} is not a user defined in the JTX database!", strAssignTo));
                }

                ipJob.AssignedType = jtxAssignmentType.jtxAssignmentTypeUser;
            }

            ipJob.AssignedTo = strAssignTo;
            ipJob.Store();

            return(0);
        }
        /// <summary>
        /// Called when a step of this type is executed in the workflow.
        /// </summary>
        /// <param name="JobID">ID of the job being executed</param>
        /// <param name="StepID">ID of the step being executed</param>
        /// <param name="argv">Array of arguments passed into the step's execution</param>
        /// <param name="ipFeedback">Feedback object to return status messages and files</param>
        /// <returns>Return code of execution for workflow path traversal</returns>
        public int Execute(int jobID, int stepID, ref object[] argv, ref IJTXCustomStepFeedback ipFeedback)
        {
            // Get the arguments
            string sHoldTypeName = "";
            string sHoldRemarks  = "";

            bool bHoldType = StepUtilities.GetArgument(ref argv, "HoldType", true, out sHoldTypeName);

            if (!bHoldType)
            {
                MessageBox.Show("Invalid arguments entered. No hold type entered.");
                return(-1);
            }
            bool bHoldRemarks = StepUtilities.GetArgument(ref argv, "HoldRemarks", true, out sHoldRemarks);

            // Get the hold type
            IJTXConfiguration pJTXConfig = m_ipDatabase.ConfigurationManager;
            IJTXHoldType      pHoldType  = pJTXConfig.GetHoldType(sHoldTypeName);

            if (pHoldType == null)
            {
                MessageBox.Show("Invalid hold type name entered: " + sHoldTypeName);
                return(-1);
            }

            // Get the job
            IJTXJobManager pJobManager = m_ipDatabase.JobManager;
            IJTXJob        pJob        = pJobManager.GetJob(jobID);
            IJTXJobHolds   pJobHolds   = pJob as IJTXJobHolds;

            // Add new job hold
            IJTXJobHold pNewHold = pJobHolds.CreateHold(pHoldType);

            if (bHoldRemarks)
            {
                pNewHold.HoldComments = sHoldRemarks;
                pNewHold.Store();
            }

            return(0);
        }
        /// <summary>
        /// Called when a step of this type is executed in the workflow.
        /// </summary>
        /// <param name="JobID">ID of the job being executed</param>
        /// <param name="StepID">ID of the step being executed</param>
        /// <param name="argv">Array of arguments passed into the step's execution</param>
        /// <param name="ipFeedback">Feedback object to return status messages and files</param>
        /// <returns>Return code of execution for workflow path traversal</returns>
        public int Execute(int jobID, int stepID, ref object[] argv, ref IJTXCustomStepFeedback ipFeedback)
        {
            if (jobID <= 0)
            {
                throw (new ArgumentOutOfRangeException("JobID", jobID, "Job ID must be a positive value"));
            }

            System.Diagnostics.Debug.Assert(m_ipDatabase != null);

            IJTXJobManager pJobMan = m_ipDatabase.JobManager;
            IJTXJob2       pJob    = pJobMan.GetJob(jobID) as IJTXJob2;

            // Make sure all the information exists to create this verion
            if (pJob.ActiveDatabase == null)
            {
                System.Windows.Forms.MessageBox.Show("Job does not have a data workspace");
                return(-1);
            }
            if (pJob.ParentVersion == "")
            {
                System.Windows.Forms.MessageBox.Show("Job does not have a parent version");
                return(-1);
            }
            string strVersionNameOverride;
            bool   bVNOverride = StepUtilities.GetArgument(ref argv, m_expectedArgs[1], true, out strVersionNameOverride);

            if (pJob.VersionName == "" & !bVNOverride)
            {
                System.Windows.Forms.MessageBox.Show("The job does not have a version name");
                return(-1);
            }

            IVersion pNewVersion;
            string   strVersionName;

            if (bVNOverride)
            {
                strVersionName = strVersionNameOverride;
            }
            else
            {
                strVersionName = pJob.VersionName;
            }

            int index = strVersionName.IndexOf(".", 0);

            if (index >= 0)
            {
                strVersionName = strVersionName.Substring(index + 1);
            }

            esriVersionAccess verAccess   = esriVersionAccess.esriVersionAccessPrivate;
            string            strVerScope = "";

            if (StepUtilities.GetArgument(ref argv, m_expectedArgs[0], true, out strVerScope))
            {
                strVerScope = strVerScope.ToLower().Trim();

                if (strVerScope == "public")
                {
                    verAccess = esriVersionAccess.esriVersionAccessPublic;
                }
                else if (strVerScope == "protected")
                {
                    verAccess = esriVersionAccess.esriVersionAccessProtected;
                }
            }

            pJob.VersionName = strVersionName;
            pNewVersion      = pJob.CreateVersion(verAccess);

            if (pNewVersion == null)
            {
                throw (new System.SystemException("Unable to create version"));
            }

            IPropertySet pOverrides = new PropertySetClass();

            pOverrides.SetProperty("[VERSION]", pNewVersion.VersionName);
            IJTXActivityType pActType = m_ipDatabase.ConfigurationManager.GetActivityType(Constants.ACTTYPE_CREATE_VERSION);

            if (pActType != null)
            {
                pJob.LogJobAction(pActType, pOverrides, "");
            }

            JTXUtilities.SendNotification(Constants.NOTIF_VERSION_CREATED, m_ipDatabase, pJob, pOverrides);

            System.Runtime.InteropServices.Marshal.ReleaseComObject(pNewVersion);

            return(0);
        }
        static void Main(string[] args)
        {
            JTXReportNotification prog = new JTXReportNotification();

            if (prog.CheckoutLicense())
            {
                // Arguments list
                // /ReportID:<Report ID to execute>
                // /NotifType:<Notification type to send>
                // example: JTXReportNotification.exe /NotifType:ReportNotification /ReportID:401

                object[] pArgObjects = args as object[];

                // Get some variables ready
                int    iReportID             = 0;
                string sReportID             = "";
                string sNotificationTypeName = "";

                StepUtilities.GetArgument(ref pArgObjects, "ReportID", true, out sReportID);
                if (!int.TryParse(sReportID, out iReportID))
                {
                    Console.WriteLine("Invalid Report ID entered");
                    return;
                }
                StepUtilities.GetArgument(ref pArgObjects, "NotifType", true, out sNotificationTypeName);
                if (sNotificationTypeName == "")
                {
                    Console.WriteLine("A notification type must be entered.");
                }

                IJTXDatabaseManager jtxDBMan  = new JTXDatabaseManagerClass();
                IJTXDatabase        pJTXDB    = jtxDBMan.GetActiveDatabase(false);
                IJTXConfiguration2  jtxConfig = pJTXDB.ConfigurationManager as IJTXConfiguration2;

                string sReportOutput = prog.RunReport(jtxConfig, iReportID);

                // if there's output, send the notification
                if (sReportOutput != "")
                {
                    IJTXNotificationConfiguration pNotificationConfig = (IJTXNotificationConfiguration)jtxConfig;
                    IJTXNotificationType          pNotificationType   = pNotificationConfig.GetNotificationType(sNotificationTypeName);

                    if (pNotificationType == null)
                    {
                        Console.WriteLine("Please enter a valid notification type.");
                        return;
                    }

                    // Update the message
                    string sMessageBefore = pNotificationType.MessageTemplate;
                    pNotificationType.MessageTemplate = sReportOutput;
                    pNotificationType.Store();

                    // Send it!
                    JTXUtilities.SendNotification(sNotificationTypeName, pJTXDB, null, null);

                    // Set the message back.
                    pNotificationType.MessageTemplate = "";
                    pNotificationType.Store();
                }
                else
                {
                    Console.WriteLine("Please enter a valid report ID.");
                }

                prog.CheckinLicense();
            }
        }
        static void Main(string[] args)
        {
            // Convert the arguments to objects
            object[] argv = new object[args.Length];
            for (int i = 0; i < args.Length; i++)
            {
                argv[i] = args[i];
            }

            // Check if they want to display the usage message
            string tmpOut;

            if (StepUtilities.GetArgument(ref argv, "h", true, out tmpOut) || StepUtilities.GetArgument(ref argv, "?", true, out tmpOut))
            {
                PrintUsageMessage();
                return;
            }

            if (CheckoutLicense())
            {
                try
                {
                    IJTXDatabaseManager2 dbMgr = new JTXDatabaseManagerClass() as IJTXDatabaseManager2;
                    IJTXDatabase         ipDB  = null;
                    if (StepUtilities.GetArgument(ref argv, argNames[0], true, out tmpOut))
                    {
                        // Database was specified
                        try
                        {
                            ipDB = dbMgr.GetDatabase(tmpOut);
                        }
                        catch (COMException)
                        {
                            Console.WriteLine("{0} is not a valid Workflow Manager database alias", tmpOut);
                        }
                        Console.WriteLine("Using database {0}", tmpOut);
                    }
                    else
                    {
                        // Use the default database
                        Console.WriteLine("Using default database");
                        ipDB = dbMgr.GetActiveDatabase(false);
                    }

                    // Get the domain. If one is not specified, use the current domain
                    string strDomain;
                    if (StepUtilities.GetArgument(ref argv, argNames[1], true, out tmpOut))
                    {
                        strDomain = tmpOut;
                    }
                    else
                    {
                        strDomain = Environment.UserDomainName;
                    }

                    // Get the username
                    string strUsername = "";
                    if (StepUtilities.GetArgument(ref argv, argNames[2], true, out tmpOut))
                    {
                        strUsername = tmpOut;
                    }

                    // Get the password
                    string strPassword = "";
                    if (strUsername != "" && StepUtilities.GetArgument(ref argv, argNames[3], true, out tmpOut))
                    {
                        strPassword = tmpOut;
                    }

                    // Get the userGroup.  If one is not specified, check the registry for the value the UI stored
                    string strUserGroup;
                    if (StepUtilities.GetArgument(ref argv, argNames[4], true, out tmpOut))
                    {
                        strUserGroup = tmpOut;
                    }
                    else
                    {
                        strUserGroup = GetGroupFromReg("UserADGroup");
                    }

                    // Get the groupGroup.  If one is not specified, check the registry for the value the UI stored
                    string strGroupGroup;
                    if (StepUtilities.GetArgument(ref argv, argNames[5], true, out tmpOut))
                    {
                        strGroupGroup = tmpOut;
                    }
                    else
                    {
                        strGroupGroup = GetGroupFromReg("GroupADGroup");
                    }

                    if (String.IsNullOrEmpty(strUserGroup) || String.IsNullOrEmpty(strGroupGroup))
                    {
                        Console.WriteLine("Error: Empty userGroup or groupGroup");
                        return;
                    }

                    ConfigurationCache.InitializeCache(ipDB);

                    // Synchronize
                    int groupCount, userCount;
                    ActiveDirectoryHelper.SyncronizeJTXDatabaseWithActiveDirectory(ipDB, strDomain, strUsername, strPassword,
                                                                                   strUserGroup, strGroupGroup, out groupCount, out userCount);

                    Console.WriteLine("Successfully imported {0} users in {1} groups", userCount, groupCount);
                }
                catch (Exception e)
                {
                    Console.WriteLine("Failed with error: " + e.Message + e.StackTrace);
                }
                finally
                {
                    CheckinLicense();
                }
            }
            else
            {
                Console.WriteLine("Could not checkout license... exiting");
            }
        }
        static void Main(string[] args)
        {
            JTXOverdueNotification prog = new JTXOverdueNotification();

            if (prog.CheckoutLicense())
            {
                try
                {
                    // Arguments list
                    // /NotifType:<Notification type to send>
                    // example: JTXOverdueNotification.exe /NotifType:OverdueJob

                    object[] pArgObjects = args as object[];

                    // Get some variables ready
                    string sNotificationTypeName = "";

                    StepUtilities.GetArgument(ref pArgObjects, "NotifType", true, out sNotificationTypeName);
                    if (sNotificationTypeName == "")
                    {
                        Console.WriteLine("A notification type must be entered.");
                        return;
                    }

                    IJTXDatabaseManager jtxDBMan   = new JTXDatabaseManagerClass();
                    IJTXDatabase        pJTXDB     = jtxDBMan.GetActiveDatabase(false);
                    IJTXConfiguration   pJTXConfig = pJTXDB.ConfigurationManager;

                    // Create a simple query to find jobs that were due before today
                    IQueryFilter pQF = new QueryFilterClass();

                    // NOTE #1: Verify the date format matches your selected RDBMS
                    // NOTE #2: Verify the status id for 'Closed' with the JTX Administrator
                    pQF.WhereClause = "DUE_DATE < '" + DateTime.Today.ToString() + "'" + " AND STATUS <> 9";
                    Console.WriteLine(pQF.WhereClause);

                    // Get the notification type for the notification that will be sent
                    IJTXNotificationConfiguration pNotificationConfig = pJTXConfig as IJTXNotificationConfiguration;
                    IJTXNotificationType          pNotificationType   = pNotificationConfig.GetNotificationType(sNotificationTypeName);
                    if (pNotificationType == null)
                    {
                        Console.WriteLine("Please enter a valid notification type.");
                        return;
                    }

                    // Get the job manager to execute the query and find the jobs in question
                    IJTXJobManager pJobManager = pJTXDB.JobManager;
                    IJTXJobSet     pJobs       = pJobManager.GetJobsByQuery(pQF);

                    pJobs.Reset();
                    for (int a = 0; a < pJobs.Count; a++)
                    {
                        IJTXJob pJob = pJobs.Next();
                        Console.WriteLine(pJob.Name);

                        // Send it!
                        JTXUtilities.SendNotification(sNotificationTypeName, pJTXDB, pJob, null);
                    }
                }
                catch (Exception except)
                {
                    Console.WriteLine("An error occurred: " + except.Message);
                }
                prog.CheckinLicense();
                Console.WriteLine("Completed.");
            }
        }
Exemplo n.º 13
0
        /// <summary>
        /// Called when a step of this type is executed in the workflow.
        /// </summary>
        /// <param name="JobID">ID of the job being executed</param>
        /// <param name="StepID">ID of the step being executed</param>
        /// <param name="argv">Array of arguments passed into the step's execution</param>
        /// <param name="ipFeedback">Feedback object to return status messages and files</param>
        /// <returns>Return code of execution for workflow path traversal</returns>
        public int Execute(int JobID, int stepID, ref object[] argv, ref IJTXCustomStepFeedback ipFeedback)
        {
            if (JobID <= 0)
            {
                throw new ArgumentOutOfRangeException("JobID", JobID, "Job ID must be a positive value");
            }

            try
            {
                string strTemp = "";
                bool   bAttach = false;
                if (StepUtilities.GetArgument(ref argv, m_expectedArgs[1], false, out strTemp))
                {
                    bAttach = true;
                }

                string strResolution;
                if (!StepUtilities.GetArgument(ref argv, m_expectedArgs[2], false, out strResolution))
                {
                    strResolution = "1200";
                }

                int iResolution = 1200;
                if (!Int32.TryParse(strResolution, out iResolution))
                {
                    iResolution = 1200;
                }

                string outputPath = "";
                if (!bAttach)
                {
                    SaveFileDialog pSaveFileDialog = new SaveFileDialog();
                    pSaveFileDialog.Filter = "PDF files (*.pdf)|*.pdf";
                    pSaveFileDialog.Title  = "Choose output location...";

                    string strInitDir = "";
                    if (StepUtilities.GetArgument(ref argv, m_expectedArgs[0], true, out strInitDir))
                    {
                        if (System.IO.Directory.Exists(strInitDir))
                        {
                            pSaveFileDialog.InitialDirectory = strInitDir;
                        }
                    }

                    if (pSaveFileDialog.ShowDialog() != DialogResult.OK)
                    {
                        return(-1);
                    }

                    outputPath = pSaveFileDialog.FileName;
                }

                string inputPath = JTXUtilities.SaveJobMXD(JobID);

                if (bAttach)
                {
                    outputPath = SystemUtilities.GetTemporaryFileLocation(inputPath, "pdf");
                }

                // delete output file if it already exists
                System.IO.FileInfo fi = new System.IO.FileInfo(outputPath);
                if (fi.Exists)
                {
                    fi.Delete();
                }

                MapDocumentClass map = new MapDocumentClass();

                if (!map.get_IsMapDocument(inputPath))
                {
                    throw new ApplicationException("Invalid map or specified map not found.");
                }

                map.Open(inputPath, null);

                IActiveView pActiveView = (IActiveView)map.PageLayout;
                IExport     pExport     = new ExportPDFClass();

                pExport.ExportFileName = outputPath;

                tagRECT deviceFrameRect;
                deviceFrameRect.left   = 0;
                deviceFrameRect.right  = 800;
                deviceFrameRect.top    = 0;
                deviceFrameRect.bottom = 600;

                pActiveView.ScreenDisplay.DisplayTransformation.set_DeviceFrame(ref deviceFrameRect);

                int iOutputResolution = iResolution;
                int iScreenResolution = 96;
                pExport.Resolution = iOutputResolution;
                IOutputRasterSettings pOutputRasterSettings = (IOutputRasterSettings)pExport;
                pOutputRasterSettings.ResampleRatio = 1;

                tagRECT exportRect;

                exportRect.left   = pActiveView.ExportFrame.left * (iOutputResolution / iScreenResolution);
                exportRect.top    = pActiveView.ExportFrame.top * (iOutputResolution / iScreenResolution);
                exportRect.right  = pActiveView.ExportFrame.right * (iOutputResolution / iScreenResolution);
                exportRect.bottom = pActiveView.ExportFrame.bottom * (iOutputResolution / iScreenResolution);

                IEnvelope pPixelBoundsEnv = new EnvelopeClass();

                pPixelBoundsEnv.PutCoords(exportRect.left, exportRect.top, exportRect.right, exportRect.bottom);
                pExport.PixelBounds = pPixelBoundsEnv;

                int hdc = pExport.StartExporting();
                pActiveView.Output(hdc, iOutputResolution, ref exportRect, null, null);
                pExport.FinishExporting();
                pExport.Cleanup();

                if (bAttach)
                {
                    JTXUtilities.AddAttachmentToJob(JobID, outputPath, jtxFileStorageType.jtxStoreInDB);
                }

                return(0);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
        ////////////////////////////////////////////////////////////////////////
        // METHOD: GetInputParams
        private bool GetInputParams(object [] argv)
        {
            string sTemp = "";

            // Job Type
            StepUtilities.GetArgument(ref argv, m_ExpectedArgs[0], true, out m_paramJobTypeName);

            // Job Assignment
            StepUtilities.GetArgument(ref argv, m_ExpectedArgs[1], true, out m_paramAssignToGroup);
            StepUtilities.GetArgument(ref argv, m_ExpectedArgs[2], true, out m_paramAssignToUser);

            // Job Dependencies
            m_paramDependThisStep = StepUtilities.GetArgument(ref argv, m_ExpectedArgs[3], true, out sTemp);
            m_paramDependNextStep = StepUtilities.GetArgument(ref argv, m_ExpectedArgs[4], true, out sTemp);
            m_paramHasStatusType  = StepUtilities.GetArgument(ref argv, m_ExpectedArgs[5], true, out m_paramStatusType);

            // Number of Jobs and AOI Definition
            m_paramUseParentAOI = StepUtilities.GetArgument(ref argv, m_ExpectedArgs[6], true, out sTemp);
            StepUtilities.GetArgument(ref argv, m_ExpectedArgs[7], true, out m_AOIOverlapFeatureClassName);
            if (StepUtilities.GetArgument(ref argv, m_ExpectedArgs[8], true, out sTemp))
            {
                m_paramNumberChildJobs = Convert.ToInt16(sTemp);
            }

            // Versioning
            StepUtilities.GetArgument(ref argv, m_ExpectedArgs[9], true, out sTemp);
            if (string.IsNullOrEmpty(sTemp))
            {
                m_paramCreateVersionType = CreateVersionType.None;
            }
            else if (sTemp.Equals("The parent job's version"))
            {
                m_paramCreateVersionType = CreateVersionType.UseParentJobsVersion;
            }
            else if (sTemp.Equals("The parent job's parent version"))
            {
                m_paramCreateVersionType = CreateVersionType.UseParentJobsParentVersion;
            }
            else if (sTemp.Equals("The parent job's DEFAULT version"))
            {
                m_paramCreateVersionType = CreateVersionType.UseParentJobsDefaultVersion;
            }
            else if (sTemp.Equals("The job type's default properties parent version"))
            {
                m_paramCreateVersionType = CreateVersionType.UseJobTypeDefaultSettings;
            }

            StepUtilities.GetArgument(ref argv, m_ExpectedArgs[10], true, out sTemp);
            if (string.IsNullOrEmpty(sTemp))
            {
                m_paramAssignVersionType = AssignVersionType.None;
            }
            else if (sTemp.Equals("The parent job's version"))
            {
                m_paramAssignVersionType = AssignVersionType.UseParentJobsVersion;
            }

            // Extended Properties
            StepUtilities.GetArgument(ref argv, m_ExpectedArgs[11], true, out m_paramExtendedProperties);

            StepUtilities.GetArgument(ref argv, m_ExpectedArgs[12], true, out sTemp);
            if (!String.IsNullOrEmpty(sTemp))
            {
                m_dueDate = JTXUtilities.GenerateDateString(m_ipDatabase.JTXWorkspace, sTemp, false);
            }

            StepUtilities.GetArgument(ref argv, m_ExpectedArgs[13], true, out sTemp);
            if (!String.IsNullOrEmpty(sTemp))
            {
                int.TryParse(sTemp, out m_duration);
            }

            return(true);
        }
Exemplo n.º 15
0
        /// <summary>
        /// Called when a step of this type is executed in the workflow.
        /// </summary>
        /// <param name="JobID">ID of the job being executed</param>
        /// <param name="StepID">ID of the step being executed</param>
        /// <param name="argv">Array of arguments passed into the step's execution</param>
        /// <param name="ipFeedback">Feedback object to return status messages and files</param>
        /// <returns>Return code of execution for workflow path traversal</returns>
        public int Execute(int JobID, int stepID, ref object[] argv, ref IJTXCustomStepFeedback ipFeedback)
        {
            System.Diagnostics.Debug.Assert(m_ipDatabase != null);

            string strValue  = "";
            int    jobTypeID = 0;

            if (!StepUtilities.GetArgument(ref argv, m_expectedArgs[0], true, out strValue))
            {
                throw new ArgumentNullException(m_expectedArgs[0], string.Format("\nMissing the {0} parameter!", m_expectedArgs[0]));
            }

            if (!Int32.TryParse(strValue, out jobTypeID))
            {
                throw new ArgumentNullException(m_expectedArgs[0], "Argument must be an integrer!");
            }

            IJTXJobType    pJobType = m_ipDatabase.ConfigurationManager.GetJobTypeByID(jobTypeID);
            IJTXJobManager pJobMan  = m_ipDatabase.JobManager;
            IJTXJob        pNewJob  = pJobMan.CreateJob(pJobType, 0, true);

            IJTXActivityType pActType = m_ipDatabase.ConfigurationManager.GetActivityType(Constants.ACTTYPE_CREATE_JOB);

            if (pActType != null)
            {
                pNewJob.LogJobAction(pActType, null, "");
            }

            JTXUtilities.SendNotification(Constants.NOTIF_JOB_CREATED, m_ipDatabase, pNewJob, null);

            // Assign a status to the job if the Auto Assign Job Status setting is enabled
            IJTXConfigurationProperties pConfigProps = (IJTXConfigurationProperties)m_ipDatabase.ConfigurationManager;

            if (pConfigProps.PropertyExists(Constants.JTX_PROPERTY_AUTO_STATUS_ASSIGN))
            {
                string strAutoAssign = pConfigProps.GetProperty(Constants.JTX_PROPERTY_AUTO_STATUS_ASSIGN);
                if (strAutoAssign == "TRUE")
                {
                    pNewJob.Status = m_ipDatabase.ConfigurationManager.GetStatus("Created");
                }
            }

            // Associate the current job with the new job with a parent-child relationship
            pNewJob.ParentJob = JobID;

            // Assign the job as specified in the arguments
            string strAssignTo = "";

            if (StepUtilities.GetArgument(ref argv, m_expectedArgs[1], true, out strAssignTo))
            {
                pNewJob.AssignedType = jtxAssignmentType.jtxAssignmentTypeGroup;
                pNewJob.AssignedTo   = strAssignTo;
            }
            else if (StepUtilities.GetArgument(ref argv, m_expectedArgs[2], true, out strAssignTo))
            {
                pNewJob.AssignedType = jtxAssignmentType.jtxAssignmentTypeUser;
                pNewJob.AssignedTo   = strAssignTo;
            }
            pNewJob.Store();

            // Copy the workflow to the new job
            WorkflowUtilities.CopyWorkflowXML(m_ipDatabase, pNewJob);

            // Create 1-1 extended property entries
            IJTXAuxProperties pAuxProps = (IJTXAuxProperties)pNewJob;

            System.Array contNames     = pAuxProps.ContainerNames;
            IEnumerator  contNamesEnum = contNames.GetEnumerator();

            contNamesEnum.Reset();

            while (contNamesEnum.MoveNext())
            {
                string strContainerName = (string)contNamesEnum.Current;
                IJTXAuxRecordContainer pAuxContainer = pAuxProps.GetRecordContainer(strContainerName);
                if (pAuxContainer.RelationshipType == esriRelCardinality.esriRelCardinalityOneToOne)
                {
                    pAuxContainer.CreateRecord();
                }
            }

            m_ipDatabase.LogMessage(5, 1000, System.Diagnostics.Process.GetCurrentProcess().MainWindowTitle);

            // Update Application message about the new job
            if (System.Diagnostics.Process.GetCurrentProcess().MainWindowTitle.Length > 0) //if its not running in server
            {
                MessageBox.Show("Created " + pJobType.Name + " Job " + pNewJob.ID, "Job Created", MessageBoxButtons.OK, MessageBoxIcon.Information);
            }

            return(0);
        }
Exemplo n.º 16
0
        public DialogResult ShowDialog(object[] argsIn, out object[] argsOut)
        {
            // Populate the combo boxes with the appropriate information
            IJTXConfiguration2 ipJTXConfig = m_ipDatabase.ConfigurationManager as IJTXConfiguration2;

            PopulateJobTypes(ipJTXConfig);
            PopulateUsers(ipJTXConfig);
            PopulateGroups(ipJTXConfig);
            PopulateStatusTypes(ipJTXConfig);

            // Populate the dialog with the existing argument information
            string strTemp = "";

            if (StepUtilities.GetArgument(ref argsIn, m_expectedArgs[0], true, out strTemp))
            {
                // Then the job type has been entered
                IJTXJobType ipJobType = ipJTXConfig.GetJobType(strTemp);

                if (ipJobType != null)
                {
                    cmbJobTypes.SelectedItem = ipJobType.Name;
                }
            }

            if (StepUtilities.GetArgument(ref argsIn, m_expectedArgs[1], true, out strTemp))
            {
                // Then a user group has been selected for the new job assignment
                chkGroup.Checked = true;
                chkUser.Checked  = false;
                cmbUsers.Enabled = false;
                int idx = cmbGroups.Items.IndexOf(strTemp);
                cmbGroups.SelectedIndex = idx;
                if (idx < 0)
                {
                    cmbGroups.Text = strTemp;
                }
            }

            if (StepUtilities.GetArgument(ref argsIn, m_expectedArgs[2], true, out strTemp))
            {
                // Then a user has been selected for the new job assignment
                chkGroup.Checked  = false;
                chkUser.Checked   = true;
                cmbGroups.Enabled = false;
                int idx = cmbUsers.Items.IndexOf(strTemp);
                cmbUsers.SelectedIndex = idx;
                if (idx < 0)
                {
                    cmbUsers.Text = strTemp;
                }
            }

            if (StepUtilities.GetArgument(ref argsIn, m_expectedArgs[3], true, out strTemp))
            {
                // Then a dependency is being created ...
                chkDependThisStep.Checked  = true;
                lblStatus.Enabled          = true;
                cboDependentStatus.Enabled = true;
            }

            if (StepUtilities.GetArgument(ref argsIn, m_expectedArgs[4], true, out strTemp))
            {
                // Then a dependency is being created ...
                chkDependNextStep.Checked  = true;
                lblStatus.Enabled          = true;
                cboDependentStatus.Enabled = true;
            }

            if (StepUtilities.GetArgument(ref argsIn, m_expectedArgs[5], true, out strTemp))
            {
                // Then a user has been selected for the new job assignment
                lblStatus.Enabled = true;
                lblStatus.Enabled = true;
                cboDependentStatus.SelectedItem = strTemp;
            }

            if (StepUtilities.GetArgument(ref argsIn, m_expectedArgs[6], true, out strTemp))
            {
                // Then the parent job's AOI will be used by the child
                chkAssignParentAOIToChild.Checked = true;
            }
            if (StepUtilities.GetArgument(ref argsIn, m_expectedArgs[7], true, out strTemp))
            {
                // Then the number of child jobs and their AOIs will be determined by a
                // spatial overlap with an input feature class
                chkAssignParentAOIToChild.Enabled = false;

                radioButton_generateNumberJobs.Checked = true;
                txtAOIFeatureClassName.Enabled         = true;
                txtAOIFeatureClassName.Text            = strTemp;
            }
            if (StepUtilities.GetArgument(ref argsIn, m_expectedArgs[8], true, out strTemp))
            {
                // Then the user will specify the number of child jobs
                txtAOIFeatureClassName.Enabled = false;

                radioButton_DefineNumberOfJobs.Checked = true;
                lstNumberOfJobs.Value             = Convert.ToDecimal(strTemp);
                chkAssignParentAOIToChild.Enabled = true;
            }
            if (StepUtilities.GetArgument(ref argsIn, m_expectedArgs[9], true, out strTemp))
            {
                // Then a version will be created for the child job(s) from the Default version
                chkCreateVersion.Checked        = true;
                cboCreateVersionSetting.Enabled = true;
                int idx = cboCreateVersionSetting.Items.IndexOf(strTemp);
                cboCreateVersionSetting.SelectedIndex = idx;
                if (idx < 0)
                {
                    cboCreateVersionSetting.Text = strTemp;
                }
            }
            if (StepUtilities.GetArgument(ref argsIn, m_expectedArgs[10], true, out strTemp))
            {
                // Then a version will be created for the child job(s) from the Default version
                chkAssignVersion.Checked        = true;
                cboAssignVersionSetting.Enabled = true;
                int idx = cboAssignVersionSetting.Items.IndexOf(strTemp);
                cboAssignVersionSetting.SelectedIndex = idx;
                if (idx < 0)
                {
                    cboAssignVersionSetting.Text = strTemp;
                }
            }
            if (StepUtilities.GetArgument(ref argsIn, m_expectedArgs[11], true, out strTemp))
            {
                // Then the user will not be able to modify any parameters that were pre-configured
                chkSetExtProps.Checked = true;
                txtSetExtProps.Text    = strTemp;
            }

            if (StepUtilities.GetArgument(ref argsIn, m_expectedArgs[12], true, out strTemp))
            {
                chkDueDate.Checked = true;
                dtpDueDate.Value   = JTXUtilities.GenerateDateString(m_ipDatabase.JTXWorkspace, strTemp, false);
            }
            else if (StepUtilities.GetArgument(ref argsIn, m_expectedArgs[13], true, out strTemp))
            {
                txtDuration.Text = strTemp;
            }

            // Show the dialog
            this.ShowDialog();

            argsOut = m_Arguments.ToArray();

            return(DialogResult);
        }