Пример #1
0
        /// <summary>
        /// Ukazka pouziti volani simulaci. Kazde volani simuluje jednoho klienta.
        /// </summary>
        public void ClientRun(string username)
        {
            try
            {
                UserID user = new UserID(username);    //uzivatel-je predavan serveru

                //zjisteni informaci o algoritmech
                Console.WriteLine("Zjistuji informace o implementovanych algoritmech:");
                var algoritms = proxy_simulation.GetAlgorithmInfo(user);    //seznam informaci o algoritmech, volani pomoci proxy_simulation objektu
                foreach (var item in algoritms)
                {
                    Console.WriteLine("ID:{0}\tJmeno:{1}\tPopis:{2}", item.AlgorithmID, item.AlgorithmName, item.AlgorithmDescription);
                }
                //vytvoreni senatu-informace o senatech musi byt nactene z databaze a zde vytvoreny jejich instance
                //Dochazi k volani konstruktoru na strane klienta, viz DataContractHelpers.cs, kde jsou tyto konstruktory implementovany
                Senate s1 = new Senate("INS-tester-1");                //senat, ktery je povoleny,zatizeni 100, pocet aktivnich pripadu 0
                Senate s2 = new Senate("INS-tester-2", false);         //senat je zakazany-nebude pouzit v simulaci
                Senate s3 = new Senate("INS-tester-3", true, 50);      //senat je povoleny, zatizeni je 50, pocet aktivnich pripadu 0
                Senate s4 = new Senate("INS-tester-4", true, 100, 20); //senat je povoleny, zatizeni 100, pocet aktivnich pripadu 20
                Senate s5 = new Senate("INS-tester-5");
                //po odkomentovani vyjimka-volana na strane klienta
                //Senate s6 = new Senate("INS-tester-6",true,120);//zpusobi vyjimku na strane klienta, nepovolena hodnota zatizeni 120
                SimulationParams par = new SimulationParams(); //vytvoreni tridy pro simulacni parametry, pred odeslanim na server musi byt vse nastaveno
                par.User    = user;                            //nastav si uzivatele
                par.Senates = new List <Senate>()
                {
                    s1, s2, s3, s4, s5
                };                                                                                         //musi se vytvorit seznam senatu pro simulaci
                //vyber algoritmu pro simulaci, na FE uzivatel vybere
                par.AlgorithmsToSimulate = (from a in algoritms select int.Parse(a.AlgorithmID)).ToList(); //zjisti-vem ID vsech implementovanych algoritmu pro pouziti v simulaci
                par.IterationsCount      = 100;                                                            //nastaveni poctu iteraci
                par.CasesToDistribution  = 1000;                                                           //pocet rozdelovanych pripadu v kazde iteraci
                var results = proxy_simulation.DoSimulation(par);                                          //proved simulaci-bezi na serveru

                if (results.Count != par.AlgorithmsToSimulate.Count)                                       //test zda ma spravny pocet vysledku
                {
                    throw new Exception("WRONG RESULTS: Algorithm to simulate inconsistence.");
                }
                else    //kdyz ok
                {
                    foreach (var result in results)
                    {
                        if (result.Data.Count != par.IterationsCount)
                        {
                            throw new Exception("WRONG RESULTS: Iteration counts.");
                        }
                        StatisticInfo(result.Data, username);
                    }
                }
            }
            catch (FaultException <GeneratorServiceFault> fault)//odchytavani vyjimek ze serveru
            {
                ConsoleServerMessage(fault);
            }
            catch (Exception e)//odchytnuti vyjimky z klienta
            {
                ConsoleClientMessage(e);
            }
            finally
            {
                Console.WriteLine("DONE: {0}", username);
            }
        }
        /// <summary>
        /// <c>Run</c> (přesměrováno; GET) - "webová" metoda pro zobrazení výsledků simulace (URL: /Simulation/Run, ale když nemá TempData, tak přesměruje na /Simulation/Index).
        /// </summary>
        /// <remarks><para>ViewModel: SimulationResViewModels.cs, třída SimulationResViewModel.</para><para>Views: Simulation/Run.cshtml.</para><para>Pouze pro přihlášené uživatele.</para><para>Tuto metodu lze spustit jedině po vyplnění formuláře s parametry simulace (nemá-li TempData, tak uživatele přesměruje na daný formulář.</para><para>Generuje také data pro XLS-soubor s výsledky simulace.</para><para>Lze volat jen jednou. Pro opakované volání je nutno znovu vyplnit formulář s parametry simulace! (Zajištěno přesměrováním.)</para></remarks>
        //
        // Redirect: Simulation/Run
        // https://stackoverflow.com/questions/129335/how-do-you-redirect-to-a-page-using-the-post-verb
        // https://stackoverflow.com/questions/26751087/detect-if-page-was-redirected-from-redirecttoaction-method
        public ActionResult Run()
        {
            if (TempData.Count == 0)               // nemáme data z Index()
            {
                return(RedirectToAction("Index")); // přesměrování
            }
            // jsou data => připravíme HTML pro výpis senátů, a pak spustíme simulaci a zpracujeme výsledky:

            SimulationParams par = new SimulationParams(); // objekt pro back-end (simulační parametry, musí být serveru správně předány)

            List <AlgorithmInfo> algInfo = TempData["AlgInfo"] as List <AlgorithmInfo>;
            List <Senate>        senates = TempData["Senates"] as List <Senate>;
            int    nCases = (int)TempData["NumCases"];
            int    nIters = (int)TempData["NumIters"];
            string resInitBE;

            GetSenates(); // nastaví "mySenates" a "htmlSenates", prioritně ze session
            ViewBag.senates = HtmlSenates(false, senates);

            Initialize();
            resInitBE = InitializeBackEnd(); // připojení k serveru s back-endem, získání seznamu algoritmů
            if (resInitBE != null)
            {
                TempData.Add("error", resInitBE); // chybové hlášení pro přesměrování
                return(RedirectToAction("Error", "Simulation"));
            }

            par.User    = tester;                                                                    // nastav si uzivatele
            par.Senates = senates;                                                                   // seznam senatu pro simulaci
            par.AlgorithmsToSimulate = (from a in algInfo select int.Parse(a.AlgorithmID)).ToList(); // IDecka algoritmu
            par.IterationsCount      = nIters;                                                       // nastaveni poctu iteraci
            par.CasesToDistribution  = nCases;                                                       // pocet rozdelovanych pripadu v kazde iteraci
            SimulationResViewModel SRVM = new SimulationResViewModel();                              //

            try
            {
                var results = proxy_simulation.DoSimulation(par);         // proveď simulaci (běží na serveru)
                var report  = new SimulationReport(algo, par, results);
                SRVM.Senates.AddRange(from p in par.Senates select p.ID); // jména senátů

                foreach (var a_result in results)                         // prochazej vysledky po algoritmech
                {
                    SRVM.AlgId.Add(a_result.UsedAlgorithm);               // pridej identifikator pouziteho algoritmu, coz je int
                    SRVM.AlgName.Add(ConvertAlgorithmName(algo[a_result.UsedAlgorithm].AlgorithmName));
                    SRVM.Data.Add(a_result.Data);                         // pridej data ze simulace konkretniho algoritmu, tedy predavam List<List<int>> - vyznam indexu prvni pres iterace, druhy  pres senaty
                    SRVM.MinMaxDiff.Add(a_result.MaxDifference);          // vypocet "max. okamžité odchylky" v rámci každé iterace; tohle dělá back-end (od 28. 3. 2018)

                    // vypocet a pridani statistickych informaci:

                    /* Do MAX je pridavan seznam maximalnich hodnot pres iterace, tj. pro kazdy senat je zde jedna polozka v seznamu.
                     * Ostatni statisticke veliciny analogicky...
                     */
                    SRVM.Max.Add(GetMax(a_result.Data));              // spocti maximum a pridej to do seznamu
                    SRVM.Min.Add(GetMin(a_result.Data));              // spocti minimum a pridej to do seznamu
                    List <double> avglist;
                    SRVM.Avg.Add(avglist = GetAvg(a_result.Data));    // spocti prumery a pridej do seznamu
                    SRVM.Stdev.Add(GetStdev(a_result.Data, avglist)); // spocti odchylky a pridej do seznamu. Pro odchylky potrebuji prumery, proto ten pomocny seznam
                }
                //            SRVM.TestovaciVypis();

                // report.CreateReportToFile("report.xlsx"); // zapise do souboru na serveru (pro Plastiaka)
                var memory = report.CreateReportOnTheFly(); // vytvor v pameti. Poslání response: http://howtodomssqlcsharpexcelaccess.blogspot.cz/2014/05/aspnet-how-to-create-excel-file-in.html

                if (!TempData.ContainsKey("BytesData"))
                {
                    TempData.Add("BytesData", memory.ToArray()); // prevod na pole Bytu
                }
                ViewBag.isEquiv = Session["equiv"];
                return(View(SRVM));
            }
            catch (Exception e)
            {
                TempData.Add("error", e.Message);
                return(RedirectToAction("Error", "Simulation"));
            }
            finally
            {
                proxy_simulation.Close(); // odpojení od back-endu
            }
        }
