Beispiel #1
0
        public async Task <ActionResult> Index(FormCollection fc)
        {
            ViewBag.AdminLoginStatus = 0;
            string email = fc["email"];
            string pass  = fc["pass"];

            if (!string.IsNullOrWhiteSpace(email) && !string.IsNullOrWhiteSpace(pass))
            {
                User user = await ApiCenter <User> .AdminLogin(email, pass) as User;

                if (user != null)
                {
                    Session["AdminLoginUser"] = user;
                    return(Redirect("/Admin"));
                }
                else
                {
                    ViewBag.AdminLoginStatus = 2;
                }
            }
            else
            {
                ViewBag.AdminLoginStatus = 1;
            }
            return(View());
        }
        public async Task <IActionResult> PlayMatch()
        {
            EntityHttpResponse entityResponse = await ApiCenter.GetAsync($"Season/CreateSeason");


            return(View());
        }
        // GET: Admin/Users
        public async Task <ActionResult> Index()
        {
            List <User> users = await ApiCenter <List <User> > .GetAsync("Users") as List <User>;

            ViewBag.usersimages = Functions.GetFiles(Server.MapPath("~/Uploads/Photos/users"));
            return(View(users));
        }
        public async Task <ActionResult> Edit(User user, HttpPostedFileBase uploadFile)
        {
            if (ModelState.IsValid)
            {
                if (uploadFile != null)
                {
                    var    originalFilename = Path.GetFileName(uploadFile.FileName);
                    var    Extension        = Path.GetExtension(uploadFile.FileName);
                    string fileId           = Guid.NewGuid().ToString().Replace("-", "");

                    System.IO.Directory.CreateDirectory(Server.MapPath("~/Uploads/Photos/users/system"));
                    var path = Path.Combine(Server.MapPath("~/Uploads/Photos/users/system"), fileId) + Extension;
                    uploadFile.SaveAs(path);

                    user.ImageId          = fileId;
                    user.OriginalFilename = originalFilename;
                }
                else
                {
                    user.ImageId          = (TempData["editusertemp"] as User).ImageId;
                    user.OriginalFilename = (TempData["editusertemp"] as User).OriginalFilename;
                    TempData.Keep();
                }
                user.UpdateDate   = DateTime.Now;
                user.UpdateUserid = loginUser.id;
                await ApiCenter <User> .UpdateAsync(user, "Users");

                return(RedirectToAction("Index"));
            }
            return(View(user));
        }
        public async Task <ActionResult> DeleteConfirmed(int id)
        {
            User user = await ApiCenter <User> .GetAsync("Users/" + id) as User;

            await ApiCenter <User> .DeleteAsync(id.ToString(), "Users");

            return(RedirectToAction("Index"));
        }
        // GET: Admin/Users/Details/5
        public async Task <ActionResult> Details(int?id)
        {
            if (id == null)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
            }
            User user = await ApiCenter <User> .GetAsync("Users/" + id) as User;

            if (user == null)
            {
                return(HttpNotFound());
            }
            return(View(user));
        }
Beispiel #7
0
        public async Task <IActionResult> Login(LoginViewModel loginViewModel)
        {
            loginViewModel.Password = PasswordCryptographyCombine(loginViewModel.Password);
            EntityHttpResponse entityHttpResponse = await ApiCenter.GetAsync($"User/Login/{loginViewModel.Email}/{loginViewModel.Password}");

            if (entityHttpResponse.IsTrue)
            {
                User user = ApiCenter.getData <User>(entityHttpResponse);
                LoginUserSave(user);
                return(RedirectToAction("UserDetail", "Home"));
            }
            else
            {
                TempData.Add("LoginErrorMasage", entityHttpResponse._Data);
                return(View());
            }
        }
        private async void Create_Season_Click(object sender, RoutedEventArgs e)
        {
            Season season = new Season()
            {
                Date = dp.SelectedDate.Value
            };
            EntityHttpResponse SeasonCreate = await ApiCenter.CreateAsync <Season>(season, "Season/Create");

            if (SeasonCreate.IsTrue)
            {
                MessageBox.Show("Season Basari ile kayit edilmistir");
                NavigationService.Navigate(new LeagueCreate());
            }
            else
            {
                MessageBox.Show("Ekleme Basarisiz");
            }
        }
        private async void LeagueCreate_Loaded(object sender, RoutedEventArgs e)
        {
            EntityHttpResponse Http_seasons = await ApiCenter.GetAsync("Season");

            EntityHttpResponse Http_team = await ApiCenter.GetAsync("Team");

            ICollection <Team>   Teams;
            ICollection <Season> Seasons;

            if (Http_seasons.IsTrue && Http_team.IsTrue)
            {
                Seasons = ApiCenter.getData <ICollection <Season> >(Http_seasons);
                Teams   = ApiCenter.getData <ICollection <Team> >(Http_team);
                LB_Teams.ItemsSource  = Teams;
                CB_Season.ItemsSource = Seasons;
            }
            else
            {
                MessageBox.Show("Sayfa yuklenirken sorun olustu lutfen daha sonra tekrar deneyiniz.");
            }
        }
        // GET: Admin/Users/Edit/5
        public async Task <ActionResult> Edit(int?id)
        {
            if (id == null)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
            }
            User user = await ApiCenter <User> .GetAsync("Users/" + id) as User;

            if (user == null)
            {
                return(HttpNotFound());
            }
            else
            {
                if (!string.IsNullOrWhiteSpace(user.OriginalFilename))
                {
                    ViewBag.img = Helpers.CsharpHelpers.Functions.GetFile(Server.MapPath("~/Uploads/Photos/users"), user.ImageId);
                }
            }
            TempData["editusertemp"] = user;
            return(View(user));
        }
        public async Task <ActionResult> Create(User user, HttpPostedFileBase uploadFile)
        {
            if (ModelState.IsValid)
            {
                var    originalFilename = Path.GetFileName(uploadFile.FileName);
                var    Extension        = Path.GetExtension(uploadFile.FileName);
                string fileId           = Guid.NewGuid().ToString().Replace("-", "");

                System.IO.Directory.CreateDirectory(Server.MapPath("~/Uploads/Photos/users/system"));
                var path = Path.Combine(Server.MapPath("~/Uploads/Photos/users/system"), fileId) + Extension;
                uploadFile.SaveAs(path);

                user.ImageId          = fileId;
                user.OriginalFilename = originalFilename;

                await ApiCenter <User> .CreateAsync(user, "Users");

                return(RedirectToAction("Index"));
            }

            return(View(user));
        }
        public async Task <IActionResult> UserDetail()
        {
            ViewBag.IsLogin = IsLogin;
            if (IsLogin)
            {
                User user = LoginUser();

                EntityHttpResponse entityHttpResponseTeam = await ApiCenter.GetAsync($"Team/{user.Teamid}");

                if (entityHttpResponseTeam.IsTrue)
                {
                    Team team = ApiCenter.getData <Team>(entityHttpResponseTeam);
                    EntityHttpResponse entityHttpResponseStadium = await ApiCenter.GetAsync($"Stadium/{team.Stadiumid}");

                    if (entityHttpResponseStadium.IsTrue)
                    {
                        Stadium stadium = ApiCenter.getData <Stadium>(entityHttpResponseStadium);
                        ViewBag.LoadError = false;
                        TempData.Clear();
                        EntityHttpResponse entityHttpResponseTeams = await ApiCenter.GetAsync("Team");

                        if (entityHttpResponseTeams.IsTrue)
                        {
                            List <Team> teams;
                            teams = ApiCenter.getData <List <Team> >(entityHttpResponseTeams);
                            return(View(new AccountListViewModel(user, team, stadium, teams)));
                        }
                    }
                }
                ViewBag.LoadError = true;
                TempData.Add("UserDetailErrorMesage", "Kullaniciya ait bilgiler tamamen yuklenemedi");
                return(View(null));
            }

            else
            {
                return(RedirectToAction("Login", "Account"));
            }
        }
