Ejemplo n.º 1
0
        public async Task <IActionResult> Edit(int id, [Bind("ExamPrice,Id,Surname,Name,Patronymic,Photo,PhotoPath")] ExaminerViewModel examinerViewModel)
        {
            if (id != examinerViewModel.Id)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                Examiner examiner = new Examiner
                {
                    Id         = examinerViewModel.Id,
                    Surname    = examinerViewModel.Surname,
                    Name       = examinerViewModel.Name,
                    Patronymic = examinerViewModel.Patronymic,
                    ExamPrice  = examinerViewModel.ExamPrice,
                    Photo      = examinerViewModel.PhotoPath
                };

                if (examinerViewModel.Photo != null)
                {
                    var fileName = UploadedFile(examinerViewModel);
                    examiner.Photo = fileName;
                }

                _context.Update(examiner);
                await _context.SaveChangesAsync();

                return(RedirectToAction(nameof(Index)));
            }
            return(View(examinerViewModel));
        }
        public void TestExaminer()
        {
            Examiner examiner = new Examiner()
            {
                Id         = 1,
                Name       = "Илья",
                SurName    = "Шутов",
                Patronymic = "Борисович",
                Examen     = "Математика",
                Examen_2   = "Информатика"
            };

            Examiner examiner2 = new Examiner()
            {
                Id         = 1,
                Name       = "Илья",
                SurName    = "Шутов",
                Patronymic = "Борисович",
                Examen     = "Математика",
                Examen_2   = "Информатика"
            };

            string except            = "1 Шутов Илья Борисович Математика Информатика";
            int    except_properties = 6;

            Assert.IsTrue(examiner.Equals(examiner2));
            Assert.AreEqual(except, examiner.ToString());
            Assert.AreEqual(except_properties, examiner.GetHashCode());
        }
Ejemplo n.º 3
0
        public void TestAddDeleteToDatabaseExaminer()
        {
            Examiner examiner = new Examiner
            {
                Id         = 5,
                Name       = "Илья",
                SurName    = "Шутов",
                Patronymic = "Борисович",
                Examen     = "Математика",
                Examen_2   = "Информатика"
            };

            AddToDataBase add = new AddToDataBase();

            add.AddNewExaminer(examiner);

            DataContext db = new DataContext(connectionString);
            Examiner    ex = db.GetTable <Examiner>().OrderByDescending(u => u.Id).FirstOrDefault();

            var except_EndElement = true;
            var actual_EndElement = examiner.Equals(ex);

            DeleteToDataBase del = new DeleteToDataBase();

            del.DeleteEndExaminer();

            ex = db.GetTable <Examiner>().OrderByDescending(u => u.Id).FirstOrDefault();

            var except_EndElement_2 = false;
            var actual_EndElement_2 = examiner.Equals(ex);

            Assert.AreEqual(except_EndElement, actual_EndElement);
            Assert.AreEqual(except_EndElement_2, actual_EndElement_2);
        }
Ejemplo n.º 4
0
        public void TestingUpdateDatabase()
        {
            string   new_ex = "ОС";
            Examiner ex     = new Examiner()
            {
                Id         = 1,
                Name       = "Константин",
                SurName    = "Курочка",
                Patronymic = "Сергеевич",
                Examen     = "ООП",
                Examen_2   = new_ex
            };

            UpdateDataBase update = new UpdateDataBase();

            update.UpdateFirstExaminer(ex);

            DataContext db  = new DataContext(connectionString);
            Examiner    res = db.GetTable <Examiner>().FirstOrDefault();

            var except = true;
            var actual = ex.Equals(res);

            // возврат начальных значений
            ex.Examen_2 = "КС";
            update.UpdateFirstExaminer(ex);

            Assert.AreEqual(except, actual);
        }
Ejemplo n.º 5
0
 void InitializeGame()
 {
     score    = new Scorer();
     examiner = new Examiner(InitialLevel);
     spawner.Reset();
     StartLevel();
 }
