DDC - VR LL-SL Lookup - 452 - Copy.cs

// Skeleton generated by Hyland Unity Editor on 3/30/2017 12:35:32 PM
namespace SYSFindLicEaseBoardComplainantSubject
{
    using System;
    using System.Text;
    using System.Data;
    using System.Data.Odbc;
    using Hyland.Unity;

    /// <summary>
    /// Query LicEase for Boad, Complainant, and Subject based on Case Number and License Type
    /// </summary>
    public class HRInspectionLookup : IWorkflowScript
    {
        #region User-Configurable Script Settings
        // Script name for diagnostics logging
        private const string ScriptName = "452 - DDC - VR LL-SL Lookup";

        // Diagnostics logging level - set to Verbose for testing, Error for production
        private const Diagnostics.DiagnosticsLevel DiagLevel = Diagnostics.DiagnosticsLevel.Verbose;

        // Workflow property where error message will be stored
        private const string ErrorMessageProperty = "UnityError";

        // If true, errors will be added to document history
        private const bool WriteErrorsToHistory = true;

        // Date/Time format for diagnostics logging
        private const string DateTimeFormat = "MM-dd-yyyy HH:mm:ss.fff";
        
        private const string gSaveToDBA = "DBA";
        private const string gSaveToCounty = "County";
        private const string gSaveToLocationAddress = "Description";

        private const string gParamLicType = "License Type";
        private const string gParamFileNum = "File Number";

        #endregion

        /***********************************************
         * USER/SE: PLEASE DO NOT EDIT BELOW THIS LINE *
         ***********************************************/

        #region Private Globals
        // Active workflow document
        private Document _currentDocument;
        #endregion

