// GET: Account
public ActionResult Index()
{
using (AccountDBContext db = new AccountDBContext())
{
return(View(db.userAccount.ToList()));
}
}
public ActionResult Login(UserAccount user)
{
using (AccountDBContext db = new AccountDBContext())
{
try
{
var usr = db.userAccount.Single(u => u.Username == user.Username && u.Password == user.Password);
if (usr != null)
{
Session["UserID"] = usr.UserID.ToString();
Session["Username"] = usr.Username.ToString();
return(RedirectToAction("LoggedIn"));
}
else
{
ModelState.AddModelError("", "Username or Password are incorrect");
}
}
catch (Exception)
{
return(RedirectToAction("Login"));
}
}
return(View());
}
public ActionResult LoginStudent(Student _student)
{
AccountDBContext DB = new AccountDBContext();
if (_student.Email != null && _student.Password != null)
{
//encript password here
byte[] bytes = Encoding.Unicode.GetBytes(_student.Password);
byte[] inArray = HashAlgorithm.Create("SHA1").ComputeHash(bytes);
_student.Password = Convert.ToBase64String(inArray);
var Student = DB.Students.Where(x => x.Email == _student.Email && x.Password == _student.Password).FirstOrDefault();
if (Student != null)
{
Session["Email"] = Student.Email.ToString();
Session["StudentId"] = Student.Id.ToString();
Session["StudentName"] = Student.Name.ToString();
return(RedirectToAction("StudentView", "ShareContents"));
}
else
{
ModelState.AddModelError("", "Username or Password not matched");
}
}
return(View());
}
public AuthProcessor(AccountDBContext context, GenericRequest request)
{
this.request = request;
this.context = context;
context.Configuration.ProxyCreationEnabled = false;
users = new GenericRepository <User>(new StorageContext <User>(context));
roles = new GenericRepository <Role>(new StorageContext <Role>(context));
userroles = new GenericRepository <UserRoles>(new StorageContext <UserRoles>(context));
}
public LoginModel(SignInManager <pdn1User> signInManager,
ILogger <LoginModel> logger,
UserManager <pdn1User> userManager
, AccountDBContext context)
{
_context = context;
_userManager = userManager;
_signInManager = signInManager;
_logger = logger;
}
public ActionResult Index()
{
var db = new AccountDBContext();
Account acc = db.Accounts.Where(p => p.Name == "blog").FirstOrDefault();
JavaScriptSerializer marshal = new JavaScriptSerializer();
ViewBag.Panels = marshal.Deserialize <List <Dictionary <string, string> > >(acc.layoutJSON);
//ViewBag.Panels = ParsedJsonMockup.getMockup();
return(View());
}
// GET: MasterUserRegistration
public ActionResult Index()
{
if (Session["UserId"] != null)
{
AccountDBContext DB = new AccountDBContext();
return(View(DB.MasterUserAccounts.ToList()));
}
else
{
return(RedirectToAction("LoginMaster", "MasterUser"));
}
}
public ActionResult Delete()
{
var db = new AccountDBContext();
Account acc = db.Accounts.Where(p => p.Name == "blog").FirstOrDefault();
JavaScriptSerializer marshal = new JavaScriptSerializer();
var clear = new List <Dictionary <string, string> >();
string emptyJson = marshal.Serialize(clear);
acc.layoutJSON = emptyJson;
db.SaveChanges();
return(RedirectToAction("Index"));
}
public string Login(string login, string password)
{
using (var db = new AccountDBContext())
{
var user = db.Users.Where(u => u.Login == login)
.AsEnumerable()
.FirstOrDefault(u => BCrypt.Net.BCrypt.Verify(password, u.PasswordHash));
if (user == null)
{
return(null);
}
return(GetToken(login));
}
}
public ActionResult Register(UserAccount account)
{
if (ModelState.IsValid)
{
using (AccountDBContext db = new AccountDBContext())
{
db.userAccount.Add(account);
db.SaveChanges();
}
ModelState.Clear();
ViewBag.Message = account.firstName + " " + account.lastName + " successfully registered";
}
return(View());
}
public ActionResult DeleteConfirmed(int id)
{
AccountDBContext db2 = new AccountDBContext();
UtilityBillModel utilitybillmodel = db.UtilityBills.Find(id);
var accSum = from a in db2.Accounts
where a.AccountID.Equals(utilitybillmodel.AccountToPayID)
select a.AccountBalance;
//Check if account exists
if (accSum != null)
{
//Check if account sum is greater than the bill
if (accSum.FirstOrDefault() >= utilitybillmodel.AmountToPay) //pay
{
var accountToUpdate = db2.Accounts.Where(o => o.AccountID == utilitybillmodel.AccountToPayID);
// update LastName for all Persons in personsToUpdate
foreach (BankAccountModel p in accountToUpdate)
{
p.AccountBalance = accSum.FirstOrDefault() - utilitybillmodel.AmountToPay;
}
db.UtilityBills.Remove(utilitybillmodel);
db.SaveChanges();
db2.SaveChanges();
String currentUser = User.Identity.Name;
db1.Loggers.Add(
new LoggerModel {
dateLog = DateTime.Now,
userNameLog = currentUser,
transactionLog = "Utility payed for " + utilitybillmodel.AccountToPayID + " for amount " + utilitybillmodel.AmountToPay
}
);
db1.SaveChanges();
return(RedirectToAction("Index"));
}
else
{
return(RedirectToAction("Error1"));
}
}
//If account does not exist
else
{
return(RedirectToAction("Error"));
}
}
public ActionResult NewPanel(string q)
{
var db = new AccountDBContext();
Account acc = db.Accounts.Where(p => p.Name == "blog").FirstOrDefault();
JavaScriptSerializer marshal = new JavaScriptSerializer();
ViewBag.Panels = marshal.Deserialize <List <Dictionary <string, string> > >(acc.layoutJSON);
if (q != null)
{
var dict = marshal.Deserialize <Dictionary <string, string> >(q);
ViewBag.Panels.Add(dict);
string newJson = marshal.Serialize(ViewBag.Panels);
acc.layoutJSON = newJson;
db.SaveChanges();
}
return(View("Index"));
}
public async Task <string> RegisterAsync(string login, string password)
{
using (var db = new AccountDBContext())
{
var user = await db.Users.FirstOrDefaultAsync(u => u.Login == login);
if (user != null)
{
return(null);
}
await db.Users.AddAsync(new User(login, password));
await db.SaveChangesAsync();
return(GetToken(login));
}
}
static void Main(string[] args)
{
AppDomain.CurrentDomain.SetData("DataDirectory", Application.StartupPath);
AccountDBContext context = new AccountDBContext();
ObjectMessageQueue queue = new ObjectMessageQueue();
ObjectMessageQueue.InitializeQueue(ObjectMessageQueue.AUTH_REQUEST);
while (true)
{
try
{
Object obj = queue.receiveObject(ObjectMessageQueue.AUTH_REQUEST);
GenericRequest gen_req = obj as GenericRequest;
if (gen_req == null)
{
Console.WriteLine("Error processing request, it is not a request object!");
queue.sendObject(null, ObjectMessageQueue.AUTH_RESPONSE);
}
else
{
Console.WriteLine("Fetching data...");
AuthProcessor parser = new AuthProcessor(context, gen_req);
try
{
Object result = typeof(AuthProcessor).GetMethod(gen_req.Method.ToString()).Invoke(parser, null);
Console.WriteLine("It worked!");
queue.sendResponse(result, ObjectMessageQueue.AUTH_RESPONSE);
}
catch (SqlException)
{
Console.WriteLine("An error occurred.");
}
}
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
continue;
}
}
}
public ActionResult Edit(Account acc)
{
var db = new AccountDBContext();
Account blog = db.Accounts.Where(p => p.Name == "blog").FirstOrDefault();
string name = acc.Name;
string pass = acc.Password;
if (name == "blog")
{
if (Hashing.VerifyMd5Hash(MD5.Create(), pass, blog.Password) == true)
{
ViewBag.Logged = true;
}
}
JavaScriptSerializer marshal = new JavaScriptSerializer();
ViewBag.Panels = marshal.Deserialize <List <Dictionary <string, string> > >(blog.layoutJSON);
return(View("Index"));
}
public ActionResult LoginMaster(MasterUserAccount user)
{
AccountDBContext DB = new AccountDBContext();
if (user.Email != null && user.Password != null)
{
var Master = DB.MasterUserAccounts.SingleOrDefault(x => x.Email == user.Email && x.Password == user.Password);
if (Master != null)
{
Session["Email"] = Master.Email.ToString();
Session["UserId"] = Master.UserId.ToString();
return(RedirectToAction("MasterPage"));
}
else
{
ModelState.AddModelError("", "Username or Password not matched");
}
}
return(View());
}
public ActionResult Register(MasterUserAccount account)
{
AccountDBContext DB = new AccountDBContext();
var isExist = DB.MasterUserAccounts.Count(x => x.Email == account.Email);
Password password = new Password();
int PasswordStatus = password.CheckStrength(account.Password);
if (ModelState.IsValid)
{
if (PasswordStatus >= 4)
{
if (isExist == 0)
{
//encript password here
byte[] bytes = Encoding.Unicode.GetBytes(account.Password);
byte[] inArray = HashAlgorithm.Create("SHA1").ComputeHash(bytes);
account.Password = Convert.ToBase64String(inArray);
account.ConfirmPassword = Convert.ToBase64String(inArray);
DB.MasterUserAccounts.Add(account);
DB.SaveChanges();
ModelState.Clear();
ViewBag.Message = "User" + account.FirstName + " " + account.LastName + " is Successfully Registered";
return(View());
}
else
{
ViewBag.Message = "User Already Exist";
return(View());
}
}
else
{
ViewBag.Message = "Password Not Strong";
return(View());
}
}
return(View());
}
public ActionResult LoginTeacher(Teacher _teacher)
{
AccountDBContext DB = new AccountDBContext();
if (_teacher.Email != null && _teacher.Password != null)
{
//encript password here
byte[] bytes = Encoding.Unicode.GetBytes(_teacher.Password);
byte[] inArray = HashAlgorithm.Create("SHA1").ComputeHash(bytes);
_teacher.Password = Convert.ToBase64String(inArray);
var Teacher = DB.Teachers.Where(x => x.Email == _teacher.Email && x.Password == _teacher.Password).FirstOrDefault();
if (Teacher != null)
{
Session["TeacherName"] = Teacher.suffix + " " + Teacher.TeacherFName;
Session["TeacherId"] = Teacher.Id.ToString();
return(RedirectToAction("FacultyView", "ShareContents"));
}
else
{
ModelState.AddModelError("", "Username or Password not matched");
}
}
return(View());
}
public AccountsController(AccountDBContext context)
{
_context = context;
}
public ResturantsFoodsController(AccountDBContext context)
{
_context = context;
}
public LoginManager(AccountDBContext context, ILogger <LoginManager> logger)
{
_context = context;
_logger = logger;
}
public UserMesagesManegerController(AccountDBContext context)
{
_context = context;
}
public HomeController(AccountDBContext context, ILogger <HomeController> logger)
{
_context = context;
_logger = logger;
}
public KpisController(AccountDBContext context, IKpiResult kpiResult)
{
_context = context;
_kpiResult = kpiResult;
}
public AccountRepository(AccountDBContext context)
{
this.context = context;
}
public IndexModel(ILogger <IndexModel> logger, AccountDBContext context)
{
_logger = logger;
_context = context;
ViewData["Count"] = _context.TblMesages.Where(x => (x.ReceiverUser) == (User.Identity.Name.ToUpper())).Count();
}
public ordersManagerController(AccountDBContext context)
{
_context = context;
}
public UserRolesManagerController(AccountDBContext context)
{
_context = context;
}
public async Task <User> GetUser(string login)
{
using (var db = new AccountDBContext())
return(await db.Users.FirstOrDefaultAsync(u => u.Login == login));
}
public MyOrdersController(AccountDBContext context)
{
_context = context;
}