Ejemplo n.º 6
0
        public ActionResult DeleteConfirmed(int id)
        {
            Examiner examiner = db.Examiners.Find(id);

            db.Examiners.Remove(examiner);
            db.SaveChanges();
            return(RedirectToAction("Index"));
        }
Ejemplo n.º 7
0
 public ActionResult Edit([Bind(Include = "ExaminerID,InstituteAdminID,UserName")] Examiner examiner)
 {
     if (ModelState.IsValid)
     {
         db.Entry(examiner).State = EntityState.Modified;
         db.SaveChanges();
         return(RedirectToAction("Index"));
     }
     ViewBag.InstituteAdminID = new SelectList(db.InstituteAdmins, "InstituteAdminID", "InsAdminName", examiner.InstituteAdminID);
     return(View(examiner));
 }
Ejemplo n.º 8
0
        public ActionResult Create([Bind(Include = "ExaminerID,InstituteAdminID,UserName")] Examiner examiner)
        {
            if (ModelState.IsValid)
            {
                db.Examiners.Add(examiner);
                db.SaveChanges();
                return(RedirectToAction("Index"));
            }

            ViewBag.InstituteAdminID = new SelectList(db.InstituteAdmins, "InstituteAdminID", "InsAdminName", examiner.InstituteAdminID);
            return(PartialView(examiner));
        }
Ejemplo n.º 9
0
        private async Task LoadAsync(Examiner user)
        {
            var email = await _userManager.GetEmailAsync(user);

            Email = email;

            Input = new InputModel
            {
                NewEmail = email,
            };

            IsEmailConfirmed = await _userManager.IsEmailConfirmedAsync(user);
        }
Ejemplo n.º 10
0
        private async Task LoadAsync(Examiner user)
        {
            var userName = await _userManager.GetUserNameAsync(user);

            var phoneNumber = await _userManager.GetPhoneNumberAsync(user);

            Username = userName;

            Input = new InputModel
            {
                PhoneNumber = phoneNumber
            };
        }
    public void IdentifyBlocksThatIfRemovedWouldCreateLargerSets()
    {
        List <Set> s = new List <Set>();

        // Create a situation where a single file has two redundant
        // sets, each set having two blocks.  Like so:

        /*  1
         *  2 public void Foo()
         *  3 {
         *  4     ////////////////////////////////
         *  5     ////// Redundant set Top ///////
         *  6     ////////////////////////////////
         *  7     --> Foo extract method candidate <--
         *  8     ////////////////////////////////
         *  9     ////// Redundant set Bottom ////
         * 10     ////////////////////////////////
         * 11 }
         * 12 public void Bar()
         * 13 {
         * 14     ////////////////////////////////
         * 15     ////// Redundant set Top ///////
         * 16     ////////////////////////////////
         * 17     --> Bar extract method candidate <--
         * 18     ////////////////////////////////
         * 19     ////// Redundant set Bottom ////
         * 20     ////////////////////////////////
         * 21 }
         * 22
         *
         * If the two --><-- sections were removed, the two sets would
         * become one big set.
         */
        s.Add(new Set(3));
        s[0].AddBlock("SampleRedundantFile.cs", 4);
        s[0].AddBlock("SampleRedundantFile.cs", 14);

        s.Add(new Set(3));
        s[1].AddBlock("SampleRedundantFile.cs", 8);
        s[1].AddBlock("SampleRedundantFile.cs", 18);

        Examiner e = new Examiner(null);

        List <ISet> candidates = e.Examine(s);

        Assert.AreEqual(1, candidates.Count);
        Assert.AreEqual(7, candidates[0].Blocks[0].StartLineNumber);
        Assert.AreEqual(7, candidates[0].Blocks[0].EndLineNumber);
        Assert.AreEqual(17, candidates[0].Blocks[1].StartLineNumber);
        Assert.AreEqual(17, candidates[0].Blocks[1].EndLineNumber);
    }
Ejemplo n.º 12
0
        // GET: Examiner/Details/5
        public ActionResult Details(int?id)
        {
            if (id == null)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
            }
            Examiner examiner = db.Examiners.Find(id);

            if (examiner == null)
            {
                return(HttpNotFound());
            }
            return(View(examiner));
        }
