private void DownloadCompleted(object sender, TaskEventArgs e)
        {
            string message = "";
            if (e.Error != null)
            {
                message = "Error downloading: " + e.Error.Message;
            }
            else
            {
                message = "Downloaded.\nResult:";

                string txtFilePath = e.UserState as string;
                IsolatedStorageFile storage = IsolatedStorageFile.GetUserStoreForApplication();
                IsolatedStorageFileStream file = storage.OpenFile(txtFilePath, FileMode.Open, FileAccess.Read);
                using (StreamReader reader = new StreamReader(file))
                {
                    message += reader.ReadToEnd();
                }
            }

            Dispatcher.BeginInvoke(() =>
            {
                displayMessage(message);
            }
            );
        }
Ejemplo n.º 2
0
        private void DownloadCompleted(object sender, TaskEventArgs e)
        {
            UserTask task = e.UserState as UserTask;
            if (e.Error != null)
            {
                task.TaskStatus = "Downloading error";
                task.OutputFilePath = "<error>";
                task.ErrorMessage = e.Error.Message;
                moveTaskToCompleted(task);
                return;
            }

            if (task.IsFieldLevel)
            {
                task.RecognizedText = FieldLevelXml.ReadText(task.OutputFilePath);
            }

            task.TaskStatus = "Ready";
            moveTaskToCompleted(task);
        }
Ejemplo n.º 3
0
        private void ProcessingCompleted(object sender, TaskEventArgs e)
        {
            UserTask task = e.UserState as UserTask;

            if (task.SourceIsTempFile)
            {
                File.Delete(task.SourceFilePath);
            }

            if (e.Error != null)
            {
                task.TaskStatus = "Processing error";
                task.OutputFilePath = "<error>";
                task.ErrorMessage = e.Error.Message;
                moveTaskToCompleted(task);
                return;
            }

            if (e.Result.Status == TaskStatus.NotEnoughCredits)
            {
                task.TaskStatus = "Not enough credits";
                task.OutputFilePath = "<not enough credits>";
                MessageBox.Show("Not enough credits to process the file.\nPlease add more pages to your application's account.",
                    "Error", MessageBoxButton.OK, MessageBoxImage.Exclamation);
                moveTaskToCompleted(task);
                return;
            }

            if (e.Result.Status != TaskStatus.Completed)
            {
                task.TaskStatus = "Internal server error";
                moveTaskToCompleted(task);
                return;
            }

            task.TaskStatus = "Downloading";
            // Start downloading
            restClientAsync.DownloadFileAsync(e.Result, task.OutputFilePath, task);
        }
Ejemplo n.º 4
0
 private void onDownloadFileCompleted(object sender, TaskEventArgs e)
 {
     if (DownloadFileCompleted != null)
     {
         DownloadFileCompleted(sender, e);
     }
 }
        private void ProcessingCompleted(object sender, TaskEventArgs e)
        {
            if (e.Error != null)
            {
                Dispatcher.BeginInvoke(() =>
                {
                    displayMessage("Processing error: " + e.Error.Message);
                }
                );
                return;
            }

            Dispatcher.BeginInvoke(() =>
                {
                    displayMessage("Processing completed. Downloading..");
                }
                );

            // Download a file
            string outputPath = "result.txt";
            Task task = e.Result;
            abbyyClient.DownloadFileAsync(task, outputPath, outputPath);
        }
Ejemplo n.º 6
0
        private void downloadCompletionMethod(
            Task task,
            Exception exception,
            bool canceled,
            AsyncOperation asyncOp)
        {
            if (!canceled)
            {
                lock (downloadJobs)
                {
                    downloadJobs.Remove(asyncOp.UserSuppliedState);
                }
            }

            TaskEventArgs e = new TaskEventArgs(task, exception, canceled, asyncOp.UserSuppliedState);

            asyncOp.PostOperationCompleted(onDownloadCompletedDelegate, e);
        }
Ejemplo n.º 7
0
 private void onProcessingCompleted(object sender, TaskEventArgs e)
 {
     if (TaskProcessingCompleted != null)
     {
         TaskProcessingCompleted(sender, e);
     }
 }