        #region IWorkflowScript
        /// <summary>
        /// Implementation of <see cref="IWorkflowScript.OnWorkflowScriptExecute" />.
        /// <seealso cref="IWorkflowScript" />
        /// </summary>
        /// <param name="app"></param>
        /// <param name="args"></param>
        public void OnWorkflowScriptExecute(Hyland.Unity.Application app, Hyland.Unity.WorkflowEventArgs args)
        {
            try
            {
                // Initialize global settings
                IntializeScript(ref app, ref args);

                //get and clean LicenseType and Case # keywords for passing to LicEase database
                KeywordType kwtLicNum = _currentDocument.DocumentType.KeywordRecordTypes.FindKeywordType(gParamFileNum);
                string strFileNum = "";
                if (kwtLicNum != null)
                {
                    KeywordRecord keyRecLicNum = _currentDocument.KeywordRecords.Find(kwtLicNum);
                    if (keyRecLicNum != null)
                    {
                        Keyword kwdLicNum = keyRecLicNum.Keywords.Find(kwtLicNum);
                        if (kwdLicNum != null)
                            strFileNum = CleanSeedKW(kwdLicNum.ToString());
                    }
                }
                KeywordType kwtLicenseType = _currentDocument.DocumentType.KeywordRecordTypes.FindKeywordType(gParamLicType);
                string strLicenseType = "";
                if (kwtLicenseType != null)
                {
                    KeywordRecord keyRecLicenseType = _currentDocument.KeywordRecords.Find(kwtLicenseType);
                    if (keyRecLicenseType != null)
                    {
                        Keyword kwdLicenseType = keyRecLicenseType.Keywords.Find(kwtLicenseType);
                        if (kwdLicenseType != null)
                            strLicenseType = CleanSeedKW(kwdLicenseType.ToString());
                    }
                }

                if (strFileNum == "")
                {
                    throw new Exception(string.Format("Search keyword {0} is blank.", gSaveToDBA));
                }

                if (strLicenseType == "")
                {
                    throw new Exception(string.Format("Search keyword {0} is blank.", gParamLicType));
                }

                //access Config Item for LicEase User
                string gUSER = "";
                if (app.Configuration.TryGetValue("LicEaseUser", out gUSER))
                {
                }

                //access Config Item for LicEase Password
                string gPASS = "";
                if (app.Configuration.TryGetValue("LicEasePassword", out gPASS))
                {
                }

				//access Config Item for LicEase PROD ODBC
				string gODBC = "";
				if (app.Configuration.TryGetValue("LicEasePROD", out gODBC))
				{
				}

                string connectionString = string.Format("DSN={0};Uid={1};Pwd={2};", gODBC, gUSER, gPASS);
                app.Diagnostics.WriteIf(Diagnostics.DiagnosticsLevel.Verbose, string.Format("Connection string: {0}", connectionString));

                StringBuilder strSql = new StringBuilder();
                strSql.Append(@"select (select n.key_nme from link l, clnt_link_typ clt, link_typ lt, name n where c.lic_id = l.prnt_id and l.link_prnt_cde = 'L' and l.curr_ind = 'Y' and l.clnt_link_typ_id = clt.clnt_link_typ_id ");
                strSql.Append(@" and clt.link_typ_id = lt.link_typ_id and lt.link_typ_cde = 'DBA' and l.nme_id = n.nme_id and n.ent_nme_typ = 'D' and n.cur_nme_ind = 'Y') as DBA,");
                strSql.Append(@" nvl((select trim(a.str_addr_nbr||' '||a.addr_line1||' '||a.addr_line2||' '||a.addr_line3||' '||a.addr_cty||', '||a.st_cde||' '||a.addr_zip) ");
                strSql.Append(@" from link l, clnt_link_typ clt, link_typ lt, addr a where c.lic_id = l.prnt_id and l.link_prnt_cde = 'L' and l.curr_ind = 'Y' and l.clnt_link_typ_id = clt.clnt_link_typ_id ");
                strSql.Append(@" and clt.link_typ_id = lt.link_typ_id and lt.link_typ_cde = 'SL' and l.addr_id = a.addr_id), ");
                strSql.Append(@" (select trim(a.str_addr_nbr||' '||a.addr_line1||' '||a.addr_line2||' '||a.addr_line3||' '||a.addr_cty||', '||a.st_cde||' '||a.addr_zip) ");
                strSql.Append(@" from link l, clnt_link_typ clt, link_typ lt, addr a where c.lic_id = l.prnt_id and l.link_prnt_cde = 'L' and l.curr_ind = 'Y' and l.clnt_link_typ_id = clt.clnt_link_typ_id ");
                strSql.Append(@" and clt.link_typ_id = lt.link_typ_id and lt.link_typ_cde = 'LL' and l.addr_id = a.addr_id)) as LocationAddress, nvl((select y.cnty_desc from link l, clnt_link_typ clt, link_typ lt, addr a, cnty y ");
                strSql.Append(@" where c.lic_id = l.prnt_id and l.link_prnt_cde = 'L' and l.curr_ind = 'Y' and l.clnt_link_typ_id = clt.clnt_link_typ_id and clt.link_typ_id = lt.link_typ_id");
                strSql.Append(@" and lt.link_typ_cde = 'SL' and l.addr_id = a.addr_id and a.cnty = y.cnty), (select y.cnty_desc from link l, clnt_link_typ clt, link_typ lt, addr a, cnty y where c.lic_id = l.prnt_id");
                strSql.Append(@" and l.link_prnt_cde = 'L' and l.curr_ind = 'Y' and l.clnt_link_typ_id = clt.clnt_link_typ_id and clt.link_typ_id = lt.link_typ_id and lt.link_typ_cde = 'LL'");
                strSql.Append(@" and l.addr_id = a.addr_id and a.cnty = y.cnty)) as LocationCounty from lic c where c.clnt_cde = '");
                strSql.Append(strLicenseType);
                strSql.Append(@"' and c.file_nbr = '");
                strSql.Append(strFileNum);
                strSql.Append(@"'");

                app.Diagnostics.WriteIf(Diagnostics.DiagnosticsLevel.Verbose, string.Format("Sql Query: {0}", strSql.ToString()));

                using (OdbcConnection con = new OdbcConnection(connectionString))
                {
                    try
                    {
                        con.Open();
                        using (OdbcCommand command = new OdbcCommand(strSql.ToString(), con))
                        using (OdbcDataReader reader = command.ExecuteReader())
                        {
                            if (reader.HasRows)
                            {
                                string strDBA = "";
                                string strCounty = "";
                                string strDesc = "";

                                reader.Read();

                                strDesc = reader["LocationAddress"].ToString();
                                strDBA = reader["DBA"].ToString();
                                strCounty = reader["LocationCounty"].ToString();
                                
                                Keyword kwdDesc = null;
                                if (!String.IsNullOrEmpty(strDesc))
                                {
                                    KeywordType kwtDesc = app.Core.KeywordTypes.Find(gSaveToLocationAddress);
                                    if (kwtDesc != null)
                                        kwdDesc = CreateKeywordHelper(kwtDesc, strDesc);
                                }

                                Keyword kwdDBA = null;
                                if (!String.IsNullOrEmpty(strDBA))
                                {
                                    KeywordType kwtDBA = app.Core.KeywordTypes.Find(gSaveToDBA);
                                    if (kwtDBA != null)
                                        kwdDBA = CreateKeywordHelper(kwtDBA, strDBA);
                                }

                                Keyword kwdCounty = null;
                                if (!String.IsNullOrEmpty(strCounty))
                                {
                                    KeywordType kwtCounty = app.Core.KeywordTypes.Find(gSaveToCounty);
                                    if (kwtCounty != null)
                                        kwdCounty = CreateKeywordHelper(kwtCounty, strCounty);
                                }

                                using (DocumentLock documentLock = _currentDocument.LockDocument())
                                {
                                    // Ensure lock was obtained
                                    if (documentLock.Status != DocumentLockStatus.LockObtained)
                                    {
                                        throw new Exception("Document lock not obtained");
                                    }
                                    // Create keyword modifier object to hold keyword changes
                                    KeywordModifier keyModifier = _currentDocument.CreateKeywordModifier();

                                    // Add update keyword call to keyword modifier object
                                    //Note Overloads available for use
                                    //(I.E.): keyModifier.AddKeyword(keywordTypeName,keywordValue)
                                    if (kwdDesc != null) keyModifier.AddKeyword(kwdDesc);
                                    if (kwdDBA != null) keyModifier.AddKeyword(kwdDBA);
                                    if (kwdCounty != null) keyModifier.AddKeyword(kwdCounty);

                                    // Apply keyword change to the document
                                    keyModifier.ApplyChanges();

                                    string output = String.Format("Keyword: '{0}' Value: '{1}', {7}Keyword: '{2}' Value: '{3}', {7}Keyword: '{4}' Value: '{5}', {7}added to Document {6}.",
                                        gSaveToDBA, strDBA, gSaveToLocationAddress, strDesc, gSaveToCounty, strCounty, _currentDocument.ID, Environment.NewLine);
                                    //Output the results to the OnBase Diagnostics Console
                                    app.Diagnostics.WriteIf(Hyland.Unity.Diagnostics.DiagnosticsLevel.Verbose, output);

                                    documentLock.Release();
                                }
                            }
                            else
                            {
                                throw new Exception(string.Format("No records found in database"));
                            }
                        }
                    }
                    catch (Exception ex)
                    {
                        throw new ApplicationException("Error during database operations!", ex);
                    }
                    finally
                    {
                        if (con.State == ConnectionState.Open) con.Close();
                    }
                }
            }
            catch (Exception ex)
            {
                // Handle exceptions and log to Diagnostics Console and document history
                HandleException(ex, ref app, ref args);
            }
            finally
            {
                // Log script execution end
                app.Diagnostics.WriteIf(Diagnostics.DiagnosticsLevel.Info,
                    string.Format("End Script - [{0}]", ScriptName));
            }
        }
        #endregion