Ejemplo n.º 13
0
        // GET: Examiner/Edit/5
        public ActionResult Edit(int?id)
        {
            if (id == null)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
            }
            Examiner examiner = db.Examiners.Find(id);

            if (examiner == null)
            {
                return(HttpNotFound());
            }
            ViewBag.InstituteAdminID = new SelectList(db.InstituteAdmins, "InstituteAdminID", "InsAdminName", examiner.InstituteAdminID);
            return(View(examiner));
        }
Ejemplo n.º 14
0
        public async Task <IActionResult> OnPostAsync(string returnUrl = null)
        {
            returnUrl      = returnUrl ?? Url.Content("~/");
            ExternalLogins = (await _signInManager.GetExternalAuthenticationSchemesAsync()).ToList();
            if (ModelState.IsValid)
            {
                var user = new Examiner {
                    UserName = Input.Email, Email = Input.Email
                };
                var result = await _userManager.CreateAsync(user, Input.Password);

                if (result.Succeeded)
                {
                    _logger.LogInformation("User created a new account with password.");

                    var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);

                    code = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(code));
                    var callbackUrl = Url.Page(
                        "/Account/ConfirmEmail",
                        pageHandler: null,
                        values: new { area = "Identity", userId = user.Id, code = code, returnUrl = returnUrl },
                        protocol: Request.Scheme);

                    await _emailSender.SendEmailAsync(Input.Email, "Confirm your email",
                                                      $"Please confirm your account by <a href='{HtmlEncoder.Default.Encode(callbackUrl)}'>clicking here</a>.");

                    if (_userManager.Options.SignIn.RequireConfirmedAccount)
                    {
                        return(RedirectToPage("RegisterConfirmation", new { email = Input.Email, returnUrl = returnUrl }));
                    }
                    else
                    {
                        await _signInManager.SignInAsync(user, isPersistent : false);

                        return(LocalRedirect(returnUrl));
                    }
                }
                foreach (var error in result.Errors)
                {
                    ModelState.AddModelError(string.Empty, error.Description);
                }
            }

            // If we got this far, something failed, redisplay form
            return(Page());
        }
Ejemplo n.º 15
0
        public void AddExaminer(Examiner examiner)
        {
            using (IDbConnection connection = new System.Data.SqlClient.SqlConnection(ConnectionString))
            {
                string sql        = "dbo.AddAddress @City, @State, @Country, @Zipcode";
                int    address_id = connection.Query <int>(sql, examiner.Address).Single();

                sql = "dbo.AddExaminer @Name, @Surname, @Pesel, @BirthDate, @Address_Id";
                var e           = new { Name = examiner.Name, Surname = examiner.Surname, Pesel = examiner.Pesel, BirthDate = examiner.BirthDate, Address_Id = address_id };
                int examiner_id = connection.Query <int>(sql, e).Single();
                foreach (string category in examiner.Permissions)
                {
                    sql = "dbo.AddCategory @Examiner_Id, @Category";
                    var p = new { Examiner_Id = examiner_id, Category = category };
                    connection.Execute(sql, p);
                }
            }
        }
Ejemplo n.º 16
0
        private async Task LoadSharedKeyAndQrCodeUriAsync(Examiner user)
        {
            // Load the authenticator key & QR code URI to display on the form
            var unformattedKey = await _userManager.GetAuthenticatorKeyAsync(user);

            if (string.IsNullOrEmpty(unformattedKey))
            {
                await _userManager.ResetAuthenticatorKeyAsync(user);

                unformattedKey = await _userManager.GetAuthenticatorKeyAsync(user);
            }

            SharedKey = FormatKey(unformattedKey);

            var email = await _userManager.GetEmailAsync(user);

            AuthenticatorUri = GenerateQrCodeUri(email, unformattedKey);
        }
    public void BlocksInDifferentFilesCantBeConsecutive()
    {
        List<Set> s = new List<Set>();

        // Same block defs as above, except the sets are in different files,
        // and therefore will never be consecutive.
        s.Add(new Set(3));
        s[0].AddBlock("SampleRedundantFile.cs", 4);
        s[0].AddBlock("SampleRedundantFile.cs", 14);

        s.Add(new Set(3));
        s[1].AddBlock("DifferentFile.cs", 8);
        s[1].AddBlock("DifferentFile.cs", 18);

        Examiner e = new Examiner(null);

        List<ISet> candidates = e.Examine(s);
        Assert.IsEmpty(candidates);
    }
