public string updateAccountsAdmin(ModelUtilizatori user)
{
AdministratorRepository up = new AdministratorRepository();
string testing1 = up.updateAccountsAdmin(user);
return(testing1);
}
public ActionResult Edit(int id, AdminControllerAdminVM model)
{
AdministratorRepository adminRepository = new AdministratorRepository();
TryUpdateModel(model);
if (ModelState.IsValid)
{
Administrator admin = null;
if (adminRepository.GetAll(filter: a => a.UserName == model.UserName).FirstOrDefault() == null)
{
admin = new Administrator();
admin.UserName = model.UserName;
admin.Password = SecurityService.CreateHash(model.Password);
admin.FirstName = model.FirstName;
admin.LastName = model.LastName;
admin.IsActive = true;
adminRepository.Save(admin);
return(RedirectToAction("ManageAdministrators"));
}
else
{
throw new ArgumentException("Invalid username !");
}
}
return(View(model));
}
public bool AuthenticateUser(string username, string password, User.UserType userType)
{
switch (userType)
{
case User.UserType.Teacher:
TeacherRepository teacherRepository = new TeacherRepository();
user = teacherRepository.GetAll(filter: u => u.UserName == username && u.IsActive == true).FirstOrDefault();
break;
case User.UserType.Administrator:
AdministratorRepository adminRepository = new AdministratorRepository();
user = adminRepository.GetAll(filter: u => u.UserName == username && u.IsActive == true).FirstOrDefault();
break;
case User.UserType.Student:
StudentRepository studentRepository = new StudentRepository();
user = studentRepository.GetAll(filter: u => u.UserName == username && u.IsActive == true).FirstOrDefault();
break;
default:
LoggedUser = null;
break;
}
if (SecurityService.ValidatePassword(password, user.Password))
{
LoggedUser = user;
}
return(LoggedUser != null);
}
public string modificaSpecializare(ModelSpecializari specializare)
{
AdministratorRepository up = new AdministratorRepository();
string mesaj = up.modificaSpecialziare(specializare);
return(mesaj);
}
public string creeazaUser(ModelUtilizatori newAcc)
{
AdministratorRepository spec = new AdministratorRepository();
string mesaj = spec.creeazaUser(newAcc);
return(mesaj);
}
public IHttpActionResult modificaAnul([FromBody] ModificaAnu spc)
{
AdministratorRepository spec = new AdministratorRepository();
spec.modificaAnul(spc);
return(Ok());
}
public async Task <(bool success, string errorMessage)> InstallAsync(string userName, string password, string email, string mobile)
{
try
{
await SyncDatabaseAsync();
var administrator = new Administrator
{
UserName = userName,
Email = email,
Mobile = mobile
};
await AdministratorRepository.InsertAsync(administrator, password);
await AdministratorRepository.AddUserToRoleAsync(userName, PredefinedRole.ConsoleAdministrator.GetValue());
await UserMenuRepository.ResetAsync();
return(true, string.Empty);
}
catch (Exception ex)
{
return(false, ex.Message);
}
}
public bool AuthenticateUser(string username, string password, UserTypeEnum userType)
{
LoggedUser = null;
UserType = null;
AppContext ctx = new AppContext();
switch (userType)
{
case UserTypeEnum.Administrator:
AdministratorRepository adminRepo = new AdministratorRepository(new AppContext());
LoggedUser = unitOfWork.AdminRepository.GetByUsername(username);
break;
case UserTypeEnum.Student:
StudentRepository studentRepo = new StudentRepository(new AppContext());
LoggedUser = unitOfWork.StudentRepository.GetByUsername(username);
break;
case UserTypeEnum.Teacher:
TeacherRepository teacherRepo = new TeacherRepository(new AppContext());
LoggedUser = unitOfWork.TeacherRepository.GetByUsername(username);
break;
}
if (LoggedUser != null)
{
if (PasswordHasher.Equals(password, LoggedUser.Salt, LoggedUser.Hash))
{
UserType = userType;
return true;
}
LoggedUser = null;
}
return false;
}
public void TestAdministratorGetAllOK2()
{
IMMRequestContext IMMRequestContext = ContextFactory.GetNewContext();
AdministratorRepository adminRepo = new AdministratorRepository(IMMRequestContext);
adminRepo.Add(new Administrator
{
Id = Guid.NewGuid(),
Name = "Just Testing",
Email = "*****@*****.**",
Password = "******"
});
adminRepo.Add(new Administrator
{
Id = Guid.NewGuid(),
Name = "Just Testing again",
Email = "*****@*****.**",
Password = "******"
});
adminRepo.Save();
var admins = adminRepo.GetAll().ToList().Count();
Assert.AreEqual(2, admins);
}
public int countTeachers(int count)
{
AdministratorRepository us = new AdministratorRepository();
count = us.countTeachers();
return(count);
}
public void TestGetByIdNull()
{
Administrator administrator = new Administrator()
{
Id = 1,
Email = "*****@*****.**",
Password = "******"
};
List <Administrator> administrators = new List <Administrator>()
{
administrator,
new Administrator()
{
Id = 2,
Email = "*****@*****.**",
Password = "******"
},
};
administrators.ForEach(s => _context.Add(s));
_context.SaveChanges();
var repository = new AdministratorRepository(_context);
var result = repository.GetById(5);
Assert.IsNull(result);
}
public static void Main()
{
IRepository <BaseEntity, BaseDTO> repo = new AdministratorRepository("connectionString");
Console.WriteLine(repo.GetTestString());
Console.WriteLine("Hello World");
}
public void TestGetAllAdministrator()
{
List <Administrator> administratorsToReturn = new List <Administrator>()
{
new Administrator()
{
Id = 1,
Email = "*****@*****.**",
Password = "******"
},
new Administrator()
{
Id = 2,
Email = "*****@*****.**",
Password = "******"
},
new Administrator()
{
Id = 3,
Email = "*****@*****.**",
Password = "******"
},
};
administratorsToReturn.ForEach(a => _context.Add(a));
_context.SaveChanges();
var repository = new AdministratorRepository(_context);
var result = repository.GetAll();
Assert.IsTrue(administratorsToReturn.SequenceEqual(result));
}
public bool AuthenticateUser(string username, string password, User.UserType userType)
{
switch (userType)
{
case User.UserType.Teacher:
TeacherRepository teacherRepository = new TeacherRepository();
user = teacherRepository.GetAll(filter: u => u.UserName == username && u.IsActive == true).FirstOrDefault();
break;
case User.UserType.Administrator:
AdministratorRepository adminRepository = new AdministratorRepository();
user = adminRepository.GetAll(filter: u => u.UserName == username && u.IsActive == true).FirstOrDefault();
break;
case User.UserType.Student:
StudentRepository studentRepository = new StudentRepository();
user = studentRepository.GetAll(filter: u => u.UserName == username && u.IsActive == true).FirstOrDefault();
break;
default:
LoggedUser = null;
break;
}
if (SecurityService.ValidatePassword(password, user.Password))
LoggedUser = user;
return LoggedUser != null;
}
public Administrator login(string username, string password)
{
AdministratorRepository adminReposObj = new AdministratorRepository();
var dbAdmin = adminReposObj.Read(username);
var passwordHash = "";
//if user doesen't exist
if (dbAdmin == null)
{
return(null);
}
//check if username matches with password
using (Rfc2898DeriveBytes deriveBytes = new Rfc2898DeriveBytes(password, Convert.FromBase64String(dbAdmin.salt)))
{
passwordHash = Convert.ToBase64String(deriveBytes.GetBytes(20));
if (passwordHash == dbAdmin.passwordHash)
{
return(Mapper.Map <Administrator>(dbAdmin));
}
else
{
return(null);
}
}
}
public string setTeacherCourse(SetTeacherCourse teacher)
{
AdministratorRepository up = new AdministratorRepository();
string mesaj = up.setTeacherCourse(teacher);
return(mesaj);
}
public void TestAdministratorGet2()
{
var id = Guid.NewGuid();
IMMRequestContext IMMRequestContext = ContextFactory.GetNewContext();
AdministratorRepository adminRepo = new AdministratorRepository(IMMRequestContext);
Administrator admin1 = new Administrator()
{
Id = Guid.NewGuid(),
Name = "Just Testing",
Email = "*****@*****.**",
Password = "******"
};
Administrator admin2 = new Administrator()
{
Id = id,
Name = "Just Testing again",
Email = "*****@*****.**",
Password = "******"
};
adminRepo.Add(admin1);
adminRepo.Add(admin2);
adminRepo.Save();
Assert.AreEqual(adminRepo.Get(id), admin2);
}
public int countCourse(int count)
{
AdministratorRepository us = new AdministratorRepository();
count = us.countCourse();
return(count);
}
public string creeazaSpecializare(ModelSpecializari specializare)
{
AdministratorRepository spec = new AdministratorRepository();
string mesaj = spec.creeazaSpecializare(specializare);
return(mesaj);
}
public ActionResult ManageAdministrators()
{
AdminControllerAdminVM adminModel = new AdminControllerAdminVM();
AdministratorRepository adminRepository = new AdministratorRepository();
adminModel.administratorList = adminRepository.GetAll();
return(View(adminModel));
}
public JsonResult GetUserName(int id)
{
AdministratorRepository adminRepository = new AdministratorRepository();
Administrator admin = adminRepository.GetById(id);
string name = admin.FirstName + " " + admin.LastName + " ?";
return(Json(name, JsonRequestBehavior.AllowGet));
}
public AdministratorLogic CreateLogic()
{
IMMRequestContext Context = ContextFactory.GetNewContext();
var Repository = new AdministratorRepository(Context);
var Logic = new AdministratorLogic(Repository);
return(Logic);
}
public void GetInvalid()
{
var id = Guid.NewGuid();
IMMRequestContext IMMRequestContext = ContextFactory.GetNewContext();
AdministratorRepository adminRepo = new AdministratorRepository(IMMRequestContext);
adminRepo.Get(id);
}
public void oneTimeSetUp()
{
var connection = DbConnectionFactory.CreateTransient();
this.ctx = new ApplicationDbContext(connection);
this.repo = new AdministratorRepository(ctx);
new DatabaseSeeder().CreateDependenciesAndSeed(ctx);//heavy duty
}
/// <summary>
/// 禁用
/// </summary>
/// <param name="ids">用户标识列表</param>
public async Task DisableAsync(List <Guid> ids)
{
var entities = await AdministratorRepository.FindByIdsAsync(ids);
foreach (var entity in entities)
{
entity.Enabled = false;
}
await AdministratorRepository.UpdateAsync(entities);
await UserManager.DisableAsync(ids);
}
/// <summary>
/// 更新
/// </summary>
/// <param name="parameter">参数</param>
public async Task UpdateAsync(UserParameter parameter)
{
var entity = await AdministratorRepository.FindAsync(parameter.Id);
if (entity == null)
{
throw new Warning("用户不存在");
}
entity.Update(parameter);
await UpdateUserAsync(parameter);
await UpdateUserInfoAsync(parameter);
}
public ActionResult Edit(int id)
{
AdminControllerAdminVM adminModel = new AdminControllerAdminVM();
AdministratorRepository adminRepository = new AdministratorRepository();
if (id > 0)
{
Administrator admin = adminRepository.GetById(id);
adminModel.FirstName = admin.FirstName;
adminModel.LastName = admin.LastName;
}
return(View(adminModel));
}
public static void Add(Administrator _Administrator)
{
try
{
AdministratorRepository _AdministratorRepository = new AdministratorRepository();
_AdministratorRepository.Add(_Administrator);
}
catch (Exception ex)
{
throw ex;
}
}
public static IEnumerable <Administrator> GetAll()
{
try
{
AdministratorRepository _AdministratorRepository = new AdministratorRepository();
return(_AdministratorRepository.GetAll <Administrator>());
}
catch (Exception ex)
{
throw ex;
}
}
public void Initialize()
{
this.options = new DbContextOptionsBuilder <BetterCalmContext>().UseInMemoryDatabase(databaseName: "MSP.BetterCalmDB").Options;
this.context = new BetterCalmContext(this.options);
this.adminRepository = new AdministratorRepository(this.context);
this.sessionLogic = new SessionLogic(this.adminRepository);
Administrator admin1 = new Administrator("Mauro", "*****@*****.**", "12345");
Administrator admin2 = new Administrator("Rodrigo", "*****@*****.**", "4567");
adminRepository.Add(admin1);
adminRepository.Add(admin2);
}
public void TestAddBooking()
{
Administrator administrator = new Administrator()
{
Id = 1,
Email = "*****@*****.**",
Password = "******"
};
var repository = new AdministratorRepository(_context);
repository.AddAndSave(administrator);
Assert.AreEqual(_context.Find <Administrator>(1), administrator);
}
public void GetOneAdministrator()
{
var options = new DbContextOptionsBuilder <BetterCalmContext>()
.UseInMemoryDatabase(databaseName: "MSP.BetterCalmDatabase").Options;
var context = new BetterCalmContext(options);
listAdministrators.ForEach(cat => context.Add(cat));
context.SaveChanges();
repository = new AdministratorRepository(context);
var category = repository.Get(listAdministrators[0].Id);
context.Database.EnsureDeleted();
Assert.AreEqual(listAdministrators[0].Id, category.Id);
}
private void LoadData()
{
AdministratorRepository ARepo = new AdministratorRepository();
SalesmanRepository SRepo = new SalesmanRepository();
var SaleList = SRepo.GetSaleToDashboard();
if (chkAddAdmin.Checked)
{
var listAdmin = ARepo.GetAdminToDashboard();
foreach (var item in listAdmin)
{
SaleList.Add(item);
}
}
grdSalemen.DataSource = SaleList;
grdSalemen.Rebind();
}
public MainRepository(AppContext context)
{
_context = context;
Calls = new CallRepository(_context);
Users = new UserRepository(_context);
Locations = new LocationRepository(_context);
Groups = new GroupRepository(_context);
Operations = new OperationRepository(_context);
Roles = new RoleRepository(_context);
Debits = new DebitRepository(_context);
PenaltyTypes = new PenaltyTypeRepository(_context);
Employees = new EmployeeRepository(_context);
Extras = new ExtraRepository(_context);
PayRolls = new PayRollRepository(_context);
Salaries = new SalaryRepository(_context);
DebitTypes = new DebitTypeRepository(_context);
Penalties = new PenaltyRepository(_context);
DebitPayments = new DebitPaymentRepository(_context);
Administrators = new AdministratorRepository(_context);
Savings = new SavingRepository(_context);
Vacations = new VacationRepository(_context);
RoleOperations = new RoleOperationRepository(_context);
}
public JsonResult DeleteAdministrator(int id)
{
AdministratorRepository adminRepository = new AdministratorRepository();
if (id == AuthenticationManager.LoggedUser.Id)
{
return Json(false, JsonRequestBehavior.AllowGet);
}
else
{
Administrator admin = adminRepository.GetById(id);
if (admin != null)
{
adminRepository.Delete(admin);
}
return Json(true, JsonRequestBehavior.AllowGet);
}
}
public ActionResult Edit(int id)
{
AdminControllerAdminVM adminModel = new AdminControllerAdminVM();
AdministratorRepository adminRepository = new AdministratorRepository();
if (id > 0)
{
Administrator admin = adminRepository.GetById(id);
adminModel.FirstName = admin.FirstName;
adminModel.LastName = admin.LastName;
}
return View(adminModel);
}
public ActionResult Edit(int id, AdminControllerAdminVM model)
{
AdministratorRepository adminRepository = new AdministratorRepository();
TryUpdateModel(model);
if (ModelState.IsValid)
{
Administrator admin = null;
if (adminRepository.GetAll(filter: a => a.UserName == model.UserName).FirstOrDefault() == null)
{
admin = new Administrator();
admin.UserName = model.UserName;
admin.Password = SecurityService.CreateHash(model.Password);
admin.FirstName = model.FirstName;
admin.LastName = model.LastName;
admin.IsActive = true;
adminRepository.Save(admin);
return RedirectToAction("ManageAdministrators");
}
else
{
throw new ArgumentException("Invalid username !");
}
}
return View(model);
}
public JsonResult CheckForExistingName(string name, string type, int id)
{
bool exist = false;
switch (type)
{
case "Admin":
Administrator admin = new Administrator();
AdministratorRepository adminRepository = new AdministratorRepository();
admin = adminRepository.GetAll(filter: a => a.UserName == name && a.Id != id).FirstOrDefault();
if (admin != null)
{
exist = true;
};
break;
case "Student":
Student student = new Student();
StudentRepository studentRepository = new StudentRepository();
student = studentRepository.GetAll(filter: s => s.UserName == name && s.Id != id).FirstOrDefault();
if (student != null)
{
exist = true;
};
break;
case "Teacher":
Teacher teacher = new Teacher();
TeacherRepository teacherRepository = new TeacherRepository();
teacher = teacherRepository.GetAll(filter: t => t.UserName == name && t.Id != id).FirstOrDefault();
if (teacher != null)
{
exist = true;
};
break;
case "Course":
Course course = new Course();
CourseRepository courseRepository = new CourseRepository();
course = courseRepository.GetAll(filter: c => c.Name == name).FirstOrDefault();
if (course != null)
{
exist = true;
};
break;
case "Title":
Title title = new Title();
TitleRepository titleRepository = new TitleRepository();
title = titleRepository.GetAll(filter: t => t.Name == name).FirstOrDefault();
if (title != null)
{
exist = true;
};
break;
case "Subject":
Subject subject = new Subject();
SubjectRepository subjectRepository = new SubjectRepository();
subject = subjectRepository.GetAll(filter: s => s.Name == name).FirstOrDefault();
if (subject != null)
{
exist = true;
};
break;
}
return Json(exist, JsonRequestBehavior.AllowGet);
}
public ActionResult Home()
{
AdminControllerAdminVM model = new AdminControllerAdminVM();
StudentRepository studentRepository = new StudentRepository();
TeacherRepository teacherRepository = new TeacherRepository();
CourseRepository courseRepository = new CourseRepository();
SubjectRepository subjectRepository = new SubjectRepository();
TitleRepository titleRepository = new TitleRepository();
model.ActiveStudentCount = studentRepository.GetAll(filter: s => s.IsActive == true).Count;
model.InActiveStudentCount = studentRepository.GetAll(filter: s => s.IsActive == false).Count;
model.ActiveTeacherCount = teacherRepository.GetAll(filter: t => t.IsActive == true).Count;
model.InActiveTeacherCount = teacherRepository.GetAll(filter: t => t.IsActive == false).Count;
model.CourseCount = courseRepository.GetAll().Count;
model.SubjectCount = subjectRepository.GetAll().Count;
model.TitleCount = titleRepository.GetAll().Count();
Administrator admin = new Administrator();
AdministratorRepository adminRepository = new AdministratorRepository();
admin = adminRepository.GetById(AuthenticationManager.LoggedUser.Id);
model.FirstName = admin.FirstName;
model.LastName = admin.LastName;
return View(model);
}
public ActionResult ManageAdministrators()
{
AdminControllerAdminVM adminModel = new AdminControllerAdminVM();
AdministratorRepository adminRepository = new AdministratorRepository();
adminModel.administratorList = adminRepository.GetAll();
return View(adminModel);
}
public JsonResult GetUserName(int id)
{
AdministratorRepository adminRepository = new AdministratorRepository();
Administrator admin = adminRepository.GetById(id);
string name = admin.FirstName + " " + admin.LastName + " ?";
return Json(name, JsonRequestBehavior.AllowGet);
}
private void btnSendSMS_Click(object sender, EventArgs e)
{
string subject = (!string.IsNullOrEmpty(txtSubject.Text)) ? txtSubject.Text : "No subject";
SmsHandler smsobj = new SmsHandler();
SMSObjRepository smsobjRepo = new SMSObjRepository();
AdministratorRepository ARepo = new AdministratorRepository();
ObjLogin adm = (ObjLogin)Session["objLogin"];
string SMSCode = Guid.NewGuid().ToString().ToLower();
string listPhone = hdfPhoneNumbers.Value;
if (string.IsNullOrEmpty(listPhone))
{
ShowErrorMessage("Please provide recipient to send");
return;
}
char[] separator = new char[] { ',' };
string[] phoneList = listPhone.Split(separator);
bool flag = false;
string PhoneNotExist = string.Empty;
foreach (string phone in phoneList)
{
if (SRepo.CheckSalemenByPhoneNumber(phone))
{
smsobjRepo.InsertSMS(SMSCode, 0, adm.Phone, Constant.SalemenType, phone, Constant.SalemenType, DateTime.Now, subject,
txtContent.Text, true, false, false, 1, int.Parse(ddlPromotion.SelectedValue));
flag = true;
}
else
{
if (CRepo.IsExistedCustomerByPhone(phone))
{
smsobjRepo.InsertSMS(SMSCode, 0, adm.Phone, Constant.SalemenType, phone, Constant.CustomerType, DateTime.Now, subject,
txtContent.Text, true, false, false, 1, int.Parse(ddlPromotion.SelectedValue));
flag = true;
}
else
{
if (ARepo.GetAdminByPhoneNumber(phone))
{
smsobjRepo.InsertSMS(SMSCode, 0, adm.Phone, Constant.SalemenType, phone, Constant.AdminType, DateTime.Now, subject, txtContent.Text, true, false, false, 1, int.Parse(ddlPromotion.SelectedValue));
flag = true;
}
}
}
if (flag == false)
{
PhoneNotExist += phone + ", ";
}
}
if (!string.IsNullOrEmpty(PhoneNotExist))
{
ShowErrorMessage(PhoneNotExist.Substring(0, PhoneNotExist.Length - 2) + " not found in database.");
}
else
{
ShowErrorMessage("Send success");
}
}
