示例#1
0
        public async static Task <List <Patient> > GetPatients(ConcurrentStack <string> patients, Credential[] Accounts, int nThreads, Settings settings)   //запускает многопоточно запросы к сайту для поиска пациентов
        {
            return(await Task.Run(() =>
            {
                Job[] jobs = WebSiteSRZ.PrepareJobs(patients, Accounts, nThreads);
                var result = new ConcurrentBag <Patient>();
                Task[] tasks = new Task[jobs.Count()];

                foreach (Job job in jobs)
                {
                    tasks[job.Nthread] = Task.Run(() =>
                    {
                        WebSiteSRZ site;
                        Patient patient;
                        int j = 0;

                        foreach (Credential cred in job.Accounts)
                        {
                            using (site = new WebSiteSRZ(settings.Site, settings.ProxyAddress, settings.ProxyPort))
                            {
                                for (int i = 0; i < 3; i++) //3 попытки на авторизацию с интервалом 10секунд
                                {
                                    if (site.Authorize(cred).Result)
                                    {
                                        while (cred.Requests > 0)
                                        {
                                            patient = site.GetPatient(job.Patients[j]);
                                            if (patient.polis != null)
                                            {
                                                result.Add(patient);
                                                cred.Requests--;
                                                j++;
                                            }
                                            else
                                            {
                                                break;
                                            }
                                        }
                                        site.Logout();
                                        break;
                                    }
                                    else
                                    {
                                        Thread.Sleep(10000);
                                    }
                                }
                            }
                        }
                    });
                }

                Task.WaitAll(tasks);

                return result.ToList <Patient>();
            }));
        }
示例#2
0
        private async void button6_Click(object sender, EventArgs e)  //начать определение ФИО
        {
            try
            {
                DisableButtons();

                if (settings.TestPassed == false)
                {
                    await TestSetting();
                }

                if (settings.TestPassed)
                {
                    int    maxReq = 0, madeReq = 0, step = 2;
                    string xlsxStatus;

                    if (settings.DownloadFile)
                    {
                        toolStripStatusLabel1.Text = string.Format("{0}. Выполняется загрузка файла из СРЗ, ждите...", step++);
                        using (WebSiteSRZ site = new WebSiteSRZ(settings.Site, settings.ProxyAddress, settings.ProxyPort))
                        {
                            await site.Authorize(settings.Accounts[0]);

                            await site.DownloadFile(settings.Path, dateTimePicker1.Value);

                            site.Logout();
                        }
                    }
                    toolStripStatusLabel1.Text = string.Format("{0}. Выполняется обработка из кэша, ждите...", step++);
                    foreach (Credential cred in settings.Accounts)
                    {
                        maxReq += cred.Requests;
                    }
                    using (CacheDB cacheDB = new CacheDB())
                        using (var excel = new ExcelFile())
                        {
                            await excel.Open(settings.Path, settings.ColumnSynonims);

                            ConcurrentStack <string> listJobs = await excel.GetPatientsFromCache(cacheDB, maxReq, true);

                            if (listJobs.Count > 0)
                            {
                                toolStripStatusLabel1.Text = string.Format("{0}. Выполняется поиск пациентов в СРЗ, ждите...", step++);
                                List <Patient> patients = await WebSiteSRZ.GetPatients(listJobs, settings.CopyAccounts(), settings.Threads, settings);

                                madeReq = patients.Count;
                                toolStripStatusLabel1.Text = string.Format("{0}. Выполняется добавление в кэш, ждите...", step++);
                                await cacheDB.AddPatients(patients, true);

                                toolStripStatusLabel1.Text = string.Format("{0}. Выполняется обработка из кэша, ждите...", step++);
                                listJobs = await excel.GetPatientsFromCache(cacheDB, int.MaxValue);
                            }
                            if (listJobs.Count == 0)
                            {
                                if (settings.RenameGender)
                                {
                                    await excel.RenameSex();
                                }
                                if (settings.RenameColumnNames)
                                {
                                    await excel.ProcessColumns();
                                }
                                if (settings.ColumnOrder)
                                {
                                    await excel.SetColumnsOrder();
                                }
                                if (settings.ColumnAutoWidth)
                                {
                                    await excel.FitColumnWidth();
                                }
                                if (settings.AutoFilter)
                                {
                                    await excel.AutoFilter();
                                }

                                xlsxStatus = "Файл готов, найдены все ФИО.";
                            }
                            else
                            {
                                xlsxStatus = String.Format("Файл не готов, осталось запросить в СРЗ {0} ФИО.", listJobs.Count);
                            }
                            await excel.Save();

                            toolStripStatusLabel1.Text = String.Format("Готово. Запрошено пациентов в СРЗ: {0} из {1} разрешенных. {2}", madeReq, maxReq, xlsxStatus);

                            if (autoStart)
                            {
                                Environment.Exit(0); //выход с кодом 0 если запущено с командной строки
                            }
                        }
                }
            }
            catch (Exception)
            {
                toolStripStatusLabel1.Text = "Произошла непредвиденная ошибка. Операция завершена некорректно.";
                if (autoStart)
                {
                    Environment.Exit(1);    //выход с кодом 1 если запущено с командной строки
                }
                throw;
            }
            finally
            {
                EnableButtons();
            }
        }