Пример #3
0
        /// <summary>
        /// Ukazka pouziti volani simulaci
        /// </summary>
        public static void ExampleUsage()
        {
            string username = "******";             //ID uzivatele, melo by byt ziskano na frontendu (FE) prihlasenim
            UserID user     = new UserID(username); //uzivatel-je predavan serveru

            try
            {
                //zjisteni informaci o algoritmech
                Console.WriteLine("Zjistuji informace o implementovanych algoritmech:");
                var algoritms = proxy_simulation.GetAlgorithmInfo(user);//seznam informaci o algoritmech, volani pomoci proxy_simulation objektu
                foreach (var item in algoritms)
                {
                    Console.WriteLine("ID:{0}\tJmeno:{1}\tPopis:{2}", item.AlgorithmID, item.AlgorithmName, item.AlgorithmDescription);
                }
                //vytvoreni senatu-informace o senatech musi byt nactene z databaze a zde vytvoreny jejich instance
                //Dochazi k volani konstruktoru na strane klienta, viz DataContractHelpers.cs, kde jsou tyto konstruktory implementovany
                Senate s1 = new Senate("INS-tester-1");               //senat, ktery je povoleny,zatizeni 100, pocet aktivnich pripadu 0
                Senate s2 = new Senate("INS-tester-2", false);        //senat je zakazany-nebude pouzit v simulaci
                Senate s3 = new Senate("INS-tester-3", true, 100);    //senat je povoleny, zatizeni je 100, pocet aktivnich pripadu 0
                Senate s4 = new Senate("INS-tester-4", true, 100, 0); //senat je povoleny, zatizeni 100, pocet aktivnich pripadu 0
                Senate s5 = new Senate("INS-tester-5");
                //po odkomentovani vyjimka-volana na strane klienta
                //Senate s6 = new Senate("INS-tester-6",true,120);//zpusobi vyjimku na strane klienta, nepovolena hodnota zatizeni 120
                SimulationParams par = new SimulationParams(); //vytvoreni tridy pro simulacni parametry, pred odeslanim na server musi byt vse nastaveno
                par.User    = user;                            //nastav si uzivatele
                par.Senates = new List <Senate>()
                {
                    s1, s2, s3, s4, s5
                };                                                                                         //musi se vytvorit seznam senatu pro simulaci
                //vyber algoritmu pro simulaci, na FE uzivatel vybere
                par.AlgorithmsToSimulate = (from a in algoritms select int.Parse(a.AlgorithmID)).ToList(); //zjisti-vem ID vsech implementovanych algoritmu pro pouziti v simulaci
                par.IterationsCount      = 10;                                                             //nastaveni poctu iteraci
                par.CasesToDistribution  = 100;                                                            //pocet rozdelovanych pripadu v kazde iteraci
                var results = proxy_simulation.DoSimulation(par);                                          //proved simulaci-bezi na serveru

                //vlozeno 24.1. test exportu do xls
                var report = new SimulationReport(algoritms, par, results);
                report.CreateReportToFile("report.xlsx");//zapise do souboru-pro spousteni v konzoli-pouzije si PLASTIAK
                //Pro DANA MAJEROVA -vytvorenisouboru v pameti pro posilani-ODKOMENTOVAT nasledujici radek a zakomentovat ReportToFile
                //  var memory = report.CreateReportOnTheFly();//vytvor v pameti--je to mozne prevest na pole bytu a poslat response -viz http://howtodomssqlcsharpexcelaccess.blogspot.cz/2014/05/aspnet-how-to-create-excel-file-in.html


                //test Kubera-jestli to funguje-Vezmu vytvoreny memory stream a ulozim ho do souboru- funguje
                using (var memory = report.CreateReportOnTheFly())
                { //nutno pridat nahoru using System.IO; pro praci se soubory
                    using (FileStream fs = new FileStream("reportfly.xlsx", FileMode.OpenOrCreate))
                    {
                        memory.Position = 0; //nastav to na zacatek
                        memory.CopyTo(fs);   //kopiruj pamet do file streamu
                        fs.Flush();          //zapis
                    }
                }



                //konec testu exportu
                foreach (var data in results)//pro kazdy algoritmus pouzity v simulaci, data jsou kompletni data pro jeden algoritmus
                {
                    Console.WriteLine("+".Repeat(70));
                    var name = (from a in algoritms where a.AlgorithmID == data.UsedAlgorithm.ToString() select a.AlgorithmName).First();
                    Console.WriteLine("Pouzity algoritmus {0}:{1}", data.UsedAlgorithm, name);
                    Console.WriteLine("+".Repeat(70));
                    int iterace = 0;
                    foreach (var array in data.Data) //zpracuj data-vypis za jednotlive iterace,array je distribuce pripadu mezi senaty
                    {
                        foreach (var item in array)  //vypis hodnot pres senaty
                        {
                            Console.Write("{0}\t", item);
                        }
                        Console.WriteLine("MAXDIF:{0}", data.MaxDifference[iterace]);
                        iterace++;
                        Console.WriteLine();
                    }
                    Console.WriteLine("-".Repeat(70));
                    Console.WriteLine("\nStatisticke informace");
                    Console.WriteLine("-".Repeat(70));
                    StatisticInfo(data.Data);
                    Console.WriteLine("-".Repeat(70));
                }
            }
            catch (FaultException <GeneratorServiceFault> fault)//odchytavani vyjimek ze serveru
            {
                ConsoleServerMessage(fault);
            }
            catch (Exception e)//odchytnuti vyjimky z klienta
            {
                ConsoleClientMessage(e);
            }
            finally
            {
                Console.WriteLine("Hotovo");
            }
        }