Esempio n. 1
0
        public List <AllInfoHTMLPage> GetAllPropertyInfoPages(List <PropertyList> pl, IProgress <AsyncProgress> progress)
        {
            var pages = new List <AllInfoHTMLPage>();
            var ap    = new AsyncProgress();

            string currKeyword = "";

            //Get the value of progress for each property
            int x = 0;

            foreach (var _pl in pl)
            {
                //Get the property's webpages (property info, residential/commercial building data, tax info and property record card)
                pages.Add(GetEntryInfo(_pl.PropertyID));

                //Set Async Progress and Logging
                x++;
                ap.ProgressText  = $"Processing. . . .{ x }/{ pl.Count }";
                ap.ProgressValue = (x * 100) / pl.Count;
                ap.LogText       = $"R{ _pl.PropertyID }. . . .Done{ NewLine }";
                if (currKeyword != _pl.Keyword) //Only display the message at start of every keyword result (applicable only for multiple keywords)
                {
                    ap.LogText = $"{ NewLine }Fetching webpages for keyword: { _pl.Keyword }{ NewLine }{ ap.LogText }";
                }
                progress.Report(ap);

                currKeyword = _pl.Keyword;
            }

            return(pages);
        }
Esempio n. 2
0
        async Task checkConnection()
        {
            DialogService dialog = new DialogService();

            ProgressDialogController AsyncProgress;

            //Ejecutamos el método para enviar un mensaje de espera mientras se comprueban los datos.
            AsyncProgress = await dialog.SendProgressAsync("Espere...", "Verificando el estatus de la conexión");

            string respuesta = await DataManager.GetStatusConetionSQLServer();

            if (respuesta == "Error")
            {
                btn_ingresar.IsEnabled = false;
                Uri resource = new Uri("/Images/circle_red.png", UriKind.Relative);
                imgEnLinea.Source  = new BitmapImage(resource);
                lblEstatus.Content = "Offline";
            }
            else
            {
                Uri resource = new Uri("/Images/circle_green.png", UriKind.Relative);
                imgEnLinea.Source  = new BitmapImage(resource);
                lblEstatus.Content = "on-Line";
            }

            //Ejecutamos el método para cerrar el mensaje de espera.
            await AsyncProgress.CloseAsync();
        }
Esempio n. 3
0
 public RestClientWrapper(string serviceBase, string folder, WindowBase windowBase, bool isShow = true)
     : this()
 {
     client.BaseAddress = new Uri(client.BaseAddress, serviceBase);
     client.DefaultRequestHeaders.Add("Folder", folder);
     this.windowBase = windowBase;
     AsyncProgress.GetInstance().InjectWindowBase(windowBase, isShow);
 }
Esempio n. 4
0
        protected async Task <TOut> DeleteAsync <TOut>(string relativeUri)
        {
            AsyncProgress.GetInstance().ShowPopup();
            Uri uri = new Uri(string.Concat(client.BaseAddress.AbsoluteUri, "/", relativeUri));
            HttpResponseMessage response = await client.DeleteAsync(uri);

            AsyncProgress.GetInstance().HidePopup();
            response.EnsureSuccessStatusCode();
            return(await response.Content.ReadAsAsync <TOut>());
        }
Esempio n. 5
0
 private void MainForm_FormClosing(object sender, FormClosingEventArgs e)
 {
     foreach (TaskScheduler task in ProgressList)
     {
         task.Exit(true);
     }
     if (AsyncProgress != null)
     {
         AsyncProgress.Exit(true);
     }
 }
Esempio n. 6
0
        private List <PropertyList> GetEntriesListAsync(int selectedFilter, List <Keywords> keywords, IProgress <AsyncProgress> progress)
        {
            var pa = new AsyncProgress();

            pa.LogText      = $"{ NewLine }Retrieve properties summary. . . .{ NewLine }";
            pa.ProgressText = "";
            progress.Report(pa);

            var pl = new List <PropertyList>();

            pl = ge.GetEntriesList(selectedFilter, keywords, progress);

            return(pl);
        }
Esempio n. 7
0
        protected async Task <T> GetAsync <T>(string relativeUri)
        {
            AsyncProgress.GetInstance().ShowPopup();
            Uri uri = new Uri(string.Concat(client.BaseAddress.AbsoluteUri, "/", relativeUri));
            HttpResponseMessage response = await client.GetAsync(uri, HttpCompletionOption.ResponseContentRead);

            AsyncProgress.GetInstance().HidePopup();
            if (response.IsSuccessStatusCode)
            {
                return(await response.Content.ReadAsAsync <T>());
            }
            else
            {
                return(default(T));
            }
        }
        void ReleaseDesignerOutlets()
        {
            if (AsyncProgress != null)
            {
                AsyncProgress.Dispose();
                AsyncProgress = null;
            }

            if (FeedbackLabel != null)
            {
                FeedbackLabel.Dispose();
                FeedbackLabel = null;
            }

            if (Indeterminate != null)
            {
                Indeterminate.Dispose();
                Indeterminate = null;
            }

            if (LevelIndicator != null)
            {
                LevelIndicator.Dispose();
                LevelIndicator = null;
            }

            if (ProgressIndicator != null)
            {
                ProgressIndicator.Dispose();
                ProgressIndicator = null;
            }

            if (Rating != null)
            {
                Rating.Dispose();
                Rating = null;
            }

            if (Relevance != null)
            {
                Relevance.Dispose();
                Relevance = null;
            }
        }
Esempio n. 9
0
        protected async Task <TOut> PutAsync <TIn, TOut>(string relativeUri, TIn param)
        {
            AsyncProgress.GetInstance().ShowPopup();
            Uri uri = new Uri(string.Concat(client.BaseAddress.AbsoluteUri, "/", relativeUri));
            var microsoftDateFormatSettings = new JsonSerializerSettings
            {
                DateFormatHandling = DateFormatHandling.MicrosoftDateFormat
            };

            string microsoftJson         = JsonConvert.SerializeObject(param, microsoftDateFormatSettings);
            HttpResponseMessage response = await client.PutAsync(uri, new StringContent(
                                                                     microsoftJson,
                                                                     Encoding.UTF8, "application/json"));

            AsyncProgress.GetInstance().HidePopup();
            response.EnsureSuccessStatusCode();

            return(await response.Content.ReadAsAsync <TOut>());
        }