        #region Helper Functions
        /// <summary>
        /// Initialize global settings
        /// </summary>
        /// <param name="app">Unity Application object</param>
        /// <param name="args">Workflow event arguments</param>
        private void IntializeScript(ref Application app, ref WorkflowEventArgs args)
        {
            // Set the specified diagnostics level
            app.Diagnostics.Level = DiagLevel;

            // Log script execution start
            app.Diagnostics.WriteIf(Diagnostics.DiagnosticsLevel.Info,
                string.Format("{0} - Start Script - [{1}]", DateTime.Now.ToString(DateTimeFormat), ScriptName));

            // Capture active document as global
            _currentDocument = args.Document;
            //  _currentDocument = app.Core.GetDocumentByID(TestDocId);
            // If an error was stored in the property bag from a previous execution, clear it
            if (args.SessionPropertyBag.ContainsKey(ErrorMessageProperty)) args.SessionPropertyBag.Remove(ErrorMessageProperty);

            // Set ScriptResult = true for workflow rules (will become false if an error is caught)
            args.ScriptResult = true;
        }

        /// <summary>
        /// Handle exceptions and log to Diagnostics Console and document history
        /// </summary>
        /// <param name="ex">Exception</param>
        /// <param name="app">Unity Application object</param>
        /// <param name="args">Workflow event arguments</param>
        /// <param name="otherDocument">Document on which to update history if not active workflow document</param>
        private void HandleException(Exception ex, ref Application app, ref WorkflowEventArgs args, Document otherDocument = null)
        {
            var history = app.Core.LogManagement;
            bool isInner = false;

            // Cycle through all inner exceptions
            while (ex != null)
            {
                // Construct error text to store to workflow property
                string propertyError = string.Format("{0}{1}: {2}",
                    isInner ? "Inner " : "",
                    ex.GetType().Name,
                    ex.Message);

                // Construct error text to store to document history
                string historyError = propertyError.Replace(ex.GetType().Name, "Unity Script Error");

                // Construct error text to log to diagnostics console
                string diagnosticsError = string.Format("{0} - ***ERROR***{1}{2}{1}{1}Stack Trace:{1}{3}",
                    DateTime.Now.ToString(DateTimeFormat),
                    Environment.NewLine,
                    propertyError,
                    ex.StackTrace);

                // Add error message to document history (on current or specified document)
                var document = otherDocument ?? _currentDocument;
                if (document != null && WriteErrorsToHistory) history.CreateDocumentHistoryItem(document, historyError);

                // Write error message to Diagnostcs Consonle
                app.Diagnostics.WriteIf(Diagnostics.DiagnosticsLevel.Error, diagnosticsError);

                // Store the original (inner) exception message to error workflow property
                if (ex.InnerException == null) args.SessionPropertyBag.Set(ErrorMessageProperty, ex.Message);

                // Move on to next inner exception
                ex = ex.InnerException;
                isInner = true;
            }

            // Set ScriptResult = false for workflow rules
            args.ScriptResult = false;
        }

