示例#1
0
        // Open document for Location and Name
        //
        public static void OpenDocument(string Location, string Name, string Type, object vkReadOnly)
        {
            if (Type == Utils.DocumentType.WORD)
            {
                string filePathName =
                    Utils.getFilePathName(Location,
                                          Name);

                WordDocumentTasks.OpenDocument(filePathName, vkReadOnly);
            }

            if (Type == Utils.DocumentType.EXCEL)
            {
                string filePathName =
                    Utils.getFilePathName(Location,
                                          Name);

                var Response = ExcelSpreadsheetTasks.OpenDocument(filePathName);
                if (Response.ReturnCode < 1)
                {
                    MessageBox.Show(Response.Message);
                }
            }
            if (Type == Utils.DocumentType.PDF)
            {
                string filePathName =
                    Utils.getFilePathName(Location,
                                          Name);
                System.Diagnostics.Process proc = new System.Diagnostics.Process();
                var adobe = CodeValue.GetCodeValueExtended(iCodeType: FCMConstant.CodeTypeString.SYSTSET, iCodeValueID: "PDFEXEPATH");

                if (!File.Exists(adobe))
                {
                    MessageBox.Show("I can't find Adobe Reader. Please configure SYSTSET.PDFEXTPATH.");
                    return;
                }

                proc.StartInfo.FileName  = adobe;
                proc.StartInfo.Arguments = filePathName;
                proc.Start();
            }
        }
示例#2
0
        /// <summary>
        /// Generate one document
        /// </summary>
        /// <param name="doco"></param>
        public void GenerateDocument(scClientDocSetDocLink doco)
        {
            // Retrieve latest version
            //
            Document.Document document = new Document.Document();
            document.UID = doco.clientDocument.FKDocumentUID;
            document.Read();

            string msg = ">>> Generating file: " + document.UID + " === " + document.SimpleFileName;

            if (uioutput != null)
            {
                uioutput.AddOutputMessage(msg);
            }
            // if (iconMessage != null) iconMessage.Text = ">>> Generating file: " + document.UID;


            // Locate source file
            //
            string sourceFileLocationName = Utils.getFilePathName(
                doco.clientDocument.SourceLocation,
                doco.clientDocument.SourceFileName);

            // Find the parent folder location
            //
            int            parentUID = doco.clientDocument.ParentUID;
            ClientDocument cdParent  = new ClientDocument();

            cdParent.UID = parentUID;
            cdParent.Read();

            // This is the client destination folder (and name)
            //
            //ResponseStatus destLocationDerivedClient = ClientDocument.GetDocumentPath(doco.clientDocument);
            //string destLocationDerived = destLocationDerivedClient.Contents.ToString();

            string clientDestinationFileLocation = doco.clientDocument.Location.Trim();

            string clientDestinationFileLocationName = Utils.getFilePathName(
                clientDestinationFileLocation, doco.clientDocument.FileName.Trim());

            // This is the source client file name
            //
            string clientSourceFileLocation = doco.clientDocument.Location.Trim();

            string clientSourceFileLocationName = Utils.getFilePathName(
                clientSourceFileLocation,
                doco.clientDocument.FileName.Trim());

            // Source location and destination may be different.
            // The destination of the file must be the one where it lives on the actual tree
            // To determine where the file should be located, we need to get the parent folder
            // The only way to determine the parent folder is walking through the entire tree from the root.
            // The root is the only thing that can be trusted. Every other location is dependent on the root.

            // The determination of the file location occurs in 2 parts. The one here is the second part.
            // At this point we are not going to use the source location of the original document, instead
            // we are going to use the client document location
            //

            // Check if destination folder directory exists
            //
            string PhysicalLocation = Utils.GetPathName(clientDestinationFileLocation);

            if (string.IsNullOrEmpty(PhysicalLocation))
            {
                string er = "Location is empty " + clientDestinationFileLocation + "\n" +
                            "File Name: " + doco.document.Name;

                uioutput.AddOutputMessage(er);
                return;
            }


            // 02/04/2011
            // This step should be done when the "FOLDER" record is created and not when the document
            // is generated
            //

            //if (!Directory.Exists( PhysicalLocation ))
            //    Directory.CreateDirectory( PhysicalLocation );


            // However the folder existence must be checked
            //
            if (!Directory.Exists(PhysicalLocation))
            {
                Directory.CreateDirectory(PhysicalLocation);

                string er = "Destination folder has been created with File! " + PhysicalLocation + "\n" +
                            "File Name: " + doco.document.Name;

                uioutput.AddOutputMessage(er);
                //return;
            }

            if (File.Exists(clientDestinationFileLocationName))
            {
                // Proceed but report in list
                //
                if (overrideDocuments == "Yes")
                {
                    // Delete file
                    try
                    {
                        File.Delete(clientDestinationFileLocationName);
                        uioutput.AddOutputMessage("File replaced: " +
                                                  document.SimpleFileName);
                    }
                    catch (Exception)
                    {
                        uioutput.AddOutputMessage("Error deleting file " +
                                                  document.SimpleFileName);
                        uioutput.AddErrorMessage("Error deleting file " +
                                                 document.SimpleFileName);

                        return;
                    }
                }
                else
                {
                    uioutput.AddOutputMessage("File already exists " +
                                              document.SimpleFileName);
                    return;
                }
            }

            // Copy and fix file
            //

            // Word Documents
            //
            if (doco.clientDocument.RecordType.Trim() == Utils.RecordType.FOLDER)
            {
                // Update file - set as GENERATED.
                //

                // This is the moment where the folder destination has to be created
                // and the folder db record has to be updated with the location
                //

                if (!Directory.Exists(PhysicalLocation))
                {
                    Directory.CreateDirectory(PhysicalLocation);
                }

                uioutput.AddOutputMessage("FOLDER: " + doco.clientDocument.SourceFileName);
            }
            else
            {
                // If is is not a folder, it must be a regular file.
                // Trying to copy it as well...
                //

                var currentDocumentPath = Path.GetExtension(doco.clientDocument.FileName);

                if (doco.clientDocument.DocumentType == Utils.DocumentType.WORD)
                {
                    #region Word
                    // ------------------------------------------------------------------------
                    // ------------------------------------------------------------------------
                    // Generate Document and replace tag values in new document generated
                    // ------------------------------------------------------------------------
                    // ------------------------------------------------------------------------
                    var results = WordDocumentTasks.CopyDocument(sourceFileLocationName, clientSourceFileLocationName, ts, vkWordApp, uioutput);
                    if (results.ReturnCode < 0)
                    {
                        // Error has occurred
                        //
                        var er = (System.Exception)results.Contents;
                        uioutput.AddOutputMessage("ERROR: " + er.ToString());
                        uioutput.AddErrorMessage("ERROR: " + er.ToString());

                        return;
                    }


                    #endregion Word
                }
                else if (doco.clientDocument.DocumentType == Utils.DocumentType.EXCEL)
                {
                    // ------------------------------------------------------------------------
                    // ------------------------------------------------------------------------
                    // Generate Document and replace tag values in new document generated
                    // ------------------------------------------------------------------------
                    // ------------------------------------------------------------------------

                    ExcelSpreadsheetTasks.CopyDocument(sourceFileLocationName, clientSourceFileLocationName, ts, vkExcelApp, uioutput);
                }
                else
                {
                    File.Copy(sourceFileLocationName, clientSourceFileLocationName);

                    uioutput.AddOutputMessage("File copied but not modified: " +
                                              Path.GetExtension(doco.clientDocument.FileName) + " == File: " + clientSourceFileLocationName);
                }

                //
                // Instantiate client document
                ClientDocument cd = new ClientDocument();
                cd.UID = doco.clientDocument.UID;

                // Update file - set as GENERATED.
                //
                cd.SetGeneratedFlagVersion('Y', document.IssueNumber);

                uioutput.AddOutputMessage("Document generated: " +
                                          clientDestinationFileLocationName);
            }
            return;
        }