Ejemplo n.º 8
0
        private void processFieldWorker(string filePath, IProcessingSettings settings,
            AsyncOperation asyncOp)
        {
            Exception e = null;

            Task task = new Task();
            try
            {
                if (settings is TextFieldProcessingSettings)
                {
                    task = _syncClient.ProcessTextField(filePath, settings as TextFieldProcessingSettings);
                }
                else if (settings is BarcodeFieldProcessingSettings)
                {
                    task = _syncClient.ProcessBarcodeField(filePath, settings as BarcodeFieldProcessingSettings);
                }
                else if (settings is CheckmarkFieldProcessingSettings)
                {
                    task = _syncClient.ProcessCheckmarkField(filePath, settings as CheckmarkFieldProcessingSettings);
                }
                else
                {
                    throw new ArgumentException("Invalid type of processing settings");
                }

                // Notify that upload was completed
                Task uploadedTask = new Task(task.Id, TaskStatus.Submitted);
                UploadCompletedEventArgs uploadCompletedEventArgs = new UploadCompletedEventArgs(uploadedTask, asyncOp.UserSuppliedState);
                asyncOp.Post(onUploadCompletedDelegate, uploadCompletedEventArgs);

                // Wait until task finishes
                startTaskMonitorIfNecessary();

                _taskList.AddTask(task);
                task = waitUntilTaskFinishes(task);
            }
            catch (Exception ex)
            {
                e = ex;
            }

            lock (processJobs)
            {
                processJobs.Remove(asyncOp.UserSuppliedState);
            }

            bool canceled = false;

            // Package the results of the operation in EventArgs
            TaskEventArgs ev = new TaskEventArgs(task, e, canceled, asyncOp.UserSuppliedState);

            // End the task. The asyncOp object is responsible 
            // for marshaling the call.
            asyncOp.PostOperationCompleted(onProcessingCompleteDelegate, ev);
        }
Ejemplo n.º 9
0
        // This is the method that the underlying, free-threaded 
        // asynchronous behavior will invoke.  This will happen on
        // a worker thread
        private void processCompletionMethod(
            Task task,
            Exception exception,
            bool canceled,
            AsyncOperation asyncOp)
        {
            // If the task was not previously canceled,
            // remove the task from the lifetime collection.
            if (!canceled)
            {
                lock (processJobs)
                {
                    processJobs.Remove(asyncOp.UserSuppliedState);
                }
            }

            // Package the results of the operation in EventArgs
            TaskEventArgs e = new TaskEventArgs(task, exception, canceled, asyncOp.UserSuppliedState);

            // End the task. The asyncOp object is responsible 
            // for marshaling the call.
            asyncOp.PostOperationCompleted(onProcessingCompleteDelegate, e);

            // Note that after the call to OperationCompleted, 
            // asyncOp is no longer usable, and any attempt to use it
            // will cause an exception to be thrown.
        }
Ejemplo n.º 10
0
        private void processingCompleted(object operationState)
        {
            TaskEventArgs e = operationState as TaskEventArgs;

            onProcessingCompleted(null, e);
        }
Ejemplo n.º 11
0
        private void downloadCompleted(object operationState)
        {
            TaskEventArgs e = operationState as TaskEventArgs;

            onDownloadFileCompleted(null, e);
        }
Ejemplo n.º 12
0
        private void ProcessingCompleted(object sender, TaskEventArgs e)
        {
            UserTask task = e.UserState as UserTask;

            if (task.SourceIsTempFile)
            {
                File.Delete(task.SourceFilePath);
            }

            if (e.Error != null)
            {
                task.TaskStatus = "Processing error";
                task.OutputFilePath = "<error>";
                task.ErrorMessage = e.Error.Message;
                moveTaskToCompleted(task);
                return;
            }

            if (e.Result.Status == TaskStatus.NotEnoughCredits)
            {
                task.TaskStatus = "Not enough credits";
                moveTaskToCompleted(task);
                return;
            }

            if (e.Result.Status != TaskStatus.Completed)
            {
                task.TaskStatus = "Internal server error";
                moveTaskToCompleted(task);
                return;
            }

            task.TaskStatus = "Downloading";
            // Start downloading
            restClientAsync.DownloadFileAsync(e.Result, task.OutputFilePath, task);
        }
Ejemplo n.º 13
0
        /// <summary>
        /// Submit and process image asynchronously. 
        /// Performs callbacks:
        ///   UploadFileCompleted
        ///   TaskProcessingCompleted
        /// </summary>
        /// <param name="filePath">Path to file in isolated storage</param>
        /// <param name="settings"></param>
        /// <param name="userState"></param>
        public void ProcessImageAsync(string filePath, ProcessingSettings settings, object userState)
        {
            BackgroundWorker w = new BackgroundWorker();
            w.DoWork += new DoWorkEventHandler((sender, e) =>
                {
                    Task task = null;
                    try
                    {
                        task = _syncClient.ProcessImage(filePath, settings);
                        UploadCompletedEventArgs uploadArgs = new UploadCompletedEventArgs(task, userState);
                        onUploadFileCompleted(sender, uploadArgs);

                        // Wait until task finishes
                        while (true)
                        {
                            task = _syncClient.GetTaskStatus(task.Id);
                            if (!task.IsTaskActive())
                            {
                                break;
                            }
                            Thread.Sleep(1000);
                        }

                        TaskEventArgs taskArgs = new TaskEventArgs(task, null, false, userState);

                        onProcessingCompleted(sender, taskArgs);
                    }
                    catch (Exception ex)
                    {
                        TaskEventArgs taskArgs = new TaskEventArgs(task, ex, false, userState);
                        onProcessingCompleted(sender, taskArgs);
                    }
                }
            );

            w.RunWorkerAsync();
        }