        /// <summary>
        /// Clean Seed Keyword
        /// </summary>
        /// <param name="pValue">Keyword Value</param>
        private string CleanSeedKW(string pValue)
        {
            string temp = pValue;
            StringBuilder newString = new StringBuilder();

            int firstSpace = pValue.IndexOf(" ");
            if (firstSpace > 0)
            {
                temp = pValue.Substring(0, firstSpace);
                foreach (char c in temp)
                {
                    if (((c >= '0') && (c <= '9')) || ((c >= 'A') && (c <= 'Z')))
                    {
                        newString.Append(c);
                    }
                    else
                    {
                        newString.Append(" ");
                    }
                }
                newString = newString.Replace(" ", "");
                newString = newString.Replace("'", "''");
                return newString.ToString();
            }
            else
            {
                return pValue.ToString();
            }
        }
        private Keyword CreateKeywordHelper(KeywordType Keytype, string Value)
        {
            Keyword key = null;
            switch (Keytype.DataType)
            {
                case KeywordDataType.Currency:
                case KeywordDataType.Numeric20:
                    decimal decVal = decimal.Parse(Value);
                    key = Keytype.CreateKeyword(decVal);
                    break;
                case KeywordDataType.Date:
                case KeywordDataType.DateTime:
                    DateTime dateVal = DateTime.Parse(Value);
                    key = Keytype.CreateKeyword(dateVal);
                    break;
                case KeywordDataType.FloatingPoint:
                    double dblVal = double.Parse(Value);
                    key = Keytype.CreateKeyword(dblVal);
                    break;
                case KeywordDataType.Numeric9:
                    long lngVal = long.Parse(Value);
                    key = Keytype.CreateKeyword(lngVal);
                    break;
                default:
                    key = Keytype.CreateKeyword(Value);
                    break;
            }
            return key;
        }
        #endregion
    }
}