示例#3
0
        /// <summary>
        /// Generate documents selected for a client
        /// </summary>
        /// <param name="clientID"></param>
        /// <param name="clientDocSetID"></param>
        /// <param name="uioutput"></param>
        /// <param name="overrideDocuments"></param>
        private void TBD_GenerateDocumentsForClient(
            int clientID, int clientDocSetID,
            string overrideDocuments)
        {
            uioutput.AddOutputMessage("Start time: " + System.DateTime.Now.ToString());

            // Instantiate Word
            //
            object vkFalse = false;

            Word.Application vkWordApp =
                new Word.Application();

            // Make it not visible
            vkWordApp.Visible = false;

            Excel.Application vkExcelApp = new Excel.Application();

            // Make it not visible
            vkExcelApp.Visible = false;

            // Get Metadata for client

            ReportMetadataList clientMetadata = new ReportMetadataList();

            clientMetadata.ListMetadataForClient(clientID);

            var ts = new List <WordDocumentTasks.TagStructure>();

            // Load variables/ metadata into memory
            //
            foreach (ReportMetadata metadata in clientMetadata.reportMetadataList)
            {
                // Retrieve value for the field selected
                //
                string value = metadata.GetValue();

                // If the field is not enabled, the program has to replace the value with spaces.
                //
                var valueOfTag = metadata.Enabled == 'Y' ? value : string.Empty;

                // When the field is an image and it is not enable, do not include the "No image" icon in the list
                //
                if (metadata.InformationType == Utils.InformationType.IMAGE && metadata.Enabled == 'N')
                {
                    continue;
                }

                ts.Add(new WordDocumentTasks.TagStructure()
                {
                    TagType  = metadata.InformationType,
                    Tag      = metadata.FieldCode,
                    TagValue = valueOfTag
                });
            }

            // Get Client Document Set Details
            // To get the source and destination folders
            ClientDocumentSet cds = new ClientDocumentSet();

            cds.Get(clientID, clientDocSetID);

            // Get List of documents for a client
            //
            var cdl = new ClientDocument();

            cdl.List(Utils.ClientID, Utils.ClientSetID);


            bool fileNotFound = false;
            // ---------------------------------------------------------------------------
            //    Check if source files exist before generation starts
            // ---------------------------------------------------------------------------
            int filecount = 0;

            foreach (scClientDocSetDocLink doco in cdl.clientDocSetDocLink)
            {
                #region File Inspection
                filecount++;

                // Ignore for now
                //
                if (doco.clientDocument.RecordType.Trim() == Utils.RecordType.FOLDER)
                {
                    string er = "Folder " + doco.document.Name;

                    uioutput.AddOutputMessage(er);
                    continue;
                }


                // Retrieve updated file name from source
                Document.Document document = new Document.Document();
                document.UID = doco.clientDocument.FKDocumentUID;
                document.Read();

                uioutput.AddOutputMessage("Inspecting file: " + document.UID + " === " + document.Name);

                // Client Document.SourceFileName is the name for the FCM File
                // Client Document.FileName is the client file name

                // Update client records with new file name
                //
                // Instantiate client document
                ClientDocument cd = new ClientDocument();
                cd.UID = doco.clientDocument.UID;
                // cd.FileName = document.FileName;
                cd.SourceFileName = document.FileName;
                cd.UpdateSourceFileName();

                // Update memory with latest file name
                // doco.clientDocument.SourceFileName = cd.FileName;
                doco.clientDocument.SourceFileName = cd.SourceFileName;

                string sourceFileLocationName = Utils.getFilePathName(
                    doco.clientDocument.SourceLocation,
                    doco.clientDocument.SourceFileName);

                // check if source folder/ file exists
                if (string.IsNullOrEmpty(doco.clientDocument.Location))
                {
                    MessageBox.Show("Document Location is empty.");
                    return;
                }

                if (string.IsNullOrEmpty(doco.clientDocument.FileName))
                {
                    MessageBox.Show("File Name is empty.");
                    return;
                }

                if (!File.Exists(sourceFileLocationName))
                {
                    string er = "File does not exist " +
                                sourceFileLocationName + " - File Name: " + doco.clientDocument.SourceFileName;

                    uioutput.AddOutputMessage(er);
                    uioutput.AddErrorMessage(er);
                    fileNotFound = true;
                    continue;
                }
                #endregion File Inspection
            }


            // Can't proceed if file not found
            if (fileNotFound)
            {
                return;
            }

            // Check if destination folder exists
            //
            if (string.IsNullOrEmpty(cds.Folder))
            {
                MessageBox.Show("Destination folder not set. Generation stopped.");
                return;
            }
            string PhysicalCDSFolder = Utils.GetPathName(cds.Folder);
            if (!Directory.Exists(PhysicalCDSFolder))
            {
                Directory.CreateDirectory(PhysicalCDSFolder);
            }


            // -----------------------------------------------------------------------
            //                          Generation starts here
            // -----------------------------------------------------------------------

            fileprocessedcount  = 0;
            valueForProgressBar = 0;
            startTime           = System.DateTime.Now.ToString();
            estimated           = System.DateTime.Now.AddSeconds(5 * filecount);

            var previousTime = System.DateTime.Now;
            var agora        = System.DateTime.Now;

            foreach (scClientDocSetDocLink doco in cdl.clientDocSetDocLink)
            {
                fileprocessedcount++;
                valueForProgressBar = (fileprocessedcount / filecount) * 100;

                // Get current time
                agora = System.DateTime.Now;

                // Get the time it took to process one file
                TimeSpan span = agora.Subtract(previousTime);

                // Calculate the estimated time to complete
                estimated = System.DateTime.Now.AddSeconds(span.TotalSeconds * filecount);

                uioutput.UpdateProgressBar(valueForProgressBar, estimated);

                previousTime = System.DateTime.Now;

                // Retrieve latest version
                //
                Document.Document document = new Document.Document();
                document.UID = doco.clientDocument.FKDocumentUID;
                document.Read();


                uioutput.AddOutputMessage(">>> Generating file: " + document.UID + " === " + document.SimpleFileName);


                string sourceFileLocationName = Utils.getFilePathName(
                    doco.clientDocument.SourceLocation,
                    doco.clientDocument.SourceFileName);

                // This is the client file name
                //
                string clientFileLocation = cds.Folder.Trim() +
                                            doco.clientDocument.Location.Trim();

                string clientFileLocationName = Utils.getFilePathName(
                    clientFileLocation,
                    doco.clientDocument.FileName.Trim());



                // Check if file destination directory exists
                //
                string PhysicalLocation = Utils.GetPathName(clientFileLocation);

                if (string.IsNullOrEmpty(PhysicalLocation))
                {
                    string er = "Location is empty " + doco.clientDocument.Location + "\n" +
                                "File Name: " + doco.document.Name;

                    uioutput.AddOutputMessage(er);
                    continue;
                }

                if (!Directory.Exists(PhysicalLocation))
                {
                    Directory.CreateDirectory(PhysicalLocation);
                }

                if (File.Exists(clientFileLocationName))
                {
                    // Proceed but report in list
                    //
                    if (overrideDocuments == "Yes")
                    {
                        // Delete file
                        try
                        {
                            File.Delete(clientFileLocationName);
                            uioutput.AddOutputMessage("File replaced " +
                                                      document.SimpleFileName);
                        }
                        catch (Exception)
                        {
                            uioutput.AddOutputMessage("Error deleting file " +
                                                      document.SimpleFileName);
                            uioutput.AddErrorMessage("Error deleting file " +
                                                     document.SimpleFileName);

                            continue;
                        }
                    }
                    else
                    {
                        uioutput.AddOutputMessage("File already exists " +
                                                  document.SimpleFileName);
                        continue;
                    }
                }

                // Copy and fix file
                //

                // Word Documents
                //
                if (doco.clientDocument.RecordType.Trim() == Utils.RecordType.FOLDER)
                {
                    // Update file - set as GENERATED.
                    //

                    uioutput.AddOutputMessage("FOLDER: " + doco.clientDocument.SourceFileName);
                }
                else
                {
                    // If is is not a folder, it must be a regular file.
                    // Trying to copy it as well...
                    //

                    var currentDocumentPath = Path.GetExtension(doco.clientDocument.FileName);

                    if (doco.clientDocument.DocumentType == Utils.DocumentType.WORD)
                    {
                        #region Word
                        // ------------------------------------------------------------------------
                        // ------------------------------------------------------------------------
                        // Generate Document and replace tag values in new document generated
                        // ------------------------------------------------------------------------
                        // ------------------------------------------------------------------------
                        var results = WordDocumentTasks.CopyDocument(sourceFileLocationName, clientFileLocationName, ts, vkWordApp, uioutput);
                        if (results.ReturnCode < 0)
                        {
                            // Error has occurred
                            //
                            var er = (System.Exception)results.Contents;
                            uioutput.AddOutputMessage("ERROR: " + er.ToString());
                            uioutput.AddErrorMessage("ERROR: " + er.ToString());

                            continue;
                        }


                        //
                        // Instantiate client document
                        ClientDocument cd = new ClientDocument();
                        cd.UID = doco.clientDocument.UID;


                        // Update file - set as GENERATED.
                        //

                        cd.SetGeneratedFlagVersion('Y', document.IssueNumber);

                        uioutput.AddOutputMessage("Document generated: " +
                                                  clientFileLocationName);

                        #endregion Word
                    }
                    else if (doco.clientDocument.DocumentType == Utils.DocumentType.EXCEL)
                    {
                        // ------------------------------------------------------------------------
                        // ------------------------------------------------------------------------
                        // Generate Document and replace tag values in new document generated
                        // ------------------------------------------------------------------------
                        // ------------------------------------------------------------------------

                        ExcelSpreadsheetTasks.CopyDocument(sourceFileLocationName, clientFileLocationName, ts, vkExcelApp, uioutput);

                        //
                        // Instantiate client document
                        ClientDocument cd = new ClientDocument();
                        cd.UID = doco.clientDocument.UID;


                        // Update file - set as GENERATED.
                        //

                        cd.SetGeneratedFlagVersion('Y', document.IssueNumber);

                        uioutput.AddOutputMessage("Document generated: " +
                                                  clientFileLocationName);
                    }
                    else
                    {
                        File.Copy(sourceFileLocationName, clientFileLocationName);

                        uioutput.AddOutputMessage("File copied but not modified: " +
                                                  Path.GetExtension(doco.clientDocument.FileName) + " == File: " + clientFileLocationName);
                    }
                }
            }

            // close word application
            vkWordApp.Quit(ref vkFalse, ref vkFalse, ref vkFalse);
            vkExcelApp.Quit();

            uioutput.AddOutputMessage("End time: " + System.DateTime.Now.ToString());
        }