public ResponseModel Login(Login login)
{
login.Password = EncodeDecode.EncodePassword(login.Password);
var data = _userContext.Users.FirstOrDefault(linq => linq.Email == login.Email && linq.Password == login.Password);
if (data != null)
{
var admindata = new ResponseModel()
{
FirstName = data.FirstName,
LastName = data.LastName,
Email = data.Email,
Type = data.Type,
IsCreated = data.IsCreated,
IsModified = data.IsModified,
UserRole = data.UserRole
};
if (admindata.UserRole == "Admin")
{
return(admindata);
}
else
{
return(null);
}
}
else
{
return(null);
}
}
public RegistrationResponse Registration(UserRegistrationRequest userDetails)
{
try
{
RegistrationResponse responseData = null;
userDetails.Password = EncodeDecode.EncodePasswordToBase64(userDetails.Password);
var userData = new Users
{
FirstName = userDetails.FirstName,
LastName = userDetails.LastName,
Email = userDetails.Email,
Password = userDetails.Password,
IsActive = true,
UserRole = _user,
CreatedDate = DateTime.Now,
ModifiedDate = DateTime.Now
};
_appDBContext.Add(userData);
_appDBContext.SaveChanges();
responseData = ResponseData(userData);
return(responseData);
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
public ResponseModel AdminRegistration(Registratin registration)
{
registration.Password = EncodeDecode.EncodePassword(registration.Password);
var model = new UserDetails()
{
FirstName = registration.FirstName,
LastName = registration.LastName,
Email = registration.Email,
Password = registration.Password,
Type = "Advance",
UserRole = "Admin",
IsActive = true,
IsCreated = DateTime.Now,
IsModified = DateTime.Now,
};
_userContext.Add(model);
_userContext.SaveChanges();
ResponseModel responseModel = new ResponseModel()
{
UserId = model.UserId,
FirstName = model.FirstName,
LastName = model.LastName,
Email = model.Email,
IsActive = model.IsActive,
IsCreated = model.IsCreated,
IsModified = model.IsModified,
Type = model.Type,
UserRole = model.UserRole
};
return(responseModel);
}
// Use this for initialization
void Awake()
{
usrInput = "";
dummy = "";
oldUsername = "";
newUsername = "";
oldPassword = "";
newPassword = "";
decoder = transform.GetComponent <EncodeDecode> ();
dummy = "User Username";
dummy = decoder.Base64Encode(dummy);
if (PlayerPrefs.HasKey(dummy))
{
oldUsername = PlayerPrefs.GetString(dummy);
}
oldUsername = decoder.Base64Decode(oldUsername);
dummy = "User Password";
dummy = decoder.Base64Encode(dummy);
if (PlayerPrefs.HasKey(dummy))
{
oldPassword = PlayerPrefs.GetString(dummy);
}
oldPassword = decoder.Base64Decode(oldPassword);
}
public HttpResponseMessage CreateUser([FromBody] UserRequestDTO data)
{
var respMessage = new HttpResponseMessage();
if (data == null)
{
return(BaseController.Security.GetMessageNotCreateUser(respMessage, "Dados inválidos"));
}
if (string.IsNullOrWhiteSpace(data.email))
{
return(BaseController.Security.GetMessageNotCreateUser(respMessage, "E-mail não informado"));
}
if (string.IsNullOrWhiteSpace(data.nickName))
{
return(BaseController.Security.GetMessageNotCreateUser(respMessage, "Usuário não informado"));
}
if (string.IsNullOrWhiteSpace(data.codeIn))
{
return(BaseController.Security.GetMessageNotCreateUser(respMessage, "Senha não informada"));
}
if (!BaseController.Security.IsValidEmail(data.email))
{
return(BaseController.Security.GetMessageInvalidMail(respMessage));
}
else
{
data.codeIn = EncodeDecode.CrashOut(data.codeIn);
data.repeatCodeIn = EncodeDecode.CrashOut(data.repeatCodeIn);
BaseController.Security.GetMessageCreateUser(respMessage, _userBusiness.InsertUser(data));
}
return(respMessage);
}
/// <summary>
/// Verify Admin Login Details
/// </summary>
/// <param name="loginDetails">Admin Login Details</param>
/// <returns>If data verified, return response data else ull or exception</returns>
public async Task <RegistrationResponse> AdminLogin(AdminLoginRequest loginDetails)
{
try
{
RegistrationResponse responseData = null;
loginDetails.Password = EncodeDecode.EncodePasswordToBase64(loginDetails.Password);
SQLConnection();
using (SqlCommand cmd = new SqlCommand("ValidateLogin", conn))
{
cmd.CommandType = System.Data.CommandType.StoredProcedure;
cmd.Parameters.AddWithValue("@Email", loginDetails.Email);
cmd.Parameters.AddWithValue("@Password", loginDetails.Password);
cmd.Parameters.AddWithValue("@UserRole", _admin);
conn.Open();
SqlDataReader dataReader = await cmd.ExecuteReaderAsync();
responseData = AdminRegistrationResponseModel(dataReader);
};
return(responseData);
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
public ResponseModel AdminLogin(Login login)
{
try
{
login.Password = EncodeDecode.EncodePassword(login.Password);
var data = this._user.Users.FirstOrDefault(user => user.Email == login.Email && user.Passwrod == login.Password);
if (data != null)
{
var userdata = new ResponseModel()
{
Id = data.Id,
FirstName = data.FirstName,
LastName = data.LastName,
Email = data.Email,
IsActive = data.IsActive,
IsCreated = data.IsCreated,
IsModified = data.IsModified,
Type = data.Type,
UserRole = data.UserRole
};
return(userdata);
}
else
{
return(null);
}
}
catch (Exception e)
{
throw new Exception(e.Message);
}
}
/// <summary>
/// It Check whether the login data send by the user is correct or not.
/// </summary>
/// <param name="login">login parameter like email-id or password</param>
/// <returns>It return the Response Model to be Send as Response</returns>
public UserResponseModel Login(LoginRequest login)
{
try
{
login.Password = EncodeDecode.EncodePasswordToBase64(login.Password);
var data = context.UserDetails.FirstOrDefault(user => (user.EmailId == login.EmailId) &&
(user.Password == login.Password) && user.UserRole == _user);
if (data != null)
{
var userData = new UserResponseModel()
{
UserId = data.UserId,
FirstName = data.FirstName,
LastName = data.LastName,
EmailId = data.EmailId,
ProfilePic = data.ProfilePic,
Type = data.Type,
IsActive = data.IsActive,
UserRole = data.UserRole,
CreatedAt = data.CreatedAt,
ModifiedAt = data.ModifiedAt
};
return(userData);
}
return(null);
}
catch (Exception e)
{
throw new Exception(e.Message);
}
}
/// <summary>
/// Add admin details into the database
/// </summary>
/// <param name="adminDetails">Admin Registration Details</param>
/// <returns>If data added successully, return response data else null or exception</returns>
public async Task <RegistrationResponse> AdminRegistration(AdminRegistrationRequest adminDetails)
{
try
{
RegistrationResponse responseData = null;
adminDetails.Password = EncodeDecode.EncodePasswordToBase64(adminDetails.Password);
SQLConnection();
using (SqlCommand cmd = new SqlCommand("AddUserDetails", conn))
{
cmd.CommandType = System.Data.CommandType.StoredProcedure;
cmd.Parameters.AddWithValue("@FirstName", adminDetails.FirstName);
cmd.Parameters.AddWithValue("@LastName", adminDetails.LastName);
cmd.Parameters.AddWithValue("@Email", adminDetails.Email);
cmd.Parameters.AddWithValue("@Password", adminDetails.Password);
cmd.Parameters.AddWithValue("@IsActive", true);
cmd.Parameters.AddWithValue("@UserRole", _admin);
cmd.Parameters.AddWithValue("@CreatedDate", DateTime.Now);
cmd.Parameters.AddWithValue("@ModifiedDate", DateTime.Now);
conn.Open();
SqlDataReader dataReader = await cmd.ExecuteReaderAsync();
responseData = AdminRegistrationResponseModel(dataReader);
};
return(responseData);
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
public ActionResult Create(User user)
{
if (ModelState.IsValid)
{
User dbuser = db.Users.FirstOrDefault(x => x.Email == user.Email && x.IsAdmin == false);
if (dbuser == null)
{
EncodeDecode encodeDecode = new EncodeDecode();
SendMail sendMail = new SendMail();
user.CreateDateTime = DateTime.Now;
user.IsActive = true;
user.UserKey = encodeDecode.EnCode(user.Email);
user.IsMailSuccess = true;
//string verifyUrl = System.Web.HttpContext.Current.Request.Url.GetLeftPart(UriPartial.Authority) +
// "/MailOnayla?Id=" + user.UserKey;
//sendMail.MailSender("Sakalli Ticaret | Üyelik Aktivasyonu", "Üyelik Aktivasyonu İçin Aşağıdaki Linke Tıklayınız<br><br><br><a href='" + verifyUrl + "'>Aktivasyın Linki</a>", user.Email);
db.Users.Add(user);
db.SaveChanges();
return(Redirect("/Kullanici/KayitBasarili"));
}
else
{
ViewBag.ResultType = "danger";
ViewBag.ResultMessage = "Mail Adresi Zaten Sistemde Kayıtlı.";
}
}
return(View(user));
}
public RegistrationResponse Registration(AdminRegistrationRequest adminDetails)
{
try
{
RegistrationResponse responseData = null;
adminDetails.Password = EncodeDecode.EncodePasswordToBase64(adminDetails.Password);
var adminData = new Users
{
FirstName = adminDetails.FirstName,
LastName = adminDetails.LastName,
Email = adminDetails.Email,
Password = adminDetails.Password,
IsActive = true,
UserRole = "Admin",
CreatedDate = DateTime.Now,
ModifiedDate = DateTime.Now
};
_appDBContext.Add(adminData);
_appDBContext.SaveChanges();
responseData = SecurityRepository.ResponseData(adminData);
return(responseData);
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
/// <summary>
/// It Reset the User Password From the Database.
/// </summary>
/// <param name="resetPassword">ResetPassword Model</param>
/// <returns>Return True if reset is successfull or else false</returns>
public async Task <bool> ResetPassword(ResetPasswordRequest resetPassword, int userId)
{
try
{
UserDetails userDetails = context.UserDetails.FirstOrDefault(usr => usr.UserId == userId);
if (userDetails != null)
{
resetPassword.Password = EncodeDecode.EncodePasswordToBase64(resetPassword.Password);
userDetails.Password = resetPassword.Password;
userDetails.ModifiedAt = DateTime.Now;
var user = context.UserDetails.Attach(userDetails);
user.State = Microsoft.EntityFrameworkCore.EntityState.Modified;
await context.SaveChangesAsync();
return(true);
}
return(false);
}
catch (Exception e)
{
throw new Exception(e.Message);
}
}
public LoginResponse AdminLogin(LoginRequest loginRequest)
{
try
{
loginRequest.Password = EncodeDecode.EncodePassword(loginRequest.Password);
var admin = this.dBContext.admins.FirstOrDefault(linq => linq.AdmEmail == loginRequest.AdminEmail && linq.Password == loginRequest.Password);
if (admin != null)
{
var adminData = new LoginResponse()
{
AdminId = admin.AdminId,
AdminFirstName = admin.AdmFirstName,
AdminLastName = admin.AdmLastName,
AdminContactNumber = admin.AdmContactNumber,
AdminEmail = admin.AdmEmail
};
return(adminData);
}
return(null);
}
catch (Exception e)
{
throw new Exception(e.Message);
}
}
/// <summary>
/// method for Logins the specified login.
/// </summary>
/// <param name="login">The login.</param>
/// <returns>return userdata if successful</returns>
public ResponseModel Login(Login login)
{
try
{
login.Password = EncodeDecode.EncodePassword(login.Password);
var data = _userContext.Users.FirstOrDefault(user => (user.Email == login.Email) && (user.Password == login.Password));
if (data != null)
{
var userdata = new ResponseModel()
{
UserId = data.UserId,
FirstName = data.FirstName,
LastName = data.LastName,
Priofilepic = data.ProfilePicture,
Email = data.Email,
Type = data.Type,
IsActive = data.IsActive,
IsCreated = data.IsCreated,
IsModified = data.IsModified
};
return(userdata);
}
return(null);
}
catch (Exception e)
{
throw new Exception(e.Message);
}
}
private void getPersonById()
{
string query = @"SELECT * FROM Employees where Employee_id = @id";
using (SqlCommand cmd = new SqlCommand(query, ConnUtil.connection))
{
cmd.Parameters.AddWithValue("@id", empId);
SqlDataReader reader = cmd.ExecuteReader();
while (reader.HasRows)
{
while (reader.Read())
{
txtEmployeeNumber.IntegerValue = (int)reader["Employee_Number"];
txtEmployeeName.Text = (string)reader["Employee_Name"];
cmbGender.SelectedItem = (string)reader["Gender"];
cmbUnit.SelectedValue = (int)reader["Unit_Id"];
cmbPosition.SelectedValue = (int)reader["Position_Id"];
if (reader["Password"].ToString().Length > 0)
{
var passwordEnc = (string)reader["Password"];
var passwordDec = EncodeDecode.Decrypt(passwordEnc);
txtPassword.Text = passwordDec;
}
}
reader.NextResult();
}
reader.Close();
}
}
public void SendPacket(IServerPacket Message)
{
if (Message == null || this.GetConnection() == null)
{
return;
}
this.GetConnection().SendData(EncodeDecode.EncodeMessage(Message.GetBytes()));
}
private void insertPEA()
{
DateTime now = ClsUtil.getCurrentDate();
var password = EncodeDecode.Encrypt(txtPassword.Text);
var unitId = cmbUnit.SelectedValue;
var positionId = cmbPosition.SelectedValue;
var gender = cmbGender.Text;
try
{
string query = @"
INSERT INTO [dbo].[Employees]
([Employee_Number]
,[Employee_Name]
,[Gender]
,[Hire_Date]
,[Birth_Date]
,[Unit_Id]
,[Position_id]
,[created_date]
,[created_by]
,[Password])
VALUES
(@Employee_Number
,@Employee_Name
,@Gender
,@Hire_Date
,@Birth_Date
,@Unit_Id
,@Position_id
,@created_date
,@created_by
,@Password)";
using (SqlCommand cmd = new SqlCommand(query, ConnUtil.connection))
{
cmd.Parameters.AddWithValue("@Employee_Number", txtEmployeeNumber.IntegerValue);
cmd.Parameters.AddWithValue("@Employee_Name", txtEmployeeName.Text);
cmd.Parameters.AddWithValue("@Gender", gender);
cmd.Parameters.AddWithValue("@Hire_Date", dtHireDate.Value.ToShortDateString());
cmd.Parameters.AddWithValue("@Birth_Date", dtBirthDate.Value.ToShortDateString());
cmd.Parameters.AddWithValue("@Unit_Id", unitId);
cmd.Parameters.AddWithValue("@Position_id", positionId);
cmd.Parameters.AddWithValue("@created_date", ClsUtil.currentDateTime);
cmd.Parameters.AddWithValue("@created_by", ClsUtil.userLogin);
cmd.Parameters.AddWithValue("@Password", password);
cmd.CommandType = CommandType.Text;
cmd.ExecuteNonQuery();
MsgBoxUtil.MsgSuccessSave();
}
}
catch (Exception ex)
{
MsgBoxUtil.MsgError(ex.Message);
}
}
/// <summary>
/// It Stores Data in the Database
/// </summary>
/// <param name="registrationRequest">User Data</param>
/// <returns>If Storing Data Successfull it return ResponseData else null or Exception</returns>
public AdminResponseModel Registration(RegistrationRequest registrationRequest)
{
try
{
AdminResponseModel responseData = null;
using (SqlConnection conn = new SqlConnection(sqlConnectionString))
{
SqlCommand cmd = new SqlCommand("spAddAdminAccount", conn)
{
CommandType = System.Data.CommandType.StoredProcedure
};
cmd.Parameters.AddWithValue("@FirstName", registrationRequest.FirstName);
cmd.Parameters.AddWithValue("@LastName", registrationRequest.LastName);
cmd.Parameters.AddWithValue("@Email", registrationRequest.Email);
cmd.Parameters.AddWithValue("@Password", EncodeDecode.EncodePasswordToBase64(registrationRequest.Password));
cmd.Parameters.AddWithValue("@ContactNumber", registrationRequest.ContactNumber);
cmd.Parameters.AddWithValue("@IsVerified", registrationRequest.IsVerified);
cmd.Parameters.AddWithValue("@CreatorStamp", registrationRequest.CreatorStamp);
cmd.Parameters.AddWithValue("@CreatorUser", registrationRequest.CreatorUser);
cmd.Parameters.AddWithValue("@CreatedDate", DateTime.Now);
cmd.Parameters.AddWithValue("@ModifiedDate", DateTime.Now);
conn.Open();
SqlDataReader dataReader = cmd.ExecuteReader();
while (dataReader.Read())
{
responseData = new AdminResponseModel
{
AdminID = Convert.ToInt32(dataReader["AdminID"].ToString()),
FirstName = dataReader["FirstName"].ToString(),
LastName = dataReader["LastName"].ToString(),
Email = dataReader["Email"].ToString(),
ContactNumber = dataReader["ContactNumber"].ToString(),
IsVerified = Convert.ToBoolean(dataReader["IsVerified"]),
CreatorStamp = dataReader["CreatorStamp"].ToString(),
CreatorUser = dataReader["CreatorUser"].ToString(),
CreatedDate = Convert.ToDateTime(dataReader["CreatedDate"]),
ModifiedDate = Convert.ToDateTime(dataReader["ModifiedDate"])
};
}
conn.Close();
}
return(responseData);
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
/// <summary>
/// It checks Email & Password
/// </summary>
/// <param name="login">Login Data</param>
/// <returns>If Data Found return ResponseData else null or Exception</returns>
public AdminResponseModel Login(LoginRequest login)
{
try
{
AdminResponseModel responseData = null;
using (SqlConnection conn = new SqlConnection(sqlConnectionString))
{
SqlCommand cmd = new SqlCommand("spValidateAdminLogin", conn)
{
CommandType = System.Data.CommandType.StoredProcedure
};
SqlParameter parm = new SqlParameter("@Status", SqlDbType.Int);
parm.Direction = ParameterDirection.ReturnValue;
cmd.Parameters.Add(parm);
cmd.Parameters.AddWithValue("@Email", login.Email);
cmd.Parameters.AddWithValue("@Password", EncodeDecode.EncodePasswordToBase64(login.Password));
conn.Open();
cmd.ExecuteNonQuery();
var status = Convert.ToInt32(parm.Value);
if (status > 0)
{
SqlDataReader dataReader = cmd.ExecuteReader();
while (dataReader.Read())
{
responseData = new AdminResponseModel()
{
AdminID = Convert.ToInt32(dataReader["AdminID"]),
FirstName = dataReader["FirstName"].ToString(),
LastName = dataReader["LastName"].ToString(),
Email = dataReader["Email"].ToString(),
ContactNumber = dataReader["ContactNumber"].ToString(),
IsVerified = Convert.ToBoolean(dataReader["IsVerified"]),
CreatorStamp = dataReader["CreatorStamp"].ToString(),
CreatorUser = dataReader["CreatorUser"].ToString(),
CreatedDate = Convert.ToDateTime(dataReader["CreatedDate"]),
ModifiedDate = Convert.ToDateTime(dataReader["ModifiedDate"])
};
}
}
conn.Close();
}
return(responseData);
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
/// <summary>
/// It Register the new User.
/// </summary>
/// <param name="userDetails">User Data</param>
/// <returns>It return the Response Model to be Send as Response</returns>
public async Task <UserResponseModel> Registration(RegisterRequest userDetails)
{
try
{
userDetails.Password = EncodeDecode.EncodePasswordToBase64(userDetails.Password);
var userData = new UserDetails
{
FirstName = userDetails.FirstName,
LastName = userDetails.LastName,
EmailId = userDetails.EmailId,
Password = userDetails.Password,
Type = userDetails.Type,
IsActive = true,
UserRole = _user,
CreatedAt = DateTime.Now,
ModifiedAt = DateTime.Now
};
context.UserDetails.Add(userData);
await context.SaveChangesAsync();
var data = new UserResponseModel()
{
UserId = userData.UserId,
FirstName = userData.FirstName,
LastName = userData.LastName,
EmailId = userData.EmailId,
Type = userData.Type,
IsActive = userData.IsActive,
UserRole = userData.UserRole,
CreatedAt = userData.CreatedAt,
ModifiedAt = userData.ModifiedAt
};
return(data);
}
catch (Exception e)
{
if (e.InnerException != null)
{
throw new Exception(e.InnerException.Message);
}
else
{
throw new Exception(e.Message);
}
}
}
private void updatePEA()
{
var password = EncodeDecode.Encrypt(txtPassword.Text);
var unitId = cmbUnit.SelectedValue;
var positionId = cmbPosition.SelectedValue;
var gender = cmbGender.Text;
var dateTimeNow = ClsUtil.getCurrentDate();
try
{
string query = @"
UPDATE [dbo].[Employees]
SET [Employee_Number] =@Employee_Number
,[Employee_Name] = @Employee_Name
,[Gender] = @Gender
,[Hire_Date] =@Hire_Date
,[Birth_Date] =@Birth_Date
,[Unit_Id] = @Unit_Id
,[Position_id] = @Position_id
,[Password] = @Password
,[updated_date] = @updated_date
,[updated_by] = @updated_by
WHERE Employee_id = @emp_id ";
using (SqlCommand cmd = new SqlCommand(query, ConnUtil.connection))
{
cmd.Parameters.AddWithValue("@Employee_Number", txtEmployeeNumber.IntegerValue);
cmd.Parameters.AddWithValue("@Employee_Name", txtEmployeeName.Text);
cmd.Parameters.AddWithValue("@Gender", gender);
cmd.Parameters.AddWithValue("@Hire_Date", dtHireDate.Value.ToShortDateString());
cmd.Parameters.AddWithValue("@Birth_Date", dtBirthDate.Value.ToShortDateString());
cmd.Parameters.AddWithValue("@Unit_Id", unitId);
cmd.Parameters.AddWithValue("@Position_id", positionId);
cmd.Parameters.AddWithValue("@Password", password);
cmd.Parameters.AddWithValue("@updated_date", ClsUtil.currentDateTime);
cmd.Parameters.AddWithValue("@updated_by", ClsUtil.userLogin);
cmd.Parameters.AddWithValue("@emp_id", empId);
cmd.CommandType = CommandType.Text;
cmd.ExecuteNonQuery();
MsgBoxUtil.MsgSuccessSave();
}
}
catch (Exception ex)
{
MsgBoxUtil.MsgError(ex.Message);
}
}
public UserResponseDTO InsertUser(UserRequestDTO data)
{
var resultGuid = Guid.NewGuid();
try
{
var resultMailExist = VerifyUserExist(data, out _response);
if (!resultMailExist)
{
if (_userRepository.InsertUser(new UserRequestDTO
{
email = data.email,
codeIn = EncodeDecode.CrashIn(data.codeIn),
nickName = data.nickName
}, resultGuid.ToString(), EncodeDecode.CrashIn(data.codeIn)) == 1)
{
_response.guid = resultGuid.ToString();
_response.hasSuccess = true;
_response.logged = true;
_response.statusCode = System.Net.HttpStatusCode.OK;
_response.message = "Usuário cadastrado com sucesso!";
}
else
{
_response.guid = null;
_response.hasSuccess = false;
_response.logged = false;
_response.statusCode = System.Net.HttpStatusCode.Unauthorized;
_response.message = "Erro ao cadastrar usuário!";
}
}
}
catch (Exception ex)
{
_response.guid = null;
_response.hasSuccess = false;
_response.logged = false;
_response.statusCode = System.Net.HttpStatusCode.Unauthorized;
_response.message = "Erro no cadastro de usuários. | " + ex.Message;
}
return(_response);
}
private void loginProcess()
{
var passwordEnc = "";
var passwordDec = "";
string query = @"SELECT * FROM Employees where Employee_number = @id";
using (SqlCommand cmd = new SqlCommand(query, ConnUtil.connection))
{
cmd.Parameters.AddWithValue("@id", txtUserName.Text);
SqlDataReader reader = cmd.ExecuteReader();
if (reader.HasRows)
{
while (reader.Read())
{
if (reader["Password"].ToString().Length > 0)
{
passwordEnc = (string)reader["Password"];
passwordDec = EncodeDecode.Decrypt(passwordEnc);
}
}
reader.NextResult();
if (txtPassword.Text != passwordDec.ToString())
{
reader.Close();
MsgBoxUtil.MsgError("Password Salah");
return;
}
reader.Close();
ClsUtil.userLogin = txtUserName.Text;
FrmMainMenu frmMainMenu = new FrmMainMenu();
frmMainMenu.ShowDialog();
this.Hide();
this.Close();
}
else
{
MsgBoxUtil.MsgError("User Tidak Ditemukan !!");
reader.Close();
}
}
}
public MyHitbaseUserControl()
{
InitializeComponent();
webClient.UseDefaultCredentials = true;
webClient.Proxy.Credentials = CredentialCache.DefaultCredentials;
UpdateWindowState();
textBoxUser.Text = Settings.Current.MyHitbaseLastUserName;
if (!string.IsNullOrEmpty(Settings.Current.MyHitbaseLastPassword))
{
textBoxPassword.Password = EncodeDecode.Decrypt(Settings.Current.MyHitbaseLastPassword, "myHitbase");
checkBoxSaveCredentials.IsChecked = true;
}
checkBoxDontSendCover.IsChecked = Settings.Current.MyHitbaseDontSendImages;
Loaded += new RoutedEventHandler(MyHitbaseUserControl_Loaded);
}
public static void Main(string[] args)
{
#region Passo variáveis simulando um cadastro de usuário na base
var input = new CustomerRequestDTO
{
email = "*****@*****.**", //Email
codeIn = "teste@123", //Senha
repeatCodeIn = "teste@123", //Repete Senha
nickName = "Joca"
};
#endregion
#region Crio uma criptografia dos dados sensíveis a serem transitado pela API (Senha e Repetição de Senha)
var request = new HttpRequestMessage();
input.codeIn = EncodeDecode.CrashIn(input.codeIn);
input.repeatCodeIn = EncodeDecode.CrashIn(input.repeatCodeIn);
#endregion
#region Crio o usuário na base
var resultCreateUser = CallCreateUser(input);
#endregion
#region Crio token de acesso ao Sistema para o usuário anterior
if (resultCreateUser != null)
{
if (resultCreateUser.FirstOrDefault().hasSuccess == true && resultCreateUser.FirstOrDefault().logged == true)
{
#region Crio o Token de acesso ao sistema
var resultCreatToken = CallCreateToken(new AuthenticationRequestDTO
{
email = input.email,
nameSystem = "ExemploNomeAplicacao",
sKey = resultCreateUser.FirstOrDefault().guid,
userName = input.nickName
});
#endregion
}
}
#endregion
}
public AdminResponse AdminRegistration(AdminRequest adminRequest)
{
try
{
var data = this.dBContext.admins.FirstOrDefault(linq => linq.AdmEmail == adminRequest.AdminEmail);
if (data != null)
{
return(null);
}
adminRequest.Password = EncodeDecode.EncodePassword(adminRequest.Password);
Admin admin = new Admin()
{
AdmFirstName = adminRequest.AdminFirstName,
AdmLastName = adminRequest.AdminLastName,
AdmContactNumber = adminRequest.AdminContactNumber,
AdmEmail = adminRequest.AdminEmail,
Created = DateTime.Now,
Modified = DateTime.Now,
Password = adminRequest.Password
};
this.dBContext.admins.Add(admin);
dBContext.SaveChanges();
if (adminRequest != null)
{
AdminResponse adminResponse = new AdminResponse()
{
AdminId = admin.AdminId,
AdminFirstName = admin.AdmFirstName,
AdminLastName = admin.AdmLastName,
AdminContactNumber = admin.AdmContactNumber,
AdminEmail = admin.AdmEmail,
};
return(adminResponse);
}
return(null);
}
catch (Exception e)
{
throw new Exception(e.Message);
}
}
public UserResponse Login(LoginRequest loginDetails)
{
try
{
UserResponse userResponse = null;
loginDetails.Password = EncodeDecode.EncodePasswordToBase64(loginDetails.Password);
var userData = _appDB.Users.
Where(user => user.Email == loginDetails.Email && user.Password == loginDetails.Password).
FirstOrDefault();
if (userData != null)
{
userResponse = UserResponseMethod(userData);
return(userResponse);
}
return(null);
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
public RegistrationResponse Login(LoginRequest loginDetails)
{
try
{
RegistrationResponse responseData = null;
loginDetails.Password = EncodeDecode.EncodePasswordToBase64(loginDetails.Password);
var userData = _appDBContext.Users
.Where(user => user.Email == loginDetails.Email && user.Password == loginDetails.Password)
.FirstOrDefault();
if (userData != null)
{
responseData = ResponseData(userData);
}
return(responseData);
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
/// <summary>
/// method for Registers the specified user details.
/// </summary>
/// <param name="userDetails">The user details.</param>
/// <returns>returns userdetails</returns>
public async Task <ResponseModel> Register(Registratin registratin)
{
try
{
registratin.Password = EncodeDecode.EncodePassword(registratin.Password);
var model = new UserDetails()
{
FirstName = registratin.FirstName,
LastName = registratin.LastName,
Email = registratin.Email,
Password = registratin.Password,
Type = string.IsNullOrEmpty(registratin.Type.ToString()) ? "null" : registratin.Type,
IsActive = true,
IsCreated = DateTime.Now,
IsModified = DateTime.Now,
UserRole = "User"
};
_userContext.Users.Add(model);
await _userContext.SaveChangesAsync();
ResponseModel responseModel = new ResponseModel()
{
UserId = model.UserId,
FirstName = model.FirstName,
LastName = model.LastName,
Email = model.Email,
Type = model.Type,
IsActive = model.IsActive,
IsCreated = model.IsCreated,
IsModified = model.IsModified,
UserRole = model.UserRole
};
return(responseModel);
}
catch (Exception e)
{
throw new Exception(e.Message);
}
}
public async Task <ResponseModel> AdminRegistration(RegistrationRequestModel adminRegistration)
{
try
{
adminRegistration.Passwrod = EncodeDecode.EncodePassword(adminRegistration.Passwrod);
UserDB dB = new UserDB()
{
FirstName = adminRegistration.FirstName,
LastName = adminRegistration.LastName,
Email = adminRegistration.Email,
Passwrod = adminRegistration.Passwrod,
Type = "Advanced",
IsActive = true,
IsCreated = DateTime.Now,
IsModified = DateTime.Now,
UserRole = "Admin"
};
_user.Users.Add(dB);
await _user.SaveChangesAsync();
ResponseModel responseModel = new ResponseModel()
{
Id = dB.Id,
FirstName = dB.FirstName,
LastName = dB.LastName,
Email = dB.Email,
Type = dB.Type,
IsActive = dB.IsActive,
IsCreated = dB.IsCreated,
IsModified = dB.IsModified,
UserRole = dB.UserRole
};
return(responseModel);
}
catch (Exception e)
{
throw new Exception(e.Message);
}
}
