// GET: Admin/Accounts
public ActionResult Index(LoginViewModel model)
{
try
{
ViewBag.Username = Session["Username"];
IUserService userService = this.Service <IUserService>();
if (Session["Username"] == null)
{
return(this.Redirect("/"));
}
User user = userService.GetByUsername(Session["Username"].ToString());
ILicienseService licienseService = this.Service <ILicienseService>();
Liciense liciense = licienseService.getIsUseLiciense(user.Id);
ViewBag.licienseType = "Tài khoản quản lý";
ViewBag.UserFullName = user.Fullname;
IDeviceService deviceService = this.Service <IDeviceService>();
IQueryable <User> userTotal = userService.GetAllUser();
ViewBag.TotalAccount = userTotal.Count();
ViewBag.TotalDevice = deviceService.GetActive().Count();
DateTime bt = (DateTime)user.Birthday;
//ViewBag.BirthDay = String.Format("{0:dd/MM/yyyy}", bt);
}
catch (Exception e)
{
throw new Exception(e.Message);
}
return(View(model));
}
public HttpResponseMessage Get(string username, string password)
{
try
{
IUserService userService = this.Service <IUserService>();
ILicienseService licenseService = this.Service <ILicienseService>();
User user = userService.GetByUsernameAndPassword(username, password);
if (user != null)
{
int checkDate = DateTime.Now.CompareTo(user.ExpireDate);
Liciense licenseModel = licenseService.getIsUseLiciense(user.Id);
if (checkDate <= 0 && licenseModel != null)
{
UserViewModel model = new UserViewModel()
{
Id = user.Id,
Username = user.Username,
Password = user.Password,
Birthday = user.Birthday,
Fullname = user.Fullname,
RoleId = user.RoleId,
Active = user.Active,
ExpireDate = user.ExpireDate,
PackageId = licenseModel.PackageId,
};
return(new HttpResponseMessage()
{
StatusCode = System.Net.HttpStatusCode.OK,
Content = new JsonContent(model)
});
}
else
{
return(new HttpResponseMessage()
{
StatusCode = System.Net.HttpStatusCode.ExpectationFailed,
Content = new JsonContent("Expired ")
});
}
}
return(new HttpResponseMessage()
{
StatusCode = System.Net.HttpStatusCode.Unauthorized,
Content = new JsonContent("Unauthorized"),
});
}
catch (Exception e)
{
return(new HttpResponseMessage()
{
StatusCode = System.Net.HttpStatusCode.BadRequest,
Content = new JsonContent(e.Message)
});
}
}
public async Task <ActionResult> Login(LoginViewModel model, string returnUrl)
{
ViewBag.LoginFail = "Invalid Username or Password";
if (!this.ModelState.IsValid)
{
return(View(model));
}
// This doesn't count login failures towards account lockout
// To enable password failures to trigger account lockout, change to shouldLockout: true
//var user = await UserManager.FindAsync(model.Username, model.Password);
IUserService userService = this.Service <IUserService>();
User user = userService.GetByUsernameAndPassword(model.Username, model.Password);
if (user == null)
{
ModelState.AddModelError(string.Empty, "Invalid Username or Password.");
return(View());
}
if (user != null)
{
if (user.RoleId == 1)
{
returnUrl = Url.Action("AdminDetail", "Admin");
}
if (user.RoleId == 2)
{
returnUrl = Url.Action("Accounts", "User");
}
//if (result == SignInStatus.Success)
//{
// //string temp = returnUrl;
// if (UserManager.GetRoles(user.Id).FirstOrDefault(r => r.Equals("Admin")) != null)
// {
// //returnUrl = temp;
// returnUrl = Url.Action("accounts", "admin");
// }
if (string.IsNullOrEmpty(returnUrl))
{
returnUrl = this.Url.Action("Login", "Account");
}
// return this.Redirect(returnUrl);
//}
Session["Userfullname"] = user.Fullname;
Session["Username"] = user.Username;
Session["IsRole"] = user.RoleId;
Session["LicienseType"] = null;
ILicienseService licienseService = this.Service <ILicienseService>();
try
{
Liciense liciense = licienseService.GetActive(q => q.User.Username == user.Username && q.IsUse).FirstOrDefault();
if (liciense != null)
{
Session["LicienseType"] = liciense.PackageId.ToString();
}
}
catch (Exception e)
{
throw new Exception(e.Message);
}
return(this.Redirect(returnUrl));
}
return(this.View(model));
}
public Boolean AddNewLiciense(int userId, Liciense liciense)
{
if (liciense.PackageId == TYPE_Normal)
{
try
{
if (getLicienseByUserIdAndType(userId, TYPE_Normal) != null)
{
var licienseCheck = getLicienseByUserIdAndType(userId, TYPE_VIP);
if (licienseCheck != null)
{
var availableDay = (liciense.ExpireDate - DateTime.Now).Days;
liciense.IsUse = false;
liciense.ExpireDate = licienseCheck.ExpireDate.AddDays(availableDay);
this.Update(liciense);
this.Update(licienseCheck);
return(true);
}
this.Update(liciense);
return(true);
}
else
{
var licienseCheck = getLicienseByUserIdAndType(userId, TYPE_VIP);
if (licienseCheck != null)
{
var availableDay = (liciense.ExpireDate - DateTime.Now).Days;
liciense.IsUse = false;
liciense.ExpireDate = licienseCheck.ExpireDate.AddDays(availableDay);
this.Create(liciense);
this.Update(licienseCheck);
return(true);
}
this.Create(liciense);
return(true);
}
}
catch (Exception e)
{
//return false;
throw new Exception(e.Message);
}
}
if (liciense.PackageId == TYPE_VIP)
{
try
{
if (getLicienseByUserIdAndType(userId, TYPE_VIP) != null)
{
var licienseCheck = getLicienseByUserIdAndType(userId, TYPE_Normal);
if (licienseCheck != null)
{
licienseCheck.IsUse = false;
var availableDay = (licienseCheck.ExpireDate - DateTime.Now).Days;
licienseCheck.ExpireDate = liciense.ExpireDate.AddDays(availableDay);
this.Update(liciense);
this.Update(licienseCheck);
return(true);
}
liciense.IsUse = true;
this.Update(liciense);
return(true);
}
else
{
var licienseCheck = getLicienseByUserIdAndType(userId, TYPE_Normal);
if (licienseCheck != null)
{
licienseCheck.IsUse = false;
var availableDay = (licienseCheck.ExpireDate - DateTime.Now).Days;
licienseCheck.ExpireDate = liciense.ExpireDate.AddDays(availableDay);
this.Create(liciense);
this.Update(licienseCheck);
return(true);
}
liciense.IsUse = true;
this.Create(liciense);
return(true);
}
}
catch (Exception e)
{
throw new Exception(e.Message);
}
}
return(false);
}
public HttpResponseMessage getNewLicense(String username, int LicenseTypeId)
{
try
{
String licenseTypeNew = "";
ILicenseTypeService licenseTypeService = this.Service <ILicenseTypeService>();
var licenseType = licenseTypeService.getLicenseById(LicenseTypeId);
IUserService userService = this.Service <IUserService>();
IHistoryService historyService = this.Service <IHistoryService>();
userService.AddExpireDay(username, (Int64)licenseType.BuyDate);
User user = userService.GetByUsername(username);
var licienseService = this.Service <ILicienseService>();
//var listUserLiense = licienseService.getListByUserId(user.Id);
//var dayToAdd = listUserLiense.FirstOrDefault(q => q.Type == type).ExpireDate;
var flag = false;
if (isCreated(user.Id, (int)licenseType.PackageId))
{
var liciense = licienseService.getLicienseByUserIdAndType(user.Id, (int)licenseType.PackageId);
DateTime currentDay = DateTime.Now;
if (currentDay.CompareTo(liciense.ExpireDate) == -1)
{
currentDay = liciense.ExpireDate;
}
if (liciense.CreatedDate != null)
{
liciense.CreatedDate = currentDay;
}
liciense.DayOfPurchase = liciense.DayOfPurchase + (int)licenseType.BuyDate;
liciense.ExpireDate = currentDay.AddDays((int)licenseType.BuyDate);
liciense.Active = true;
flag = licienseService.AddNewLiciense(user.Id, liciense);
}
else
{
var liciense = new Liciense();
liciense.UserId = user.Id;
liciense.ExpireDate = DateTime.Now.AddDays((Int64)licenseType.BuyDate);
liciense.CreatedDate = DateTime.Now;
liciense.Active = true;
liciense.DayOfPurchase = (int)licenseType.BuyDate;
liciense.IsUse = true;
liciense.PackageId = (int)licenseType.PackageId;
flag = licienseService.AddNewLiciense(user.Id, liciense);
}
if (flag)
{
licenseTypeNew = licienseService.getIsUseLiciense(user.Id).PackageId.ToString();
//create history
History history = new History();
history.TypeId = licenseType.Id;
history.UserId = user.Id;
history.CreatedDate = DateTime.Now;
historyService.Create(history);
user.ExpireDate = licienseService.getIsUseLiciense(user.Id).ExpireDate;
userService.Update(user);
}
//return this.RedirectToAction("Index", "ManageAccount", new { area = "User" });
return(new HttpResponseMessage()
{
StatusCode = System.Net.HttpStatusCode.OK,
Content = new JsonContent(licenseTypeNew)
});
}
catch (Exception e)
{
return(new HttpResponseMessage()
{
StatusCode = System.Net.HttpStatusCode.NotFound,
Content = new JsonContent("Add Fail")
});
}
}
// GET: Admin/Accounts
public ActionResult Index(LoginViewModel model)
{
try
{
ViewBag.Username = Session["Username"];
IUserService userService = this.Service <IUserService>();
if (Session["Username"] == null)
{
return(this.Redirect("/"));
}
User user = userService.GetByUsername(Session["Username"].ToString());
ILicienseService licienseService = this.Service <ILicienseService>();
Liciense liciense = licienseService.getIsUseLiciense(user.Id);
ViewBag.licienseType = "Tài khoản khách";
ViewBag.UserFullName = user.Fullname;
ViewBag.availableDay = 0;
DateTime dt = DateTime.Now.AddDays(-1);
if (liciense != null)
{
if (liciense.PackageId == 1)
{
ViewBag.licienseType = "Tài khoản thường";
}
if (liciense.PackageId == 2)
{
ViewBag.licienseType = "Tài khoản VIP";
}
if (liciense.ExpireDate.CompareTo(DateTime.Now) == -1)
{
ViewBag.availableDay = 0;
}
else
{
ViewBag.availableDay = (liciense.ExpireDate - DateTime.Now).Days;
}
dt = (DateTime)liciense.ExpireDate;
}
//ViewBag.ExpireDay = String.Format("{0:dd/ MM/ yyyy}", dt);
if (DateTime.Now.CompareTo(dt) <= 0)
{
ViewBag.ExpireDay = String.Format("{0:dd/ MM/ yyyy}", dt);
}
else
{
ViewBag.ExpireDay = "Hết hạn";
}
ViewBag.Status = "Đang hoạt động";
if (!user.Active)
{
ViewBag.Status = "Đã khóa";
}
DateTime bt = (DateTime)user.Birthday;
ViewBag.BirthDay = String.Format("{0:dd/MM/yyyy}", bt);
}
catch (Exception e)
{
throw new Exception(e.Message);
}
return(View(model));
}