Ejemplo n.º 18
0
        private void executeAdd(object obj)
        {
            var address = new Address {
                City = City, Country = Country, Zipcode = Zipcode, State = State
            };
            var examiner = new Examiner {
                Name = Name, Surname = Surname, Pesel = Pesel, BirthDate = (DateTime)BirthDate, Address = address
            };

            examiner.Permissions.Add(Category);
            db.AddExaminer(examiner);
            Name      = null;
            Surname   = null;
            Pesel     = null;
            BirthDate = null;
            City      = null;
            State     = null;
            Zipcode   = null;
            Country   = null;
        }
    public void BlocksInDifferentFilesCantBeConsecutive()
    {
        List <Set> s = new List <Set>();

        // Same block defs as above, except the sets are in different files,
        // and therefore will never be consecutive.
        s.Add(new Set(3));
        s[0].AddBlock("SampleRedundantFile.cs", 4);
        s[0].AddBlock("SampleRedundantFile.cs", 14);

        s.Add(new Set(3));
        s[1].AddBlock("DifferentFile.cs", 8);
        s[1].AddBlock("DifferentFile.cs", 18);

        Examiner e = new Examiner(null);

        List <ISet> candidates = e.Examine(s);

        Assert.IsEmpty(candidates);
    }
Ejemplo n.º 20
0
        public async Task <IActionResult> Create([Bind("ExamPrice,Id,Surname,Name,Patronymic,Photo")] ExaminerViewModel examinerViewModel)
        {
            if (ModelState.IsValid)
            {
                string   uniqueFileName = UploadedFile(examinerViewModel);
                Examiner examiner       = new Examiner
                {
                    Surname    = examinerViewModel.Surname,
                    Name       = examinerViewModel.Name,
                    Patronymic = examinerViewModel.Patronymic,
                    Photo      = uniqueFileName,
                    ExamPrice  = examinerViewModel.ExamPrice
                };

                _context.Add(examiner);
                await _context.SaveChangesAsync();

                return(RedirectToAction(nameof(Index)));
            }
            return(View(examinerViewModel));
        }
    public void BlocksInSetNotInFileOrder()
    {
        List<Set> s = new List<Set>();

        // Exact same as the other test, except the blocks are not in file order.
        s.Add(new Set(3));
        s[0].AddBlock("SampleRedundantFile.cs", 14);
        s[0].AddBlock("SampleRedundantFile.cs", 4);

        s.Add(new Set(3));
        s[1].AddBlock("SampleRedundantFile.cs", 18);
        s[1].AddBlock("SampleRedundantFile.cs", 8);

        Examiner e = new Examiner(null);

        List<ISet> candidates = e.Examine(s);
        Assert.AreEqual(17, candidates[0].Blocks[0].StartLineNumber);
        Assert.AreEqual(17, candidates[0].Blocks[0].EndLineNumber);
        Assert.AreEqual(7, candidates[0].Blocks[1].StartLineNumber);
        Assert.AreEqual(7, candidates[0].Blocks[1].EndLineNumber);
    }
    public void BlocksInSetNotInFileOrder()
    {
        List <Set> s = new List <Set>();

        // Exact same as the other test, except the blocks are not in file order.
        s.Add(new Set(3));
        s[0].AddBlock("SampleRedundantFile.cs", 14);
        s[0].AddBlock("SampleRedundantFile.cs", 4);

        s.Add(new Set(3));
        s[1].AddBlock("SampleRedundantFile.cs", 18);
        s[1].AddBlock("SampleRedundantFile.cs", 8);

        Examiner e = new Examiner(null);

        List <ISet> candidates = e.Examine(s);

        Assert.AreEqual(17, candidates[0].Blocks[0].StartLineNumber);
        Assert.AreEqual(17, candidates[0].Blocks[0].EndLineNumber);
        Assert.AreEqual(7, candidates[0].Blocks[1].StartLineNumber);
        Assert.AreEqual(7, candidates[0].Blocks[1].EndLineNumber);
    }