Esempio n. 10
0
        public void ParallelChunkedOneGig(int threadCount)
        {
            string path = "";

            try
            {
                var uri = new Uri(Constants.ONE_GIG_FILE_S_SL);
                path = SafePath("sites_vcf.gz");
                Action <string> logger = (message) => { };
                var             timer  = new Stopwatch();
                //a list to hold measured transfer rates
                var transferRateList = new List <double>();
                var asyncProgress    = new AsyncProgress <LargeFileDownloadProgressChangedEventArgs>(
                    obj =>
                {
                    transferRateList.Add(obj.DownloadBitRate);
                    logger("progress");
                });

                var manager = new BufferManager(new[] { new BufferQueueSetting(SimpleHttpGetByRangeClient.BUFFER_SIZE, (uint)threadCount), new BufferQueueSetting(LargeFileDownloadParameters.DEFAULT_MAX_CHUNK_SIZE) });
                ILargeFileDownloadParameters parameters = new LargeFileDownloadParameters(uri, path, 1297662912, null, maxThreads: threadCount);

                timer.Start();

                Task task = parameters.DownloadAsync(logger: logger, bufferManager: manager, progress: asyncProgress);

                task.Wait(TimeSpan.FromMinutes(25));
                timer.Stop();

                var averageTransferRate = transferRateList.Average();
                Debug.WriteLine("Took {0} threads {1} ms with average transfer rate of {2}", threadCount, timer.ElapsedMilliseconds, averageTransferRate);
                //try to open the file
                ValidateGZip(path, parameters.FileSize, Constants.ONE_GIG_CHECKSUM);

                //We expect that the approximate bytes transferred (calculated using average transfer rate) is with maximim error of 30% (accuracy of atleast 70%)
                Assert.AreEqual(parameters.FileSize, averageTransferRate * timer.Elapsed.TotalSeconds, 0.30 * parameters.FileSize);
            }
            finally
            {
                File.Delete(path);
            }
        }
        public override void AwakeFromNib()
        {
            base.AwakeFromNib();

            // Start animation on progress bars
            Indeterminate.StartAnimation(this);
            AsyncProgress.StartAnimation(this);

            // Wireup controls
            LevelIndicator.Activated += (sender, e) => {
                FeedbackLabel.StringValue = string.Format("Level: {0:###}", LevelIndicator.DoubleValue);
            };

            Rating.Activated += (sender, e) => {
                FeedbackLabel.StringValue = string.Format("Rating: {0:###}", Rating.DoubleValue);
            };

            Relevance.Activated += (sender, e) => {
                FeedbackLabel.StringValue = string.Format("Relevance: {0:###}", Relevance.DoubleValue);
            };
        }
Esempio n. 12
0
        public void DownloadSmallerFile()
        {
            //8 threads
            //MaxChunkSize = 1048576
            //FileSize = 5242880

            var             uri    = new Uri(Constants.FIVE_MEG_FILE);
            var             path   = SafePath("sites_vcf.gz");
            Action <string> logger = (message) => { };

            var transferRateList = new List <double>();
            var asyncProgress    = new AsyncProgress <LargeFileDownloadProgressChangedEventArgs>(
                obj =>
            {
                transferRateList.Add(obj.DownloadBitRate);
                Debug.WriteLine(obj.DownloadBitRate);
                logger("progress");
            });

            var timer = new Stopwatch();

            timer.Start();
            ILargeFileDownloadParameters parameters = new LargeFileDownloadParameters(uri, path, 1048576, null, maxThreads: 8);
            Task task = parameters.DownloadAsync(logger: logger, progress: asyncProgress);

            task.Wait(TimeSpan.FromMinutes(1));
            timer.Stop();
            var averageTransferRate = transferRateList.Average();

            //try to open the file
            ValidateGZip(path, parameters.FileSize, Constants.FIVE_MEG_CHECKSUM);

            if (averageTransferRate > 0)// sometimes tx rate is 0, possibly due to caching
            {
                Debug.WriteLine("Took {0} threads {1} ms with average transfer rate of {2}", 8, timer.ElapsedMilliseconds, averageTransferRate);
                //We expect that the approximate bytes transferred (calculated using average transfer rate) is with maximim error of 40% (accuracy of atleast 60%) because it is a small file and txrate is calculated once every two seconds.
                Assert.GreaterOrEqual(averageTransferRate * timer.Elapsed.TotalSeconds, 0.40 * parameters.FileSize);
            }
        }
Esempio n. 13
0
        public List <PropertyList> ParseEntriesList(string keyword, string pageText, IProgress <AsyncProgress> progress)
        {
            try
            {
                List <PropertyList> pl = new List <PropertyList>();
                var ap = new AsyncProgress();

                if (pageText.Contains("recordsTotal\":0,"))
                {
                    ap.LogText = $"{ NewLine }Parsing properties summary for keyword: { keyword }{ NewLine }0 Entries found{ NewLine }";
                    //ap.ProgressValue = 100;
                    progress.Report(ap);
                    return(pl);
                }
                else
                {
                    string[] entries = Regex.Split(pageText, "},{");
                    for (int i = 0; i < entries.Length; i++)
                    {
                        pl.Add(new PropertyList()
                        {
                            Keyword = keyword, PropertyID = Regex.Match(entries[i], "propertyId\":(.+?),\"countyCode").Groups[1].Value
                        });
                    }

                    ap.LogText = $"{ NewLine }Parsing properties summary for keyword: { keyword }{ NewLine }{ pl.Count } Entries found{ NewLine }";
                    progress.Report(ap);

                    return(pl);
                }
            }
            catch (Exception e)
            {
                MessageBox.Show($"Error occured when parsing Properties List using \"{ keyword }\" keyword{ NewLine }{ e.Message }");
                throw e;
            }
        }
