// 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();
}
}
/// <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;
}
/// <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());
}