示例#3
0
        public async Task <ConcurrentDictionary <string, bool> > Test()  //тестирование настроек
        {
            return(await Task.Run(() =>
            {
                ConcurrentDictionary <string, bool> errors = new ConcurrentDictionary <string, bool>();

                int timeOut = 10000;

                //проверяем доступность прокси
                if (this.ProxyAddress != "")
                {
                    var client = new TcpClient();
                    try
                    {
                        if (client.ConnectAsync(this.ProxyAddress, this.ProxyPort).Wait(timeOut) == false)
                        {
                            throw new TimeoutException();
                        }
                    }
                    catch (Exception)
                    {
                        errors.TryAdd("proxy", true);
                    }
                    finally
                    {
                        client.Close();
                    }
                }
                if (!errors.ContainsKey("proxy"))
                {
                    errors.TryAdd("proxy", false);
                }

                //проверяем доступность сайта

                if (errors["proxy"] == false)
                {
                    try
                    {
                        HttpWebRequest webReq = (HttpWebRequest)HttpWebRequest.Create(this.Site);
                        webReq.Timeout = timeOut;

                        if (this.ProxyAddress != "")
                        {
                            webReq.Proxy = new WebProxy(this.ProxyAddress + ":" + this.ProxyPort);
                        }

                        webReq.GetResponse();
                        webReq.Abort();
                    }
                    catch (Exception)
                    {
                        errors.TryAdd("site", true);
                    }
                }
                if (!errors.ContainsKey("site"))
                {
                    errors.TryAdd("site", false);
                }

                //проверяем наличие папки
                if (!Directory.Exists(System.IO.Path.GetDirectoryName(this.Path)))
                {
                    errors.TryAdd("folder", true);
                }
                else
                {
                    errors.TryAdd("folder", false);
                }


                //проверяем наличие файла, если используется существующий файл
                if ((!this.DownloadFile) && (!System.IO.File.Exists(this.Path)))
                {
                    errors.TryAdd("file", true);
                }
                if (!errors.ContainsKey("file"))
                {
                    errors.TryAdd("file", false);
                }

                //проверяем кол-во потоков
                if ((this.Threads < 1) || (this.Threads > 50))
                {
                    errors.TryAdd("threads", true);
                }
                else
                {
                    errors.TryAdd("threads", false);
                }

                //проверяем логины
                if ((errors["proxy"] == false) && (errors["site"] == false))
                {
                    Parallel.ForEach(this.Accounts, credential =>
                    {
                        using (WebSiteSRZ site = new WebSiteSRZ(this.Site, this.ProxyAddress, this.ProxyPort))
                        {
                            if (site.Authorize(credential).Result)
                            {
                                errors.TryAdd(credential.Login, false);
                                site.Logout();
                            }
                            else
                            {
                                errors.TryAdd(credential.Login, true);
                            }
                        }
                    });
                }

                if (errors.Values.Contains(true))
                {
                    this.TestPassed = false;
                }
                else
                {
                    this.TestPassed = true;
                }

                return errors;
            }));
        }