Ejemplo n.º 14
0
        /// <summary>
        /// Download file asynchronously
        /// Performs DownloadFileCompleted callback
        /// </summary>
        public void DownloadFileAsync(Task task, string outputPath, object userState)
        {
            BackgroundWorker w = new BackgroundWorker();
            w.DoWork += new DoWorkEventHandler((sender, e) =>
                {
                    try
                    {
                        _syncClient.DownloadResult(task, outputPath);
                        TaskEventArgs taskArgs = new TaskEventArgs(task, null, false, userState);
                        onDownloadFileCompleted(sender, taskArgs);
                    }
                    catch (Exception ex)
                    {
                        TaskEventArgs taskArgs = new TaskEventArgs(task, ex, false, userState);
                        onDownloadFileCompleted(sender, taskArgs);
                    }
                }
                );

            w.RunWorkerAsync();
        }
        public void DownloadCompleted(object sender, TaskEventArgs e)
        {
            Char type = 'D';
            string text;
            StoreData store = new StoreData();
            MongoDBService.Transaction p = new MongoDBService.Transaction();

            if (e.Error != null)
            {
                message = "Error downloading: " + e.Error.Message;
            }
            else
            {
                string txtFilePath = e.UserState as string;
                IsolatedStorageFile storage = IsolatedStorageFile.GetUserStoreForApplication();
                IsolatedStorageFileStream file = storage.OpenFile(txtFilePath, FileMode.Open, FileAccess.Read);
                IsolatedStorageFileStream fileStream = storage.OpenFile(txtFilePath, FileMode.Open, FileAccess.Read);
                StreamReader reader = new StreamReader(file);
                text = reader.ReadToEnd();

                if (text.Contains("WALGREENS"))
                    type = 'W';
                else if (text.Contains("Tops"))
                    type = 'T';

                switch (type)
                {
                    case 'W':
                        using (StreamReader newReader = new StreamReader(fileStream))
                        {

                            store.Address = newReader.ReadLine() + newReader.ReadLine();
                            store.StoreName = "WALGREENS";

                            //Get for storeid from DB
                            newReader.ReadLine();
                            newReader.ReadLine();
                            newReader.ReadLine();
                            newReader.ReadLine();

                            while (true)
                            {
                                p.Name = newReader.ReadLine();
                                if (p.Name.Equals("SUBTOTAL"))
                                    break;

                                p.ID = double.Parse(newReader.ReadLine());
                                newReader.ReadLine();
                                p.quantity = newReader.ReadLine();
                                p.cost = double.Parse(newReader.ReadLine());

                                insertData(p);
                            }

                        }
                        break;

                    case 'T':
                        using (StreamReader newReader = new StreamReader(file))
                        {
                            while (!newReader.ReadLine().Contains("Tops Market")) ;

                            store.Address = newReader.ReadLine() + newReader.ReadLine();
                            store.StoreName = "WALGREENS";

                            //get the storeid from DB
                            newReader.ReadLine();
                            newReader.ReadLine();
                            newReader.ReadLine();
                            newReader.ReadLine();
                        }
                        break;
                }

            }
        }
Ejemplo n.º 16
0
        /// <summary>
        /// Submit and process image asynchronously. 
        /// Performs callbacks:
        ///   UploadFileCompleted
        ///   TaskProcessingCompleted
        /// </summary>
        /// <param name="filePath">Path to file in isolated storage</param>
        /// <param name="settings"></param>
        /// <param name="userState"></param>
        public void ProcessImageAsync(string filePath, ProcessingSettings settings, object userState)
        {
            BackgroundWorker w = new BackgroundWorker();
            w.DoWork += new DoWorkEventHandler((sender, e) =>
                {
                    OcrSdkTask task = null;
                    try
                    {
                        task = _syncClient.ProcessImage(filePath, settings);
                        UploadCompletedEventArgs uploadArgs = new UploadCompletedEventArgs(task, userState);
                        onUploadFileCompleted(sender, uploadArgs);

                        // Wait until task finishes
                        while (true)
                        {
                            task = _syncClient.GetTaskStatus(task.Id);
                            if (!task.IsTaskActive())
                            {
                                break;
                            }
                            Thread.Sleep(1000);
                        }

                        if (task.Status == TaskStatus.NotEnoughCredits)
                        {
                            throw new Exception("Not enough credits to process image. Please add more pages to your application's account.");
                        }

                        TaskEventArgs taskArgs = new TaskEventArgs(task, null, false, userState);

                        onProcessingCompleted(sender, taskArgs);
                    }
                    catch (Exception ex)
                    {
                        TaskEventArgs taskArgs = new TaskEventArgs(task, ex, false, userState);
                        onProcessingCompleted(sender, taskArgs);
                    }
                }
            );

            w.RunWorkerAsync();
        }