Esempio n. 14
0
        public List <PropertyList> GetEntriesList(int selectedFilter, List <Keywords> keywords, IProgress <AsyncProgress> progress)
        {
            var pl = new List <PropertyList>();
            var ap = new AsyncProgress();

            CookieContainer cookies;
            HttpWebRequest  request;
            HttpWebResponse response;

            var searchBy = (SearchBy)selectedFilter;

            var responseData = "";
            var strUrl       = "";
            var postData     = "";

            foreach (var keyword in keywords)
            {
                try
                {
                    //Navigate to main website
                    strUrl                  = @"https://ares.sncoapps.us/?clearFilters=True";
                    postData                = "";
                    cookies                 = new CookieContainer();
                    request                 = (HttpWebRequest)WebRequest.Create(strUrl);
                    request.Method          = "GET";
                    request.Accept          = "text/html";
                    request.ContentType     = "application/x-www-form-urlencoded";
                    request.ContentLength   = postData.Length;
                    request.CookieContainer = cookies;
                    request.Timeout         = Timeout.Infinite;
                    request.UserAgent       = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.132 Safari/537.36";
                    response                = (HttpWebResponse)request.GetResponse();
                    response.Cookies        = request.CookieContainer.GetCookies(request.RequestUri);
                    var encoding       = new System.Text.UTF8Encoding();
                    var responseReader = new StreamReader(response.GetResponseStream(), encoding, true);
                    responseData = responseReader.ReadToEnd();
                    response.Close();
                    responseReader.Close();

                    strUrl                    = $"https://ares.sncoapps.us/BasicSearch/Results?clearFilters=true&CountyCode=089&grayCheckBox=true&SearchCriteria={ keyword.Keyword }&searchBy={ searchBy }&grayCheckBox=false";
                    postData                  = "";
                    cookies                   = new CookieContainer();
                    request                   = (HttpWebRequest)WebRequest.Create(strUrl);
                    request.Method            = "GET";
                    request.Accept            = "text/html";
                    request.ContentType       = "application/x-www-form-urlencoded";
                    request.UserAgent         = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.132 Safari/537.36";
                    request.ContentLength     = postData.Length;
                    request.CookieContainer   = cookies;
                    request.Timeout           = Timeout.Infinite;
                    request.AllowAutoRedirect = true;
                    response                  = (HttpWebResponse)request.GetResponse();
                    response.Cookies          = request.CookieContainer.GetCookies(request.RequestUri);
                    encoding                  = new System.Text.UTF8Encoding();
                    responseReader            = new StreamReader(response.GetResponseStream(), encoding, true);
                    responseData              = responseReader.ReadToEnd();
                    response.Close();
                    responseReader.Close();

                    strUrl                  = $"https://ares.sncoapps.us/BasicSearch/ResultsJson?searchCriteria={ keyword.Keyword }&countyCode=089&listMode=card&searchBy={ searchBy }&_=1600158783610";
                    postData                = "";
                    cookies                 = new CookieContainer();
                    request                 = (HttpWebRequest)WebRequest.Create(strUrl);
                    request.Method          = "GET";
                    request.Accept          = "text/html";
                    request.ContentType     = "application/x-www-form-urlencoded";
                    request.ContentLength   = postData.Length;
                    request.CookieContainer = cookies;
                    request.Timeout         = Timeout.Infinite;
                    request.UserAgent       = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.132 Safari/537.36";
                    response                = (HttpWebResponse)request.GetResponse();
                    response.Cookies        = request.CookieContainer.GetCookies(request.RequestUri);
                    encoding                = new System.Text.UTF8Encoding();
                    responseReader          = new StreamReader(response.GetResponseStream(), encoding, true);
                    responseData            = responseReader.ReadToEnd();
                    response.Close();
                    responseReader.Close();

                    //if (!responseData.Contains("recordsTotal\":0"))
                    pl.AddRange(ep.ParseEntriesList(keyword.Keyword, responseData, progress));

                    ap.LogText      = "";
                    ap.ProgressText = $"Properties found: { pl.Count }";
                    progress.Report(ap);
                }
                catch (Exception e)
                {
                    MessageBox.Show($"Error occured when fetching Property List webpage using \"{ keyword.Keyword }\" keyword{ NewLine }{ e.Message }");
                    throw e;
                }
            }

            return(pl);
        }
Esempio n. 15
0
        private async void AdjuntarArchivo()
        {
            ListaDocumentos.Clear();

            string filename = "";

            //Incializamos los servicios de dialog.
            DialogService dialog = new DialogService();


            //Declaramos un objeto de tipo ProgressDialogController, el cual servirá para recibir el resultado el mensaje progress.
            ProgressDialogController AsyncProgress;

            MetroDialogSettings setting = new MetroDialogSettings();

            setting.AffirmativeButtonText = StringResources.lblYes;
            setting.NegativeButtonText    = StringResources.lblNo;

            //Abre la ventana de explorador de archivos
            Microsoft.Win32.OpenFileDialog dlg = new Microsoft.Win32.OpenFileDialog();
            dlg.Filter = "PDF Files (.pdf)|*.pdf";

            Nullable <bool> result;

            // Mostrar el explorador de archivos
            result = dlg.ShowDialog();

            //Se crea el objeto de tipo archivo
            Archivo obj = new Archivo();

            if (result == true)
            {
                //Se obtiene el nombre del documento
                filename = dlg.FileName;

                //Si el archivo no está en uso
                if (!Module.IsFileInUse(filename))
                {
                    //Ejecutamos el método para enviar un mensaje de espera mientras se comprueban los datos.
                    AsyncProgress = await dialog.SendProgressAsync(StringResources.msgEspera, StringResources.msgInsertando);

                    //Se convierte el archvio a tipo byte y se le asigna al objeto
                    obj.archivo = await Task.Run(() => File.ReadAllBytes(filename));

                    //Obtiene la extensión del documento y se le asigna al objeto
                    obj.ext = System.IO.Path.GetExtension(filename);

                    //Se obtiene sólo el nombre, sin extensión.
                    obj.nombre = System.IO.Path.GetFileNameWithoutExtension(filename);

                    //asigna la imagen del pdf al objeto
                    obj.ruta = @"/Images/p.png";

                    DataManagerControlDocumentos.InsertDocumentoFirmado(obj, SelectedDocumento.version.id_version);

                    //si se agrego el archivo correspondiente lo agregamos a la lista temporal
                    ListaDocumentos.Add(obj);

                    //Ejecutamos el método para cerrar el mensaje de espera.
                    await AsyncProgress.CloseAsync();

                    await dialog.SendMessage("Genial!!!", "Tu documento ya fué enviado al administrador de CIT para su liberación.\nSi todo esta correcto recibiras un correo confirmando su liberación,\n de lo contrario recibiras un correo informandote el estátus de tu documento.");
                }
                else
                {
                    //Si el archivo está abierto mandamos un mensaje indicando que se debe cerrar el archivo para poder adjuntarlo.
                    await dialog.SendMessage(StringResources.ttlAlerta, StringResources.msgCierreArchivo);
                }
            }
        }
