public ActionResult SellAccount(int accountId)
        {
            var account = _accountService.ReadOneById(accountId);
            var user    = _userService.ReadByGeneralUserId(User.Identity.GetUserId());

            if ((account.Price - ((account.Price * account.EventPrice) / 100)) > UserExternalService.GetUserBalance(User.Identity.GetUserId()))
            {
                return(RedirectToAction("ChargingView", "User",
                                        new { Message = "Tài khoản quý khách không đủ tiền, xin vui lòng nạp thêm. Cám ơn !" }));
            }
            try
            {
                _accountService.SoldAccount(accountId);

                //delete image
                FileUlti.DeleteFile(Server.MapPath("~") + account.Avatar.Substring(2));

                foreach (var page in account.NumberOfPageGems)
                {
                    FileUlti.DeleteFile(Server.MapPath("~") + page.ImageUrl.Substring(2));
                }

                var sumOfBalance = user.Balance - (account.Price - ((account.Price * account.EventPrice) / 100));
                _userService.UpdateBalanceUser(user.GeneralUserId, sumOfBalance);
            }
            catch (Exception)
            {
            }

            try
            {
                if (user != null)
                {
                    _historyService.Create(new UserTradingHistoryDto()
                    {
                        AccountId   = account.Id,
                        UserId      = user.Id,
                        CreatedDate = DateTime.Now
                    });
                }
            }
            catch (Exception)
            {
                throw;
            }



            AccountSoldViewModel vm = new AccountSoldViewModel()
            {
                AccountName = account.UserName,
                Password    = account.Password,
                Description = account.Description
            };

            return(View(vm));
        }
        public ActionResult DeleteWheelItem(int id = 0)
        {
            var result = _userService.DeleteLuckyItem(id);

            if (!string.IsNullOrEmpty(result))
            {
                FileUlti.DeleteFile(Server.MapPath("~") + result.Substring(2));
            }

            return(RedirectToAction("WheelManagement"));
        }
Beispiel #3
0
        public int DeletePageGemById(int pageGemId)
        {
            var imagesDeleted = _pageGemRepositories.ReadOne(a => a.Id == pageGemId);

            _pageGemRepositories.Delete(a => a.Id == pageGemId);
            int result = _pageGemRepositories.SaveChanges();

            if (result > 0)
            {
                FileUlti.DeleteFile(imagesDeleted.ImageUrl);
            }

            return(result);
        }
        public ActionResult CreateRank(CreateRankViewModel data)
        {
            var path    = Server.MapPath("~/Images");
            var rankdto = new RankDto()
            {
                CreatedDate = DateTime.Now,
                RankName    = data.RankName,
                RankImage   = "../Images/" + FileUlti.SaveFile(data.RankImage, path)
            };

            _rankService.Create(rankdto);

            return(RedirectToAction("RankManagement"));
        }
        public LuckyWheelItemDto CreateLuckyItem(LuckyWheelItemDto data)
        {
            var entity = Mapper.Map <LuckyWheelItem>(data);

            entity.CreatedDate = DateTime.Now;
            entity.ImageUrl    = "../Images/LuckyItem/" + FileUlti.SaveFile(data.FileImage, data.ImageUrl);

            var result = _luckyWheelItemRepositories.Create(entity);

            if (_luckyWheelItemRepositories.SaveChanges() > 0)
            {
                return(Mapper.Map <LuckyWheelItemDto>(result));
            }

            return(null);
        }