Ejemplo n.º 23
0
        public async Task <List <Exam> > GetFutureExams(Examiner examiner = null, Examinee examinee = null, string category = null, DateTime?date = null)
        {
            using (IDbConnection connection = new System.Data.SqlClient.SqlConnection(ConnectionString))
            {
                string sql         = "dbo.GetFutureExams @Examiner_Id, @Examinee_Id, @Category, @Date";
                int?   examiner_id = examiner == null ? null : (int?)examiner.Id;
                int?   examinee_id = examinee == null ? null : (int?)examinee.Id;
                var    p           = new { Examiner_Id = examiner_id, Examinee_Id = examinee_id, Category = category, Date = date };
                var    exams       = await connection.QueryAsync <Exam, int, int, Exam>(sql,
                                                                                        (exam, ee_id, er_id) =>
                {
                    var x         = GetExamineeById(ee_id);
                    var y         = GetExaminerById(er_id);
                    exam.Examinee = x;
                    exam.Examiner = y;
                    return(exam);
                },
                                                                                        param : p,
                                                                                        splitOn : "Examinee_Id, Examiner_Id");

                return(exams.ToList());
            }
        }
        private void Initialize(GameObject go, bool renderOK = true)
        {
            this.Tile                = string.Empty;
            this.RenderString        = string.Empty;
            this.BackgroundString    = string.Empty;
            this.DetailColorChar     = 'k';
            this.ForegroundColorChar = 'y';
            this.BackgroundColorChar = 'k';
            this.DetailColor         = ConsoleLib.Console.ColorUtility.ColorMap['k'];
            this.ForegroundColor     = ConsoleLib.Console.ColorUtility.ColorMap['y'];
            this.BackgroundColor     = ConsoleLib.Console.ColorUtility.ColorMap['k'];

            //gather render data for GameObject similar to how the game does it in Cell.cs
            Render pRender = go?.pRender;

            if (pRender == null || !pRender.Visible || Globals.RenderMode != RenderModeType.Tiles)
            {
                return;
            }
            RenderEvent renderData   = new RenderEvent();
            Examiner    examinerPart = go.GetPart <Examiner>();

            if (examinerPart != null && !string.IsNullOrEmpty(examinerPart.UnknownTile) && !go.Understood())
            {
                renderData.Tile = examinerPart.UnknownTile;
            }
            else
            {
                renderData.Tile = go.pRender.Tile;
            }
            if (!string.IsNullOrEmpty(pRender.TileColor))
            {
                renderData.ColorString = pRender.TileColor;
            }
            else
            {
                renderData.ColorString = pRender.ColorString;
            }
            if (renderOK) //we can't render blueprint-created objects, because the game will throw errors trying to check their current cell
            {
                go.Render(renderData);
            }

            //renderData.Tile can be null if something has a temporary character replacement, like the up arrow from flying
            this.Tile             = !string.IsNullOrEmpty(renderData.Tile) ? renderData.Tile : pRender.Tile;
            this.RenderString     = !string.IsNullOrEmpty(renderData.RenderString) ? renderData.RenderString : pRender.RenderString;
            this.BackgroundString = renderData.BackgroundString;

            ////DEBUG
            //UnityEngine.Debug.Log("Render data from GameObject.Render() for " + go.DisplayName + ":\n    Tile=" + renderData.Tile
            //    + "\n    ColorString=" + renderData.ColorString
            //    + "\n    DetailColor=" + renderData.DetailColor
            //    + "\n    RenderString=" + renderData.RenderString
            //    + "\n    BackgroundString=" + renderData.BackgroundString
            //    + "\nRender data from object itself:"
            //    + "\n    Tile=" + pRender.Tile
            //    + "\n    RenderString=" + pRender.RenderString
            //    + "\n    TileColor=" + pRender.TileColor
            //    + "\n    ColorString=" + pRender.ColorString
            //    + "\n    DetailColor=" + pRender.DetailColor);
            ////DEBUG

            //save render data in our custom TileColorData format, using logic similar to QudItemListElement.InitFrom()
            if (!string.IsNullOrEmpty(pRender.DetailColor))
            {
                this.DetailColor     = ConsoleLib.Console.ColorUtility.ColorMap[pRender.DetailColor[0]];
                this.DetailColorChar = pRender.DetailColor[0];
            }
            //from what I've been able to determine, I believe that the BackgroundString only applies to non-tiles (RenderString) entities (such as gas clouds)
            string colorString = renderData.ColorString + (string.IsNullOrEmpty(this.Tile) ? this.BackgroundString : string.Empty);

            if (!string.IsNullOrEmpty(colorString))
            {
                for (int j = 0; j < colorString.Length; j++)
                {
                    if (colorString[j] == '&' && j < colorString.Length - 1)
                    {
                        if (colorString[j + 1] == '&')
                        {
                            j++;
                        }
                        else
                        {
                            this.ForegroundColor     = ConsoleLib.Console.ColorUtility.ColorMap[colorString[j + 1]];
                            this.ForegroundColorChar = colorString[j + 1];
                        }
                    }
                    if (colorString[j] == '^' && j < colorString.Length - 1)
                    {
                        if (colorString[j + 1] == '^')
                        {
                            j++;
                        }
                        else
                        {
                            this.BackgroundColor     = ConsoleLib.Console.ColorUtility.ColorMap[colorString[j + 1]];
                            this.BackgroundColorChar = colorString[j + 1];
                        }
                    }
                }
            }
            this.Attributes = ColorUtility.MakeColor(ColorUtility.CharToColorMap[this.ForegroundColorChar], ColorUtility.CharToColorMap[this.BackgroundColorChar]);
        }
    public void IdentifyBlocksThatIfRemovedWouldCreateLargerSets()
    {
        List<Set> s = new List<Set>();

        // Create a situation where a single file has two redundant
        // sets, each set having two blocks.  Like so:
        /*  1
         *  2 public void Foo()
         *  3 {
         *  4     ////////////////////////////////
         *  5     ////// Redundant set Top ///////
         *  6     ////////////////////////////////
         *  7     --> Foo extract method candidate <--
         *  8     ////////////////////////////////
         *  9     ////// Redundant set Bottom ////
         * 10     ////////////////////////////////
         * 11 }
         * 12 public void Bar()
         * 13 {
         * 14     ////////////////////////////////
         * 15     ////// Redundant set Top ///////
         * 16     ////////////////////////////////
         * 17     --> Bar extract method candidate <--
         * 18     ////////////////////////////////
         * 19     ////// Redundant set Bottom ////
         * 20     ////////////////////////////////
         * 21 }
         * 22
         *
         * If the two --><-- sections were removed, the two sets would
         * become one big set.
         */
        s.Add(new Set(3));
        s[0].AddBlock("SampleRedundantFile.cs", 4);
        s[0].AddBlock("SampleRedundantFile.cs", 14);

        s.Add(new Set(3));
        s[1].AddBlock("SampleRedundantFile.cs", 8);
        s[1].AddBlock("SampleRedundantFile.cs", 18);

        Examiner e = new Examiner(null);

        List<ISet> candidates = e.Examine(s);
        Assert.AreEqual(1, candidates.Count);
        Assert.AreEqual(7, candidates[0].Blocks[0].StartLineNumber);
        Assert.AreEqual(7, candidates[0].Blocks[0].EndLineNumber);
        Assert.AreEqual(17, candidates[0].Blocks[1].StartLineNumber);
        Assert.AreEqual(17, candidates[0].Blocks[1].EndLineNumber);
    }
Ejemplo n.º 26
0
 private void Examiner_Focused(object sender, FocusEventArgs e)
 {
     Examiner.Unfocus();
 }