Esempio n. 16
0
        private static bool ProcessArgs(string[] args)
        {
            var options = new DownloadOptions();

            try
            {
                var optionSet = CreateOptions(options);
                optionSet.Parse(args);

                if (options.ShowHelp || (options.Uri == null))
                {
                    optionSet.WriteOptionDescriptions(Console.Out);
                }
                else if (options.HasException)
                {
                    Console.WriteLine(options.Exception.Message);
                }
                else
                {
                    //go get file size
                    GetSizeAndSource(options);
                    LargeFileDownloadParameters parameters = null;
                    if (options.Uri != null && options.FileSize.HasValue && options.FileSize.Value > 0)
                    {
                        parameters = new LargeFileDownloadParameters(options.Uri, options.OutputFile,
                                                                     options.FileSize.Value,
                                                                     options.MaxThreads, options.MaxChunkSize);
                    }


                    if (parameters != null)
                    {
                        Action <string> logger = (message) => Debug.WriteLine(message);
                        var             token  = new CancellationToken();
                        var             watch  = new Stopwatch();
                        watch.Start();
                        IAsyncProgress <LargeFileDownloadProgressChangedEventArgs> progress = new AsyncProgress <LargeFileDownloadProgressChangedEventArgs>(Handler);
                        var task = parameters.DownloadAsync(token, progress, logger);
                        task.Wait();
                        watch.Stop();
                        ClearCurrentConsoleLine();

                        Console.WriteLine("done in {0}ms ({1}m {2}s {3}ms", watch.ElapsedMilliseconds, watch.Elapsed.Minutes, watch.Elapsed.Seconds, watch.Elapsed.Milliseconds);
                        if (options.IsInteractive)
                        {
                            return(true);
                        }
                        Environment.Exit(0);
                    }
                }
            }
            catch (Exception e)
            {
                Console.WriteLine(e.Message);
                if (options.IsInteractive)
                {
                    return(true);
                }
                Environment.Exit(-1);
            }
            return(!options.ShouldExit);
        }
Esempio n. 17
0
 private void ReportProgress(object sender, AsyncProgress e)
 {
     txtLogs.AppendText(e.LogText);
     progBar.Value    = e.ProgressValue;
     lblProgress.Text = e.ProgressText;
 }
        /// <summary>
        /// Método para adjuntar archivos a las lecciones aprendidas
        /// </summary>
        public async void AdjuntarArchivo()
        {
            //Inicializamos los servicios de dialog
            DialogService dialog = new DialogService();

            //Declaramos un objeto de tipo ProgressDialogController, el cual servirá para recibir el resultado el mensaje progress.
            ProgressDialogController AsyncProgress;

            //Inicializamos los servicios de metrodialog
            MetroDialogSettings settings = new MetroDialogSettings();

            //Declaramos las posibles respuestas del metrodialog
            settings.AffirmativeButtonText = StringResources.lblYes;
            settings.NegativeButtonText    = StringResources.lblNo;

            //abrimos la ventana para buscar el archivo a insertar
            Microsoft.Win32.OpenFileDialog dlg = new Microsoft.Win32.OpenFileDialog();

            //obtenemos el archivo seleccionado
            Nullable <bool> result = dlg.ShowDialog();

            //Inicializamos una variable de tipo archivo_lecciones aprendidas que nos ayudara a guardar los datos del archivo a insertar
            Archivo_LeccionesAprendidas Archivo = new Archivo_LeccionesAprendidas();

            //Verificamos que se haya insertado un archivo
            if (result == true)
            {
                try
                {
                    //Obtenemos el nombre del archivo
                    string filename = dlg.FileName;

                    //Verificamos que no se encuentre abierto el archivo,si el archivo no esta entra en la condicion para agregar el archivo
                    if (!Module.IsFileInUse(filename))
                    {
                        //Mandamos un mensaje de espera mientras se inserta el archivo a la lista de documentos
                        AsyncProgress = await dialog.SendProgressAsync(StringResources.msgEspera, StringResources.msgInsertando);

                        //Obtenemos los datos del archivo que vayamos a insertar
                        Archivo.ARCHIVO = await Task.Run(() => File.ReadAllBytes(filename));

                        Archivo.EXT            = System.IO.Path.GetExtension(filename);
                        Archivo.NOMBRE_ARCHIVO = System.IO.Path.GetFileNameWithoutExtension(filename);

                        //dependiendo la extensíon del archivo se agrega la ruta de imagen para visualisarla
                        switch (Archivo.EXT)
                        {
                        case ".doc":
                            Archivo.rutaIcono = @"/Images/w.png";

                            break;

                        case ".docx":
                            Archivo.rutaIcono = @"/Images/w.png";

                            break;

                        case ".pdf":
                            Archivo.rutaIcono = @"/Images/p.png";

                            break;

                        case ".xls":
                            Archivo.rutaIcono = @"/Images/E.jpg";

                            break;

                        case ".xlsx":
                            Archivo.rutaIcono = @"/Images/E.jpg";

                            break;

                        case "ppt":
                            Archivo.rutaIcono = @"/Images/PP.png";

                            break;

                        //todos los archivos que no tengan alguna de las extenciones antes mencionadas entraran aqui y se les pondra una imagen general
                        default:
                            Archivo.rutaIcono = @"/Images/I.png";
                            break;
                        }
                        //Agregamos el archivo a la lista, SOLO SE AGREGA LOCALMENTE, AUN NO LO INSERTAMOS EN LA BASE DE DATOS
                        ListaDocumentos.Add(Archivo);

                        //Cerramos el mensaje de espera
                        await AsyncProgress.CloseAsync();
                    }
                    else
                    {
                        //Si el archivo esta en uso se manda un mensaje para que lo cierre
                        await dialog.SendMessage(StringResources.ttlAlerta, StringResources.msgCierreArchivo);
                    }
                }
                catch (Exception)
                {
                    //Si no se pudo cargar el archivo se manda un mensaje de error
                    await dialog.SendMessage(StringResources.ttlAlerta, StringResources.msgError);
                }
            }
        }
