/// <summary> /// Print Job Sepearator method will be called from non Printing Plugins. /// </summary> /// <param name="executionData"></param> public void PrintJobSeparator(PluginExecutionData executionData) { PrintQueueInfo printQueueInfo = executionData.PrintQueues.FirstOrDefault(); PrintQueue printQueue = printQueue = PrintQueueController.Connect(printQueueInfo); PrintJobSeparator(executionData, printQueue); }
/// <summary> /// Exexutes the Print Job /// </summary> /// <returns></returns> private PluginExecutionResult ExecutePrintJob() { PluginExecutionResult printResult = new PluginExecutionResult(PluginResult.Passed); try { PrintQueue defaultPrintQueue; PrintQueueInfo printQueueInfo = ExecutionData.PrintQueues.GetRandom(); UpdateStatus("Print Activity: Retrieving print queue for " + printQueueInfo.QueueName); defaultPrintQueue = PrintQueueController.Connect(printQueueInfo); PrintingEngine engine = new PrintingEngine(); // Select a documents to print DocumentCollectionIterator documentIterator = new DocumentCollectionIterator(CollectionSelectorMode.ShuffledRoundRobin); Document document = documentIterator.GetNext(ExecutionData.Documents); // Download the document and log the starting information for the print job Guid jobId = SequentialGuid.NewGuid(); FileInfo localFile = ExecutionServices.FileRepository.GetFile(document); UpdateStatus($"Print Activity: Printing {localFile.Name} to {defaultPrintQueue.FullName}"); var result = engine.Print(localFile, defaultPrintQueue); UpdateStatus($"Print Activity: Finished printing {localFile.Name}"); return(printResult); } catch (Exception genericException) { printResult = new PluginExecutionResult(PluginResult.Failed, genericException.ToString()); ExecutionServices.SystemTrace.LogError(genericException.ToString()); return(printResult); } }
public PrintQueueRow(PrintQueueInfo queue) { QueueName = queue.QueueName; PrintServer = "Client"; QueueType = "Local"; Device = queue.AssociatedAssetId; }
private static void LogDevice(PluginExecutionData executionData, PrintQueueInfo printer) { if (!string.IsNullOrEmpty(printer.AssociatedAssetId)) { var log = new ActivityExecutionAssetUsageLog(executionData, printer.AssociatedAssetId); ExecutionServices.DataLogger.Submit(log); } }
private static void LogServer(PluginExecutionData executionData, PrintQueueInfo printQueue) { RemotePrintQueueInfo remoteQueue = printQueue as RemotePrintQueueInfo; if (remoteQueue != null) { var log = new ActivityExecutionServerUsageLog(executionData, remoteQueue.ServerHostName); ExecutionServices.DataLogger.Submit(log); } }
private void ExecuteHandler() { ExecutionServices.SystemTrace.LogDebug($"Plugin exec data print queues = {_printQueues.Count}"); foreach (var x in _printQueues) { ExecutionServices.SystemTrace.LogDebug($"Queue={x.QueueName}"); } // Check to make sure we have something in the pool... if (_printQueues.Count == 0) { var msg = "None of the selected print queues are available."; ExecutionServices.SystemTrace.LogDebug(msg); throw new PrintQueueNotAvailableException(msg); } // Pick a print queue and log the device/server if applicable PrintQueueInfo queueInfo = _printQueues.GetRandom(); LogDevice(_pluginData, queueInfo); LogServer(_pluginData, queueInfo); // Connect to the print queue ExecutionServices.SystemTrace.LogDebug($"Connecting to queue: {queueInfo.QueueName}"); PrintQueue printQueue = PrintQueueController.Connect(queueInfo); _serverName = printQueue.HostingPrintServer.Name.TrimStart('\\'); ExecutionServices.SystemTrace.LogDebug($"Connected to queue: {printQueue.FullName}"); // Select a document to print Document document = _documentIterator.GetNext(_pluginData.Documents); ActivityExecutionDocumentUsageLog documentLog = new ActivityExecutionDocumentUsageLog(_pluginData, document); ExecutionServices.DataLogger.Submit(documentLog); // Download the document and log the starting information for the print job Guid jobId = SequentialGuid.NewGuid(); FileInfo localFile = ExecutionServices.FileRepository.GetFile(document); PrintJobClientLog log = LogPrintJobStart(_pluginData, localFile, printQueue, jobId); // Print the job PrintingEngineResult result = _engine.Print(localFile, printQueue, jobId); _printJobId = result.UniqueFileId; if (result == null) { throw new FilePrintException($"Failed to print {localFile}."); } // Log the ending information LogPrintJobEnd(log, result); ExecutionServices.SystemTrace.LogDebug("Controller execution completed"); }
/// <summary> /// Executes this plugin's workflow using the specified <see cref="PluginExecutionData" />. /// </summary> /// <param name="executionData">The execution data.</param> /// <returns>A <see cref="PluginExecutionResult" /> indicating the outcome of the execution.</returns> public PluginExecutionResult Execute(PluginExecutionData executionData) { try { DriverConfigurationPrintActivityData data = executionData.GetMetadata <DriverConfigurationPrintActivityData>(); PrintQueueInfo item = executionData.PrintQueues.GetRandom(); _engine.ConfigureDriverSettings(data.PrinterPreference, item.QueueName); return(_engine.ProcessActivity(executionData)); } catch (Exception ex) { return(new PluginExecutionResult(PluginResult.Failed, ex)); } }
public PrintQueueRow(PrintQueueInfo queue) { QueueName = queue.QueueName; PrintServer = "Client"; QueueType = "Local"; Device = queue.AssociatedAssetId; RemotePrintQueueInfo remoteQueue = queue as RemotePrintQueueInfo; if (remoteQueue != null) { PrintServer = remoteQueue.ServerHostName; QueueType = "Remote"; } }
public PluginExecutionResult Execute(PluginExecutionData executionData) { if (!_setupDone) { AddOfficeRegistryEntries(); _setupDone = true; } _mailMergeData = executionData.GetMetadata <MailMergeActivityData>(); _printQueueInfoCollection = executionData.PrintQueues; _userName = executionData.Credential.UserName; _sessionId = executionData.SessionId; _tempDataSourceFileName = Path.Combine(Path.GetTempPath(), $"{_userName}_{Guid.NewGuid()}_tempDataSourceFile.doc"); //install the local printer or remote print queue // Set up the list of print devices if (_printQueueInfoCollection.Count == 0) { return(new PluginExecutionResult(PluginResult.Skipped)); } PrintQueueInfo printQueueInfo = _printQueueInfoCollection.First(); PrintQueue printQueue = PrintQueueController.Connect(printQueueInfo); // Log the device/server that was used for this job, if one was specified LogDevice(executionData, printQueueInfo); if (_mailMergeData.PrintJobSeparator) { PrintTag(printQueue, executionData); } _defaultPrintQueue = printQueue.FullName; //generate the mail merge doc and print it to default print queue try { ExecutionServices.CriticalSection.Run(new Framework.Synchronization.LocalLockToken(printQueueInfo.AssociatedAssetId, new TimeSpan(0, 0, 30), new TimeSpan(0, 5, 0)), PrintMailMerge); } catch (Exception ex) { return(new PluginExecutionResult(PluginResult.Failed, ex.Message)); } return(new PluginExecutionResult(PluginResult.Passed)); }
/// <summary> /// Connects to and returns a <see cref="PrintQueue" /> object represented by the specified <see cref="PrintQueueInfo" />. /// </summary> /// <param name="printQueueInfo">The <see cref="PrintQueueInfo" /> specifying the print queue.</param> /// <returns>A <see cref="PrintQueue" /> object.</returns> /// <exception cref="ArgumentNullException"><paramref name="printQueueInfo" /> is null.</exception> /// <exception cref="PrintQueueNotFoundException">The queue specified by <paramref name="printQueueInfo" /> could not be found.</exception> public static PrintQueue Connect(PrintQueueInfo printQueueInfo) { if (printQueueInfo == null) { throw new ArgumentNullException(nameof(printQueueInfo)); } if (printQueueInfo is RemotePrintQueueInfo remotePrintQueueInfo) { string printerName = remotePrintQueueInfo.GetPrinterName(); ConnectToRemoteQueue(printerName); return(GetPrintQueue(printerName)); } else { return(GetPrintQueue(printQueueInfo.QueueName)); } }
/// <summary> /// The execute. /// </summary> /// <param name="executionData"> /// The execution data. /// </param> /// <returns> /// The <see cref="PluginExecutionResult"/>. /// </returns> public PluginExecutionResult Execute(PluginExecutionData executionData) { CopyData data = executionData.GetMetadata <CopyData>(ConverterProvider.GetMetadataConverters()); PrintQueueInfo item = executionData.PrintQueues.GetRandom(); ScanOptions scanOptions = new ScanOptions() { LockTimeouts = data.LockTimeouts, PageCount = data.PageCount }; if (data.PrintJobSeparator) { _engine.PrintJobSeparator(executionData); } var manager = new CopyManager(executionData, scanOptions); manager.ActivityStatusChanged += UpdateStatus; manager.DeviceSelected += UpdateDevice; return(manager.RunScanActivity()); }
public PrintQueueRow(PrintQueueInfo queue) { QueueName = queue.QueueName; PrintServer = "Client"; QueueType = "Local"; Device = queue.AssociatedAssetId; RemotePrintQueueInfo remoteQueue = queue as RemotePrintQueueInfo; if (remoteQueue != null) { PrintServer = remoteQueue.ServerHostName; QueueType = "Remote"; } DynamicLocalPrintQueueInfo dynamicLocalQueue = queue as DynamicLocalPrintQueueInfo; if (dynamicLocalQueue != null) { QueueName = string.Format("{0}\\{1} on {2}", dynamicLocalQueue.PrintDriver.PackageName, dynamicLocalQueue.PrintDriver.DriverName, dynamicLocalQueue.AssociatedAssetId); } }
/// <summary> /// Defines and executes the PluginFax workflow. /// </summary> /// <param name="executionData">Information used in the execution of this workflow.</param> /// <returns>The result of executing the workflow.</returns> public PluginExecutionResult Execute(PluginExecutionData executionData) { _faxActivityData = executionData.GetMetadata <FaxActivityData>(ConverterProvider.GetMetadataConverters()); PrintQueueInfo item = executionData.PrintQueues.GetRandom(); if (_faxActivityData.PrintJobSeparator) { _engine.PrintJobSeparator(executionData); } FaxScanManager manager; if (string.IsNullOrWhiteSpace(_faxActivityData.DigitalSendServer)) { manager = new FaxScanManager(executionData); } else { manager = new FaxScanManager(executionData, _faxActivityData.DigitalSendServer); } manager.ActivityStatusChanged += UpdateStatus; manager.DeviceSelected += UpdateDevice; return(manager.RunScanActivity()); }
private LocalPrintQueueRow(PrintQueueInfo queue) { PrintQueueInfo = queue; Device = queue.AssociatedAssetId; }
/// <summary> /// Installs the print queue /// </summary> private Status InstallPrintQueue(PluginExecutionData executionData) { if (executionData.PrintQueues.Count == 0) { return(Status.Skipped); } _printQueueInfo = executionData.PrintQueues.First(); _defaultPrintQueue = PrintQueueController.Connect(_printQueueInfo); // Log the device/server that was used for this job, if one was specified LogDevice(executionData, _printQueueInfo); //To check count of paper size,type and trays try { int paperSize = GetCountFromRegistry("MediaSize"); int paperType = GetCountFromRegistry("MediaType"); int inputtrays = ((string[]) Registry.LocalMachine.OpenSubKey( $@"System\CurrentControlSet\Control\Print\Printers\{ (object)_defaultPrintQueue.FullName}\PrinterDriverData").GetValue("InputSlot")).Count( x => x.StartsWith("Tray", StringComparison.OrdinalIgnoreCase)); ExecutionServices.SystemTrace.LogInfo($"Paper Sizes available for { (object)_defaultPrintQueue.FullName} are { (object)paperSize}"); ExecutionServices.SystemTrace.LogInfo($"Paper Types available for { (object)_defaultPrintQueue.FullName} are { (object)paperType}"); ExecutionServices.SystemTrace.LogInfo($"Trays available for {_defaultPrintQueue.Name} are {inputtrays}"); } catch (NullReferenceException nullRefEx) { ExecutionServices.SystemTrace.LogInfo($"Something went wrong when trying to read values from registry, Please manually validate the supported paper sizes, types and trays supported. Exception: { (object)nullRefEx.Message}"); } if (ValidatePrintingShortcut(_defaultPrintQueue.FullName)) { try { //this is a fix for defaultprintqueue.connected not working in windows vista due to UAC foreach (string printerName in System.Drawing.Printing.PrinterSettings.InstalledPrinters) { if (_defaultPrintQueue.FullName.Equals(printerName)) { if (_activityData.IsDefaultPrinter) { PrintQueueController.SetDefaultQueue(_defaultPrintQueue); } ExecutionServices.SystemTrace.LogDebug($"Printer installed: { (object)printerName}"); return(Status.Passed); } } } catch { return(Status.Failed); } } else { ExecutionServices.SystemTrace.LogInfo( $"Failed to install the device: {_printQueueInfo.AssociatedAssetId}"); return(Status.Failed); } return(Status.Passed); }
private static PrintQueue GetCitrixPrintQueue(PrintQueueInfo printQueueInfo) { // Special handling for Citrix session queues - they are connections to a remote server, // but don't show up when querying the local server for a list of queues. // Connect to the queue directly by parsing the queue name LocalPrintQueueInfo localPrintQueueInfo = printQueueInfo as LocalPrintQueueInfo; if (localPrintQueueInfo != null) { LogDebug("Attempting to parse Citrix session queue."); var match = Regex.Match(localPrintQueueInfo.QueueName, @"^\\\\([\S\s]+)\\([\S\s]+)$"); if (match.Success) { LogDebug("Parse success."); var serverName = match.Groups[1]; var queueName = match.Groups[2]; LogDebug($"Server Name: {serverName}"); LogDebug($"Queue Name: {queueName}"); PrintServer server = new PrintServer($@"\\{serverName}"); return(new PrintQueue(server, localPrintQueueInfo.QueueName)); } else { LogDebug("Parse failure."); } } // When Citrix auto-generates a print queue on the Citrix server, it creates a queue with the // same name as the local print queue on the client machine, but appends some session information // to the end. To find the real name of the print queue on the Citrix server, we need to // find a print queue installed on the system that starts with the same text generated by the base class. LogDebug($"Looking for {printQueueInfo.QueueName}"); List <string> queueNames = PrintQueueController.GetPrintQueues().Select(n => n.FullName).ToList(); string clientName = Environment.GetEnvironmentVariable("CLIENTNAME"); RemotePrintQueueInfo remotePrintQueueInfo = printQueueInfo as RemotePrintQueueInfo; if (remotePrintQueueInfo != null) { string citrixQueueName = queueNames.FirstOrDefault( n => n.StartsWith(remotePrintQueueInfo.QueueName, StringComparison.OrdinalIgnoreCase) && n.Contains(remotePrintQueueInfo.ServerHostName, StringComparison.OrdinalIgnoreCase) && n.Contains(clientName, StringComparison.OrdinalIgnoreCase)); if (citrixQueueName != null) { LogDebug($"Found Citrix queue {citrixQueueName}"); return(PrintQueueController.GetPrintQueue(citrixQueueName)); } else { LogDebug($"Did not find mapped queue. Looking for directly attached queue."); return(PrintQueueController.GetPrintQueue(remotePrintQueueInfo.GetPrinterName())); } } DynamicLocalPrintQueueInfo dynamicPrintQueueInfo = printQueueInfo as DynamicLocalPrintQueueInfo; if (dynamicPrintQueueInfo != null) { string citrixQueueName = queueNames.FirstOrDefault( n => n.StartsWith(dynamicPrintQueueInfo.QueueName, StringComparison.OrdinalIgnoreCase) && n.Contains(clientName, StringComparison.OrdinalIgnoreCase)); if (citrixQueueName != null) { LogDebug($"Found Citrix queue {citrixQueueName}"); return(PrintQueueController.GetPrintQueue(citrixQueueName)); } else { throw new PrintQueueNotFoundException($"Could not find mapped queue for {dynamicPrintQueueInfo.QueueName}"); } } // Default to the usual behavior return(PrintQueueController.Connect(printQueueInfo)); }
/// <summary> /// Start the activity. /// </summary> /// <param name="executionData">Serialized activity data.</param> public PluginExecutionResult ProcessActivity(PluginExecutionData executionData) { PrintingActivityData data = executionData.GetMetadata <PrintingActivityData>(); PrintQueueInfoCollection printQueues = executionData.PrintQueues; // Initialize the document iterator, if it is not already created if (_documentIterator == null) { CollectionSelectorMode mode = data.ShuffleDocuments ? CollectionSelectorMode.ShuffledRoundRobin : CollectionSelectorMode.RoundRobin; _documentIterator = new DocumentCollectionIterator(mode); } // Check to make sure we have something in the pool... if (printQueues.Count == 0) { return(new PluginExecutionResult(PluginResult.Skipped, "None of the selected print queues are available.", "No available print queues.")); } // Select a print queue and log the device/server if applicable PrintQueueInfo printQueueInfo = printQueues.GetRandom(); LogDevice(executionData, printQueueInfo); LogServer(executionData, printQueueInfo); // Get the corresponding system print queue LogDebug(string.Format("Retrieving print queue for {0}", printQueueInfo.QueueName)); PrintQueue printQueue; if (ExecutionServices.SessionRuntime.AsInternal().IsCitrixEnvironment()) { printQueue = GetCitrixPrintQueue(printQueueInfo); } else { printQueue = PrintQueueController.Connect(printQueueInfo); } LogDebug(string.Format("Found queue: {0}", printQueue.FullName)); if (data.JobThrottling) { // Make sure that there is enough room in the print queue for this job. if (!CheckJobCountInQueue(printQueue, data.MaxJobsInQueue)) { // Skip the activity. return(new PluginExecutionResult(PluginResult.Skipped, "Print Queue cannot accept any more jobs.", "Print queue throttling.")); } } LogDebug("Executing print controller"); if (data.PrintJobSeparator) { PrintTag(printQueue, executionData); } // Select a document to print Document document = _documentIterator.GetNext(executionData.Documents); ActivityExecutionDocumentUsageLog documentLog = new ActivityExecutionDocumentUsageLog(executionData, document); ExecutionServices.DataLogger.Submit(documentLog); // Download the document and log the starting information for the print job Guid jobId = SequentialGuid.NewGuid(); FileInfo localFile = ExecutionServices.FileRepository.GetFile(document); PrintJobClientLog log = LogPrintJobStart(executionData, localFile, printQueue, jobId); // Print the job var engine = new Print.PrintingEngine(); engine.StatusChanged += (s, e) => StatusChanged?.Invoke(s, e); var result = engine.Print(localFile, printQueue, jobId); // Log the ending information LogPrintJobEnd(log, result); LogDebug("Controller execution completed"); return(new PluginExecutionResult(PluginResult.Passed)); }