/// <summary>
/// This function retrieves all information of the admin user
/// </summary>
/// <returns>
/// <para>Returns administrator's information</para>
/// <para>Type: AdministratorModel</para>
/// </returns>
public async Task <AdministratorModel> FetchLoggedInModelAsync()
{
AdministratorModel administrator = null;
using (MySqlConnection connection = new MySqlConnection(DbConnString.DBCONN_STRING))
{
await connection.OpenAsync();
string queryString = "SELECT * FROM login_table WHERE user_username=@usernameLoggedIn";
MySqlCommand command = new MySqlCommand(queryString, connection);
command.Parameters.AddWithValue("@usernameLoggedIn", UserSession.SingleInstance.GetLoggedInUser());
MySqlDataReader reader = (MySqlDataReader)await command.ExecuteReaderAsync();
while (await reader.ReadAsync())
{
string base64String = Convert.ToBase64String((byte[])(reader["user_image"]));
administrator = new AdministratorModel()
{
User_ID = int.Parse(reader["user_id"].ToString()),
Username = reader["user_username"].ToString(),
Password = reader["user_password"].ToString(),
Fullname = reader["user_name"].ToString(),
ProfilePicture = base64String,
Email = reader["email"].ToString()
};
}
}
return(administrator);
}
/// <summary>
/// Gets an Administrator entity by the specified email.
/// </summary>
/// <param name="email"></param>
/// <returns></returns>
public AdministratorModel GetAdministratorByEmail(string email)
{
if (!String.IsNullOrEmpty(email))
{
using (SDContext sdContext = new SDContext())
{
var admin = sdContext.Administrator.Get(x => x.Email == email);
if (admin == null)
{
return(null);
}
AdministratorModel model = new AdministratorModel()
{
Id = admin.Id,
Email = admin.Email,
Firstname = admin.Firstname,
Lastname = admin.Lastname,
UserId = admin.UserId,
LastLogin = admin.LastLogin
};
return(model);
}
}
else
{
return(null);
}
}
/// <summary>
/// This function will retrieve the details of a specific administrator
/// </summary>
/// <param name="administratorID">
/// Passes an int value of the administrator id to retrieve administrator details
/// </param>
/// <returns>
/// <para>Returns Administrator Details</para>
/// <para>Type: AdministratorModel</para>
/// </returns>
public async Task <AdministratorModel> FindAdministratorAsync(int administratorID)
{
AdministratorModel administrator = null;
using (MySqlConnection connection = new MySqlConnection(DbConnString.DBCONN_STRING))
{
await connection.OpenAsync();
string queryString = "SELECT * FROM login_table WHERE user_id=@administratorID";
MySqlCommand command = new MySqlCommand(queryString, connection);
command.Parameters.AddWithValue("@administratorID", administratorID);
MySqlDataReader reader = (MySqlDataReader)await command.ExecuteReaderAsync();
if (await reader.ReadAsync())
{
administrator = new AdministratorModel()
{
Username = reader["user_username"].ToString(),
Password = reader["user_password"].ToString(),
Fullname = reader["user_name"].ToString(),
Email = reader["email"].ToString()
};
}
}
return(administrator);
}
public DbManagementForm(ALT_R_ApiProcessor _apiProcessor)
{
InitializeComponent();
skinManager.AddFormToManage(this);
apiProcessor = _apiProcessor;
this.user = apiProcessor.AppUser;
}
protected async void btn_login_Click(object sender, EventArgs e)
{
string username = txtbox_username.Text;
string password = txtbox_password.Text;
AdministratorModel administratorModel = new AdministratorModel
{
Username = username,
Password = password
};
var isLoginSuccesfull = await LoginRepository.SingleInstance.IsLoginSuccessfullAsync(administratorModel);
if (isLoginSuccesfull)
{
bool isAdmin = await AdministratorRepository.SingleInstance.CheckIfUserIsAdministratorAsync(username);
if (isAdmin)
{
UserSession.SingleInstance.SetLoginUser(username, Constants.EmployeeType.Administrator);
}
else
{
UserSession.SingleInstance.SetLoginUser(username, Constants.EmployeeType.Employee);
}
Response.Redirect("~/Views/Inventory.aspx", false);
}
else
{
BuildSweetAlert("#fff", "Login Error", "User not found!", Constants.AlertStatus.error);
}
}
protected async void ButtonSaveProfile_Click(object sender, EventArgs e)
{
UpdateProgress1.Visible = true;
var isFieldValidated = ValidateFields();
if (isFieldValidated)
{
var updatedUser = new AdministratorModel()
{
Username = Username.Text,
Fullname = Fullname.Text,
Password = Password.Text,
Email = Email.Text
};
try
{
await UserProfileRepository.SingleInstance.UpdateProfileAsync(updatedUser, UserSession.SingleInstance.GetLoggedInUser());
}
catch (MySql.Data.MySqlClient.MySqlException ex)
{
if (ex.Message.Equals($"Duplicate entry '{updatedUser.Username}' for key 'user_username'"))
{
BuildSweetAlert("Duplicate Name!", $"Duplicate name for:{updatedUser.Username}", Constants.AlertStatus.warning);
return;
}
}
FullnameLabel.Text = updatedUser.Fullname;
BuildSweetAlert("Successfull!", "User profile has been updated!", Constants.AlertStatus.success);
}
UpdateProgress1.Visible = false;
}
public IActionResult EditPassword(string id, [FromBody] AdministratorModel administratorModel)
{
// map dto to entity and set id
var user = _iMapper.Map <Administrator>(administratorModel);
user.AdminId = id;
var result = _iAdministratorService.Authenticate(administratorModel.Email, administratorModel.Password);
if (result != null)
{
try
{
// save
_iAdministratorService.EditPassword(user, administratorModel.NewPassword);
var count = 1;
return(Output(new DeleteOrUpdateResponse
{
id = id
}, count));
}
catch (AppException ex)
{
// return error message if there was an exception
return(BadRequest(new { message = ex.Message }));
}
}
throw new Exception("密码或email错误，请检查");
}
public IActionResult Register([FromBody] AdministratorModel userModel)
{
// map dto to entity
var user = _iMapper.Map <Administrator>(userModel);
var count = 1;
try
{
// save
var result = _iAdministratorService.Create(user, userModel.Password);
if (result != null)
{
return(Output(new LoginResponse
{
email = user.Email,
}, count));
}
throw new Exception("注册失败！");
}
catch (AppException ex)
{
// return error message if there was an exception
return(BadRequest(new { message = ex.Message }));
}
}
protected async void ButtonUpdateUser_Click(object sender, EventArgs e)
{
UpdateProgress_Update.Visible = true;
var userId = AdministratorID.Text.ToString();
var username = UsernameUpdate.Text.ToString();
var password = PasswordUpdate.Text.ToString();
var fullName = FullnameUpdate.Text.ToString();
var email = EmailUpdate.Text.ToString();
if (!String.IsNullOrWhiteSpace(username) || !String.IsNullOrWhiteSpace(password) || !String.IsNullOrWhiteSpace(fullName))
{
AdministratorModel administrator = new AdministratorModel()
{
User_ID = int.Parse(userId),
Username = username,
Password = password,
Fullname = fullName,
Email = email
};
await AdministratorRepository.SingleInstance.UpdateAdministrator(administrator);
var generatedNotification = await NotificationRepository
.SingleInstance
.GenerateNotification(NotificationType.UpdateUser, username);
await NotificationRepository.SingleInstance
.InsertNewNotificationAsync(generatedNotification);
BuildSweetAlert("#fff", "Successfull", $"Successfully Updated User:{username}", AlertStatus.success);
}
LoadAdministrators();
UpdateProgress_Update.Visible = false;
}
public async Task <AdministratorModel> SignIn(string username, string password, string token)
{
using (HttpRequestMessage request = new HttpRequestMessage())
{
request.Method = HttpMethod.Get;
request.RequestUri = new Uri($"http://localhost:60079/api/admin/gbe/{username}/{password}");
request.Headers.Add("Authorization", $"bearer {token}");
using (HttpResponseMessage response = await ALT_R_ApiHelper.ApiClient.SendAsync(request))
{
if (response.IsSuccessStatusCode)
{
var result = await response.Content.ReadAsAsync <AdministratorModel>();
AppUser = result;
return(result);
}
else
{
throw new Exception(response.ReasonPhrase);
}
}
}
}
public Administrator(AdministratorModel admin) : base(admin.Id)
{
UserId = admin.UserId;
CreationDate = DateTime.Now;
Education = admin.Education;
Profession = admin.Profession;
IsDisabled = false;
}
public IActionResult Index()
{
var model = new AdministratorModel();
ViewBag.Title = "Utenti";
return(View());
}
public void TestInitialize()
{
AdministratorModel = new AdministratorModel()
{
Name = "name",
Email = "*****@*****.**",
Password = "******"
};
}
public ActionResult OdbijenZahtev(string id)
{
ObjectId i = ObjectId.Parse(id);
Korisnici.OdbijZahtevZaInstruktora(i);
AdministratorModel model = new AdministratorModel();
return(View("~/Views/Korisnik/ProfilnaAdministrator.cshtml", model));
}
public AdministratorModel Insert(AdministratorModel administratorModel)
{
var admin = administratorModel.ConvertToAdministratorEntity();
_serviceUser.ElectAdministrator(administratorModel.UserId);
_repositoryAdministrator.Save(admin);
return(admin.ConvertToAdministrator());
}
public async Task <ActionResult> DeleteConfirmed(string id)
{
AdministratorModel administratorModel = await db.Administrators.FindAsync(id);
db.Administrators.Remove(administratorModel);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
public ActionResult InstruktorToKorisnik(string id)
{
ObjectId i = ObjectId.Parse(id);
Korisnici.KonvertujUKorisnika(i);
AdministratorModel model = new AdministratorModel();
return(View("~/Views/Korisnik/ProfilnaAdministrator.cshtml", model));
}
public ActionResult BrisiKorisnika(string id)
{
ObjectId i = ObjectId.Parse(id);
Korisnici.ObrisiKorisnika(i);
AdministratorModel model = new AdministratorModel();
return(View("~/Views/Korisnik/ProfilnaAdministrator.cshtml", model));
}
public ActionResult Admin(Administrator administrator)
{
AdministratorModel Model = new AdministratorModel();
if (Model.Confirm(administrator.Name, administrator.TZ))
{
return(RedirectToAction("Index", "AdministratorLogin"));
}
return(RedirectToAction("ErrorAdmin"));
}
public void InsertAdministrator(AdministratorModel admin)
{
try
{
connection.DeleteAll <AdministratorModel>();
connection.Insert(admin);
}
catch (Exception ex)
{
}
}
protected async void BtnSave_Click(object sender, EventArgs e)
{
var username = Username.Text.ToString();
var password = Password.Text.ToString();
var fullName = FullName.Text.ToString();
var email = Email.Text.ToString();
if (!String.IsNullOrWhiteSpace(username) && !String.IsNullOrWhiteSpace(password) && !String.IsNullOrWhiteSpace(fullName))
{
AdministratorModel administrator = null;
Stream fs = ImageUpload.PostedFile.InputStream;
BinaryReader br = new System.IO.BinaryReader(fs);
byte[] bytes = br.ReadBytes((int)fs.Length);
administrator = new AdministratorModel()
{
Username = username,
Password = password,
Fullname = fullName,
Email = email,
ProfilePictureUpload = bytes,
};
if (RadioButtonPosition.SelectedValue == "E")
{
administrator.EmployeeType = EmployeeType.Employee;
}
else
{
administrator.EmployeeType = EmployeeType.Administrator;
}
try
{
await AdministratorRepository.SingleInstance.CreateNewAdministrator(administrator);
}
catch (MySql.Data.MySqlClient.MySqlException ex)
{
if (ex.Message.Equals($"Duplicate entry '{administrator.Username}' for key 'user_username'"))
{
BuildSweetAlert("#fff", "Duplicate Username", $"Duplicate Username for {administrator.Username} try another one", AlertStatus.error);
return;
}
}
var generatedNotification = await NotificationRepository
.SingleInstance
.GenerateNotification(NotificationType.CreateUser, username);
await NotificationRepository.SingleInstance
.InsertNewNotificationAsync(generatedNotification);
BuildSweetAlert("#fff", "Successfull!", $"Successfully Added {administrator.Username} as {administrator.EmployeeType.ToString()}", AlertStatus.success);
Response.Redirect(Request.RawUrl, false);
}
}
public IActionResult Create([FromBody] AdministratorModel administratorModel)
{
try
{
var admin = _serviceAdministrator.Insert(administratorModel);
return(HttpResponseHelper.Create(HttpStatusCode.Created, ApiConstants.MSG_REGISTER_ADMIN_SUCCESS, admin));
}
catch (Exception ex)
{
return(HttpResponseHelper.Create(HttpStatusCode.BadRequest, ApiConstants.ERR_GENERIC, ex));
}
}
public IActionResult Update([FromBody] AdministratorModel administratorModel)
{
try
{
var user = _serviceAdministrator.Update(administratorModel);
return(HttpResponseHelper.Create(HttpStatusCode.Created, ApiConstants.MSG_GENERIC_UPDATE_SUCCESS, user));
}
catch (Exception ex)
{
return(HttpResponseHelper.Create(HttpStatusCode.BadRequest, ApiConstants.ERR_GENERIC, ex));
}
}
public async Task <ActionResult> Edit([Bind(Include = "ProfileID,AdministratorID,AdministratorName,JoinDate,Mailbox")] AdministratorModel administratorModel)
{
administratorModel.ProfileID = User.Identity.GetUserId();
if (ModelState.IsValid)
{
db.Entry(administratorModel).State = EntityState.Modified;
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
ViewBag.ProfileID = new SelectList(db.Profiles, "ProfileID", "FirstName", administratorModel.ProfileID);
return(View(administratorModel));
}
public async Task <ActionResult> Delete(string id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
AdministratorModel administratorModel = await db.Administrators.FindAsync(id);
if (administratorModel == null)
{
return(HttpNotFound());
}
return(View(administratorModel));
}
public async Task <ActionResult> Edit(string id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
AdministratorModel administratorModel = await db.Administrators.FindAsync(id);
if (administratorModel == null)
{
return(HttpNotFound());
}
ViewBag.ProfileID = new SelectList(db.Profiles, "ProfileID", "FirstName", administratorModel.ProfileID);
return(View(administratorModel));
}
public async Task <TokenModel> LoginAsync(LoginModel login)
{
AdministratorModel customer = await _administratorBusiness.GetAdministratorByEmailAsync(login.Email);
if (customer == null)
{
throw new KeyNotFoundException("Usuário ou senha inválidos");
}
await ValidateSamePasswordAsync(login.Password, customer.Password);
string permissions = await _permissionBusiness.GetPermissionByAdministratorIdAsync(customer.Id);
return(await _tokenHandler.CreateJwtToken(customer, permissions));
}
public IActionResult CreateAdministrator([FromBody] AdministratorModel administrator)
{
try
{
Company company = companyService.GetCompanyByName(administrator.CompanyName);
Administrator admin = administrator.ToEntity();
admin.Company = company;
administratorService.CreateAdministrator(admin);
return(Ok());
}
catch (Exception ex)
{
return(BadRequest(ex.ToString()));
}
}
public IActionResult Post(AdministratorModel administratorModel)
{
IActionResult result;
if (administratorModel.HasErrors())
{
result = BadRequest(new ErrorModel(administratorModel.Errors()));
}
else
{
var administrator = AdministratorLogic.Create(administratorModel.ToEntity());
result = Created("GetAdministrator", new AdministratorBasicInfoModel(administrator));
}
return(result);
}
public IHttpActionResult updateInfo([FromBody] AdministratorModel admin)
{
bool checkForUpdates = adminHandler.CheckModificationDate(admin.modificationDate, admin.Id);
if (checkForUpdates == false)
{
return(Ok("Updates Happend, close this window to see changes"));
}
bool response = adminHandler.Update(admin);
if (response)
{
return(Ok("ok"));
}
return(Ok("Something went wrong"));
}