Esempio n. 19
0
        private static bool ProcessArgs(string[] args)
        {
            var options = new DownloadOptions();
            try
            {

                var optionSet = CreateOptions(options);
                optionSet.Parse(args);

                if (options.ShowHelp || (options.Uri == null))
                {
                    optionSet.WriteOptionDescriptions(Console.Out);
                }
                else if (options.HasException)
                {
                    Console.WriteLine(options.Exception.Message);
                }
                else
                {
                    //go get file size
                    GetSizeAndSource(options);
                    LargeFileDownloadParameters parameters = null;
                    if (options.Uri != null && options.FileSize.HasValue && options.FileSize.Value > 0)
                    {
                        parameters = new LargeFileDownloadParameters(options.Uri, options.OutputFile,
                                                                     options.FileSize.Value,
                                                                     options.MaxThreads, options.MaxChunkSize);
                    }

                    if (parameters != null)
                    {
                        Action<string> logger = (message) => Debug.WriteLine(message);
                        var token = new CancellationToken();
                        var watch = new Stopwatch();
                        watch.Start();
                        IAsyncProgress<LargeFileDownloadProgressChangedEventArgs> progress =new AsyncProgress<LargeFileDownloadProgressChangedEventArgs>(Handler);
                        var task = parameters.DownloadAsync(token, progress, logger);
                        task.Wait();
                        watch.Stop();
                       ClearCurrentConsoleLine();

                        Console.WriteLine("done in {0}ms ({1}m {2}s {3}ms", watch.ElapsedMilliseconds, watch.Elapsed.Minutes, watch.Elapsed.Seconds, watch.Elapsed.Milliseconds);
                        if (options.IsInteractive)
                        {
                            return true;
                        }
                        Environment.Exit(0);

                    }

                }
            }
            catch (Exception e)
            {
                Console.WriteLine(e.Message);
                if (options.IsInteractive)
                {
                    return true;
                }
                Environment.Exit(-1);
            }
            return !options.ShouldExit;
        }
Esempio n. 20
0
        public void ParallelChunkedOneGig(int threadCount)
        {
            string path = "";
              try
              {
                  var uri = new Uri(Constants.ONE_GIG_FILE_S_SL);
                  path = SafePath("sites_vcf.gz");
                  Action<string> logger = (message) => { };
                  var timer = new Stopwatch();
                  //a list to hold measured transfer rates
                  var transferRateList = new List<double>();
                  var asyncProgress = new AsyncProgress<LargeFileDownloadProgressChangedEventArgs>(
                      obj =>
                      {
                          transferRateList.Add(obj.DownloadBitRate);
                          logger("progress");
                      });

                  var manager = new BufferManager(new[] { new BufferQueueSetting(SimpleHttpGetByRangeClient.BUFFER_SIZE, (uint)threadCount), new BufferQueueSetting(LargeFileDownloadParameters.DEFAULT_MAX_CHUNK_SIZE) });
                  ILargeFileDownloadParameters parameters = new LargeFileDownloadParameters(uri, path, 1297662912, null, maxThreads: threadCount);

                  timer.Start();

                  Task task = parameters.DownloadAsync(logger: logger, bufferManager: manager, progress: asyncProgress);

                  task.Wait(TimeSpan.FromMinutes(25));
                  timer.Stop();

                  var averageTransferRate = transferRateList.Average();
                  Debug.WriteLine("Took {0} threads {1} ms with average transfer rate of {2}", threadCount, timer.ElapsedMilliseconds, averageTransferRate);
                  //try to open the file
                  ValidateGZip(path, parameters.FileSize, Constants.ONE_GIG_CHECKSUM);

                  //We expect that the approximate bytes transferred (calculated using average transfer rate) is with maximim error of 30% (accuracy of atleast 70%)
                  Assert.AreEqual(parameters.FileSize, averageTransferRate * timer.Elapsed.TotalSeconds, 0.30 * parameters.FileSize);
              }
              finally
              {
                  File.Delete(path);
              }
        }
Esempio n. 21
0
        public void DownloadSmallerFile()
        {
            //8 threads
            //MaxChunkSize = 1048576
            //FileSize = 5242880

            var uri = new Uri(Constants.FIVE_MEG_FILE);
            var path = SafePath("sites_vcf.gz");
            Action<string> logger = (message) => { };

            var transferRateList = new List<double>();
            var asyncProgress = new AsyncProgress<LargeFileDownloadProgressChangedEventArgs>(
                obj =>
                {
                    transferRateList.Add(obj.DownloadBitRate);
                    Debug.WriteLine(obj.DownloadBitRate);
                    logger("progress");
                });

            var timer = new Stopwatch();
            timer.Start();
            ILargeFileDownloadParameters parameters = new LargeFileDownloadParameters(uri, path, 1048576, null, maxThreads: 8);
            Task task = parameters.DownloadAsync(logger: logger, progress:asyncProgress);
            task.Wait(TimeSpan.FromMinutes(1));
            timer.Stop();
            var averageTransferRate = transferRateList.Average();

            //try to open the file
            ValidateGZip(path, parameters.FileSize, Constants.FIVE_MEG_CHECKSUM);

            if (averageTransferRate > 0)// sometimes tx rate is 0, possibly due to caching
            {
                Debug.WriteLine("Took {0} threads {1} ms with average transfer rate of {2}", 8, timer.ElapsedMilliseconds, averageTransferRate);
                //We expect that the approximate bytes transferred (calculated using average transfer rate) is with maximim error of 40% (accuracy of atleast 60%) because it is a small file and txrate is calculated once every two seconds.
                Assert.GreaterOrEqual(averageTransferRate * timer.Elapsed.TotalSeconds, 0.40 * parameters.FileSize);
            }
        }