Beispiel #6
0
        public int DeletePageGemByAccountId(int accountId)
        {
            var imagesDeleted = _pageGemRepositories.Read(a => a.AccountId == accountId).Select(a => a.ImageUrl);

            _pageGemRepositories.Delete(a => a.AccountId == accountId);
            int result = _pageGemRepositories.SaveChanges();

            if (result > 0)
            {
                foreach (var img in imagesDeleted)
                {
                    FileUlti.DeleteFile(img);
                }
            }

            return(result);
        }
        public ActionResult ClearImage()
        {
            var data = _accountService.Read(false);

            foreach (var item in data)
            {
                if (!item.IsAvailable)
                {
                    FileUlti.DeleteFile(Server.MapPath("~") + item.Avatar.Substring(2));

                    foreach (var page in item.NumberOfPageGems)
                    {
                        FileUlti.DeleteFile(Server.MapPath("~") + page.ImageUrl.Substring(2));
                    }
                }
            }

            return(RedirectToAction("Index"));
        }
        public int Delete(int entityId)
        {
            var avatar = _repoAccount.ReadOne(a => a.Id == entityId).Avatar;
            var data   = _repoAccount.ReadOne(a => a.Id == entityId).NumberOfPageGems.Select(a => a.ImageUrl).ToList();

            _repoAccount.Delete(a => a.Id == entityId);
            var result = _repoAccount.SaveChanges();

            if (result > 0)
            {
                FileUlti.DeleteFile(avatar);

                foreach (var page in data)
                {
                    FileUlti.DeleteFile(page);
                }
            }
            return(result);
        }
        public ActionResult CreateOrUpdateAccount(CreateOrUpdateAccountViewModel data)
        {
            var        path = Server.MapPath(ConfigurationManager.AppSettings["AvatarUrl"]);
            AccountDto createOrpdateResult;

            if (data.AccounId == 0)
            {
                var result = new AccountDto()
                {
                    UserName    = data.UserName,
                    Password    = data.Password,
                    CreatedDate = DateTime.Now,
                    Description = data.Description,
                    Price       = data.Price,
                    RankId      = data.RankId,
                    Avatar      = ConfigurationManager.AppSettings["AvatarUrl"] + FileUlti.SaveFile(data.Avatar, path),
                    IsAvailable = true,
                    IsHot       = true,
                    EventPrice  = data.EventPrice
                };
                createOrpdateResult = _accountService.Create(result, FileUlti.ReadFromTextFile(data.Champs), FileUlti.ReadFromTextFile(data.Skins));
            }
            else
            {
                var accountDto = _accountService.ReadOneById(data.AccounId);
                var url        = FileUlti.SaveFile(data.Avatar, path);
                accountDto.Price       = data.Price;
                accountDto.Description = data.Description;
                accountDto.Password    = data.Password;
                accountDto.UserName    = data.UserName;
                accountDto.RankId      = data.RankId;
                accountDto.EventPrice  = data.EventPrice;
                accountDto.Avatar      = (!string.IsNullOrEmpty(url) ? accountDto.Avatar : ConfigurationManager.AppSettings["AvatarUrl"] + url);

                if (data.PageGem != null && data.PageGem.All(a => a != null))
                {
                    _accountRelationDataService.DeletePageGemByAccountId(data.AccounId);
                }
                createOrpdateResult = _accountService.Update(accountDto, FileUlti.ReadFromTextFile(data.Champs), FileUlti.ReadFromTextFile(data.Skins));

                if (data.PageGem == null || data.PageGem.Length == 1)
                {
                    return(RedirectToAction("AccountManagement"));
                }
            }

            if (createOrpdateResult != null)
            {
                var pathPageGem = Server.MapPath(ConfigurationManager.AppSettings["PageGemUrl"]);
                if (data.PageGem != null)
                {
                    foreach (var item in data.PageGem)
                    {
                        var pageGem = new PageGemDto()
                        {
                            AccountId   = createOrpdateResult.Id,
                            CreatedDate = DateTime.Now,
                            ImageUrl    = ConfigurationManager.AppSettings["PageGemUrl"] + FileUlti.SaveFile(item, pathPageGem)
                        };

                        _accountRelationDataService.CreatePageGem(pageGem);
                    }
                }
            }
            return(RedirectToAction("AccountManagement"));
        }