Beispiel #13
0
        public async Task <IActionResult> Register(RegisterViewModel registerViewModel)
        {
            if (registerViewModel.Password.Equals(registerViewModel.PasswordConfirmation))
            {
                registerViewModel.Password = PasswordCryptographyCombine(registerViewModel.Password);
                EntityHttpResponse entityHttpResponse = await ApiCenter.GetAsync($"User/Register/{registerViewModel.Email}/{registerViewModel.Password}/{registerViewModel.UserName}");

                if (entityHttpResponse.IsTrue)
                {
                    return(RedirectToAction("Login", 1));
                }
                else
                {
                    TempData.Add("RegisterErrorMasage", entityHttpResponse._Data);
                    return(View());
                }
            }
            else
            {
                TempData.Add("RegisterErrorMasage", "adgangskoder stemmer ikke overens");
                return(View());
            }
        }
        private async void submit_Click(object sender, RoutedEventArgs e)
        {
            if (!string.IsNullOrWhiteSpace(leagueName.Text) && CB_Season.SelectedIndex > -1 && LB_Teams.SelectedItems.Count > 1)
            {
                League league = new League()
                {
                    Name     = leagueName.Text,
                    Seasonid = (CB_Season.SelectedItem as Season).id,
                    Season   = (CB_Season.SelectedItem as Season)
                };
                EntityHttpResponse Httpleague = await ApiCenter.CreateAsync <League>(league, "League/Create");

                if (Httpleague.IsTrue)
                {
                    var            teams   = LB_Teams.SelectedItems.Cast <Team>().ToList();
                    List <Matches> Matches = new List <Matches>();
                    foreach (Team item in teams)
                    {
                        var lt = new LeagueTeam()
                        {
                            Team     = item,
                            Teamid   = item.id,
                            League   = league,
                            Leagueid = league.id,
                        };
                        EntityHttpResponse entityHttpResponse = await ApiCenter.CreateAsync <LeagueTeam>(lt, "LeagueTeam/Create");
                    }
                    int MatchCount = 0;
                    for (int i = 0; i < teams.Count; i++)
                    {
                        Team firstTeam = teams[i];
                        for (int j = i + 1; j < teams.Count; j++)
                        {
                            Team SecondTeam = teams[j];
                            Matches.Add(new Matches()
                            {
                                FirstTeam  = firstTeam,
                                SecondTeam = SecondTeam
                            });
                            MatchCount++;
                        }
                    }

                    foreach (var item in Matches)
                    {
                        int matchday = 365 / MatchCount;
                        if (matchday == 365)
                        {
                            matchday = 0;
                        }
                        item.Date = league.Season.Date.AddDays(matchday);
                        EntityHttpResponse entityHttpResponse = await ApiCenter.CreateAsync <Matches>(item, "Matches/Create");
                    }

                    MessageBox.Show("League Olusturuldu");
                    NavigationService.Navigate(null);
                }
                else
                {
                    MessageBox.Show("Sistemsel bir sikintidan dolayi ekleme gerceklesmedi lutfen tekrar deneyiniz.");
                }
            }
            else
            {
                MessageBox.Show("Lutfen, Gerekli Tum Alanlari Doldurunuz\nTakim Adini Giriniiz\nSezon Seciniz\nEn Az Iki Takim Seciniz");
            }
        }