Esempio n. 22
0
        /// <summary>
        /// Método que inserta un archivo.
        /// </summary>
        private async void InsertArchivo()
        {
            //Inicializamos los servici de Dialog.
            DialogService ServiceDialog = new DialogService();

            //Declaramos un objeto de tipo ProgressDialogController, el cual servirá para recibir el resultado el mensaje progress.
            ProgressDialogController AsyncProgress;

            //Declaramos un objeto de tipo OpenFileDialog.
            Microsoft.Win32.OpenFileDialog dialog = new Microsoft.Win32.OpenFileDialog();

            //Abrimos la ventana para que seleccione un archivo.
            Nullable <bool> result = dialog.ShowDialog();

            //Verificamos si el usuario eligió un documento.
            if (result == true)
            {
                try
                {
                    //Obtenemos el nombre del archivo y lo asignamos a una variable.
                    string fileName = dialog.FileName;

                    //Declaramos un objeto de tipo Archivo.
                    Archivo obj = new Archivo();
                    //Si el archivo no está en uso
                    if (!IsFileInUse(fileName))
                    {
                        //Ejecutamos el método para enviar un mensaje de espera mientras se comprueban los datos.
                        AsyncProgress = await ServiceDialog.SendProgressAsync(StringResources.msgEspera, StringResources.msgInsertando);

                        //Asignamos el archivo que seleccionó el usuario al objeto declarado.
                        obj.archivo = await Task.Run(() => File.ReadAllBytes(fileName));

                        obj.ext    = System.IO.Path.GetExtension(fileName);
                        obj.nombre = System.IO.Path.GetFileNameWithoutExtension(fileName);

                        //Insertamos el archivo.
                        int r = DataManagerControlDocumentos.InsertRecurso(obj.archivo, obj.nombre, obj.ext, obj.nombre, SelectedTipoDocumento.id_tipo);

                        //Ejecutamos el método para cerrar el mensaje de espera.
                        await AsyncProgress.CloseAsync();

                        //Enviamos un mensaje dependiendo la respuesta.
                        if (r > 0)
                        {
                            await ServiceDialog.SendMessage(StringResources.ttlAlerta, StringResources.msgArchivoInsertado);

                            Consultar();
                        }

                        else
                        {
                            await ServiceDialog.SendMessage(StringResources.ttlAlerta, StringResources.msgErrorInsertarArchivo);
                        }
                    }
                    else
                    {
                        await ServiceDialog.SendMessage(StringResources.ttlAlerta, StringResources.msgCierreArchivo);
                    }
                }
                catch (IOException)
                {
                    await ServiceDialog.SendMessage(StringResources.ttlAlerta, StringResources.msgCierreArchivo);
                }
            }
        }
Esempio n. 23
0
        async void Btn_ingresar_Click(object sender, RoutedEventArgs e)
        {
            LoginDialogSettings settings = new LoginDialogSettings();

            settings.ColorScheme           = MetroDialogOptions.ColorScheme;
            settings.PasswordWatermark     = "Password";
            settings.UsernameWatermark     = "Username";
            settings.InitialPassword       = "******";
            settings.InitialUsername       = "******";
            settings.AffirmativeButtonText = StringResources.lblBtnLogin;


            //Abrimos el mensaje modal para que el usuario ingrese sus credenciales, el resultado lo guardamos en una variable local.
            LoginDialogData result = await this.ShowLoginAsync(StringResources.ttlAuthentication, StringResources.lblEnterCredentials, settings);

            //Comparamos si el resultado es distinto de nulo. Si es igual a nulo quiere decir que el usuario cancelo la captura o cerró inesperadamente la pantalla.
            if (result != null)
            {
                //Incializamos los servicios de dialog.
                DialogService dialog = new DialogService();

                //Declaramos un objeto de tipo ProgressDialogController, el cual servirá para recibir el resultado el mensaje progress.
                ProgressDialogController AsyncProgress;

                //Ejecutamos el método para enviar un mensaje de espera mientras se comprueban los datos.
                AsyncProgress = await dialog.SendProgressAsync(StringResources.lblLogIn, "");

                //Declaramos un objeto con el cual se realiza la encriptación
                Services.Encriptacion encriptar = new Services.Encriptacion();

                //Ejecutamos el método para encriptar tanto el usuario como la contraseña y los guardamos en variables locales respectivamente.
                string usuario    = encriptar.encript(result.Username);
                string contrasena = encriptar.encript(result.Password);

                //Ejecutamos el método para verificar las credenciales, el resultado lo asignamos a un objeto local de tipo Usuario.
                Usuario usuarioConectado = await DataManager.GetLogin(usuario, contrasena);

                //Verificamos el resultado, si es direfente de nulo quiere decir que el logueo fué correcto, si es igual a nulo quiere decir que el usuario no existe con las credenciales proporcionadas.
                if (usuarioConectado != null)
                {
                    //Ejecutamos el método para cerrar el mensaje de espera.
                    await AsyncProgress.CloseAsync();

                    //Verificamos si el usuario no esta bloqueado.
                    if (usuarioConectado.Block)
                    {
                        //Enviamos un mensaje para indicar que el usuario está bloqueado.
                        MessageDialogResult message = await this.ShowMessageAsync(StringResources.lblInformation, StringResources.lblUserNotActive);
                    }
                    else
                    {
                        SpeechSynthesizer _SS = new SpeechSynthesizer();
                        _SS.Volume = 100;
                        _SS.Rate   = 1;

                        _SS.SpeakAsync("Welcome, " + usuarioConectado.Nombre + ", To Process Design Engineering Program");

                        //Enviamos un mensaje de bienvenida al usuario.
                        MessageDialogResult message = await this.ShowMessageAsync(StringResources.lblWelcome, usuarioConectado.Nombre);

                        //Obtenemos la fecha del servidor
                        DateTime date_now = DataManagerControlDocumentos.Get_DateTime();
                        //Ejecutamos el método para desbloquear el sistema, si se venció la fecha final
                        DataManagerControlDocumentos.DesbloquearSistema(date_now);

                        //Obtenemos los detalles del usuario logueado.
                        usuarioConectado.Details = DataManager.GetUserDetails(usuarioConectado.NombreUsuario);

                        //Verificamos si esta cargada la foto, sino asignamos una por default.
                        if (string.IsNullOrEmpty(usuarioConectado.Details.PathPhoto))
                        {
                            usuarioConectado.Details.PathPhoto = System.Configuration.ConfigurationManager.AppSettings["PathDefaultImage"];
                        }

                        //Insertamos el ingreso a la bitácora.
                        DataManager.InserIngresoBitacora(Environment.MachineName, usuarioConectado.Nombre + " " + usuarioConectado.ApellidoPaterno + " " + usuarioConectado.ApellidoMaterno);

                        //Validamos si el usuario nuevo tiene la contraseña random
                        if (usuarioConectado.Details.Temporal_Password == true)
                        {
                            //Cargamnos las vista de ModificarContrasena
                            ModificarContrasena vistacontrasena = new ModificarContrasena();
                            //Cargamnos el modelo de CambiarContraseniaViewModel
                            CambiarContraseniaViewModel vmcambiarconatraseña = new CambiarContraseniaViewModel(usuarioConectado);

                            //Asingamos el DataContext.
                            vistacontrasena.DataContext = vmcambiarconatraseña;

                            //Mostramos la ventana de modificacion de contraseña
                            vistacontrasena.ShowDialog();

                            //Verificamos el valor de la variable CierrePantalla, si en la View Model de CambiarContrasenia la variable es false, dejamos continual el proceso
                            if (vmcambiarconatraseña.CierrePantalla == false)
                            {
                                return;
                            }
                        }

                        #region Configuración del correo electrónico

                        //Verificamos si esta configurado el correo electrónico en la plataforma.
                        //if (!usuarioConectado.Details.IsAvailableEmail || !System.IO.File.Exists(usuarioConectado.Pathnsf))
                        //{
                        //    //Configuramos las opciones del mesaje de pregunta.
                        //    MetroDialogSettings settings = new MetroDialogSettings();
                        //    settings.AffirmativeButtonText = StringResources.lblYes;
                        //    settings.NegativeButtonText = StringResources.lblNo;

                        //    //Preguntamos al usuario si lo quiere configurar en estos momentos.
                        //    MessageDialogResult resultMSG = await this.ShowMessageAsync(StringResources.ttlAtencion + usuarioConectado.Nombre, StringResources.msgConfiguracionCorreo, MessageDialogStyle.AffirmativeAndNegative, settings);

                        //    //Verificamos la respuesta del usuario, si es afirmativa iniciamos el proceso de configuración.
                        //    if (resultMSG == MessageDialogResult.Affirmative)
                        //    {
                        //        settings = new MetroDialogSettings();
                        //        settings.AffirmativeButtonText = StringResources.ttlOkEntiendo;

                        //        await this.ShowMessageAsync(usuarioConectado.Nombre + StringResources.msgParaTuInf, StringResources.msgProcesoConfiguracion, MessageDialogStyle.Affirmative, settings);

                        //        ProgressDialogController AsyncProgressConfigEmail;

                        //        AsyncProgressConfigEmail = await dialog.SendProgressAsync(StringResources.ttlEspereUnMomento + usuarioConectado.Nombre + "...", StringResources.msgEstamosConfigurando);

                        //        ConfigEmailViewModel configEmail = new ConfigEmailViewModel(usuarioConectado);

                        //        // Se reciben valores de las 2 propiedades del objeto
                        //        DO_PathMail respuestaConfigEmail = await configEmail.setEmail();

                        //        await AsyncProgressConfigEmail.CloseAsync();

                        //        if (respuestaConfigEmail.respuesta)
                        //        {
                        //            // Actualizamos el path de usuario en la misma sesión
                        //            usuarioConectado.Pathnsf = respuestaConfigEmail.rutamail;

                        //            settings.AffirmativeButtonText = StringResources.ttlGenial;
                        //            await this.ShowMessageAsync(StringResources.msgPerfecto + usuarioConectado.Nombre, StringResources.msgCuentaConfigurada, MessageDialogStyle.Affirmative, settings);
                        //        }
                        //        else
                        //        {
                        //            await this.ShowMessageAsync(StringResources.ttlOcurrioError, StringResources.msgErrorVincular);
                        //        }
                        //    }
                        //}

                        #endregion

                        if (Module.UsuarioIsRol(usuarioConectado.Roles, 2))
                        {
                            DashboardViewModel context;
                            FDashBoard         pDashBoard = new FDashBoard();
                            context = new DashboardViewModel(usuarioConectado);
                            context.ModelUsuario = usuarioConectado;

                            //NOTA IMPORTANTE: Se hizo una redundancia al asignarle en la propiedad página su misma pantalla. Solo es por ser la primera vez y tenernos en donde descanzar la primera pantalla.
                            context.Pagina = pDashBoard;

                            //Asignamos al DataContext de la PantallaHome el context creado anteriormente.
                            pDashBoard.DataContext = context;

                            //Declaramos la pantalla en la que descanzan todas las páginas.
                            Layout masterPage = new Layout();

                            //Asingamos el DataContext.
                            masterPage.DataContext = context;

                            //Ejecutamos el método el cual despliega la pantalla.
                            masterPage.ShowDialog();
                        }
                        else
                        {
                            Home PantallaHome = new Home(usuarioConectado.NombreUsuario);

                            //Creamos un objeto UsuarioViewModel, y le asignamos los valores correspondientes, a la propiedad Pagina se le asigna la pantalla inicial de Home.
                            UsuarioViewModel context = new UsuarioViewModel(usuarioConectado, PantallaHome);
                            context.ModelUsuario = usuarioConectado;

                            //NOTA IMPORTANTE: Se hizo una redundancia al asignarle en la propiedad página su misma pantalla. Solo es por ser la primeva vez y tenernos en donde descanzar la primera pantalla.
                            context.Pagina = PantallaHome;

                            //Asignamos al DataContext de la PantallaHome el context creado anteriormente.
                            PantallaHome.DataContext = context;

                            //Declaramos la pantalla en la que descanzan todas las páginas.
                            Layout masterPage = new Layout();

                            //Asingamos el DataContext.
                            masterPage.DataContext = context;

                            //Ejecutamos el método el cual despliega la pantalla.
                            masterPage.ShowDialog();
                        }

                        //Una vez que el usuario hizo clic en aceptar el mensaje de bienvenida, se procede con la codificación de la presentación de la pantalla inicial.
                        //Creamos un objeto de tipo Home, la cual es la pantalla inicial del sistema.
                        //Home PantallaHome = new Home(usuarioConectado.NombreUsuario);

                        //Creamos un objeto UsuarioViewModel, y le asignamos los valores correspondientes, a la propiedad Pagina se le asigna la pantalla inicial de Home.
                        //UsuarioViewModel context = new UsuarioViewModel { ModelUsuario = usuarioConectado, Pagina = PantallaHome };
                        //UsuarioViewModel context = new UsuarioViewModel(usuarioConectado, PantallaHome);
                        //context.ModelUsuario = usuarioConectado;

                        ////NOTA IMPORTANTE: Se hizo una redundancia al asignarle en la propiedad página su misma pantalla. Solo es por ser la primeva vez y tenernos en donde descanzar la primera pantalla.
                        //context.Pagina = PantallaHome;

                        ////Asignamos al DataContext de la PantallaHome el context creado anteriormente.
                        //PantallaHome.DataContext = context;

                        ////Declaramos la pantalla en la que descanzan todas las páginas.
                        //Layout masterPage = new Layout();

                        ////Asingamos el DataContext.
                        //masterPage.DataContext = context;

                        ////Ejecutamos el método el cual despliega la pantalla.
                        //masterPage.ShowDialog();


                        ////Si el usuario es administrador, le mostramos la pantalla de Dashboard.
                        //if (Module.UsuarioIsRol(usuarioConectado.Roles, 2))
                        //{
                        //    FDashBoard pDashBoard = new FDashBoard();

                        //    DashboardViewModel wm = new DashboardViewModel(pDashBoard, usuarioConectado);
                        //    pDashBoard.DataContext = wm;

                        //    //Declaramos la pantalla en la que descanzan todas las páginas.
                        //    Layout masterPage1 = new Layout();

                        //    //Asingamos el DataContext.
                        //    masterPage1.DataContext = wm;

                        //    //Ejecutamos el método el cual despliega la pantalla.
                        //    masterPage1.ShowDialog();

                        //}
                        //else
                        //{

                        //}
                    }
                }
                else
                {
                    //Ejecutamos el método para cerrar el mensaje de espera.
                    await AsyncProgress.CloseAsync();

                    //Enviamos un mensaje indicando que las credenciales escritas son incorrectas.
                    MessageDialogResult message = await this.ShowMessageAsync(StringResources.ttlAlerta, StringResources.lblPasswordIncorrect);
                }
            }
        }
        /// <summary>
        /// Método para adjuntar el documento de herramental para subir
        /// </summary>
        /// <param name="nombrearchivo"></param>
        public async void adjuntararchivoherramentales()
        {
            // Inicializamos los servicios
            DialogService dialog = new DialogService();

            //Declaramos un objeto de tipo ProgressDialogController, el cual servirá para recibir el resultado el mensaje progress.
            ProgressDialogController AsyncProgress;

            // Declaramos la ventana de explorador de archivos
            Microsoft.Win32.OpenFileDialog dlg = new Microsoft.Win32.OpenFileDialog();

            //Se crea el objeto de tipo archivo
            Archivo obj = new Archivo();

            // Filtramos los archivos Excel
            dlg.Filter = "Excel Files (.xlsm, .xlsx)|*.xlsm; *.xlsx";

            // Mensaje para informar nombre de celdas en archivo
            await dialog.SendMessage(StringResources.ttlAlerta, StringResources.msgCellsName);

            // Abrimos la ventana de explorador de archivos
            bool?respuesta = dlg.ShowDialog();

            // Validación que no truene si no se selecciona un archivo
            if (respuesta == true)
            {
                // Asignamos a la variable la ruta del archivo que fue seleccionado
                nombreArchivoAdjutado = dlg.FileName;

                // Validamos que el archivo no este abierto
                if (!Module.IsFileInUse(nombreArchivoAdjutado))
                {
                    // Declaramos librería para poder leer el archivo
                    SLDocument sl = new SLDocument(nombreArchivoAdjutado);

                    // Inicializamos variable para leer solo el primer registro o renglón
                    int iRow = 1;

                    // Obtenemos valores de las celdas A1, A2, A3 (títulos de columna)
                    string A1_Obtenida = sl.GetCellValueAsString(iRow, 1);
                    string A2_Obtenida = sl.GetCellValueAsString(iRow, 2);
                    string A3_Obtenida = sl.GetCellValueAsString(iRow, 3);

                    // Nombre que deberán contener dichas celdas
                    string CellA1 = "Componente";
                    string CellA2 = "Codigo_Herramental";
                    string CellA3 = "Descripcion";

                    // Validamos que el valor de las celdas obtenidas sea igual al valor necesario
                    if ((A1_Obtenida.ToUpper() == CellA1.ToUpper()) && (A2_Obtenida.ToUpper() == CellA2.ToUpper()) && (A3_Obtenida.ToUpper() == CellA3.ToUpper()))
                    {
                        //Ejecutamos el método para enviar un mensaje de espera mientras se lee el archivo.
                        AsyncProgress = await dialog.SendProgressAsync(StringResources.msgEspera, "");

                        // Mandamos llamar el método para leer los datos del archivo excel
                        List <DO_ProgramaAnual> ListaCrear = await LeerExcel(nombreArchivoAdjutado);

                        //Ejecutamos el método para cerrar el mensaje de espera.
                        await AsyncProgress.CloseAsync();

                        // Mandamos llamar el método para crear nuevo archivo a partir de la lista recibida
                        CrearExcel(ListaCrear);
                    }
                    else
                    {
                        await dialog.SendMessage(StringResources.ttlAlerta, StringResources.msgFormatoNoValido);
                    }
                }
                else
                {
                    // Si el archivo está en uso mandamos un mensaje de alerta
                    await dialog.SendMessage(StringResources.ttlAlerta, StringResources.msgCierreArchivo);
                }
            }
        }