private static SO_CRD_User[] getRecord(
DataTable dataTable_in
)
{
DataColumn _dc_iduser = null;
DataColumn _dc_login = null;
DataColumn _dc_password = null;
DataColumn _dc_ifapplication = null;
SO_CRD_User[] _output
= new SO_CRD_User[dataTable_in.Rows.Count];
for (int r = 0; r < dataTable_in.Rows.Count; r++)
{
if (r == 0)
{
_dc_iduser = dataTable_in.Columns["IDUser"];
_dc_login = dataTable_in.Columns["Login"];
_dc_password = dataTable_in.Columns["Password"];
_dc_ifapplication = dataTable_in.Columns["IFApplication"];
}
_output[r] = new SO_CRD_User();
if (dataTable_in.Rows[r][_dc_iduser] == System.DBNull.Value)
{
_output[r].IDUser = 0L;
}
else
{
_output[r].IDUser = (long)dataTable_in.Rows[r][_dc_iduser];
}
if (dataTable_in.Rows[r][_dc_login] == System.DBNull.Value)
{
_output[r].Login = string.Empty;
}
else
{
_output[r].Login = (string)dataTable_in.Rows[r][_dc_login];
}
if (dataTable_in.Rows[r][_dc_password] == System.DBNull.Value)
{
_output[r].Password = string.Empty;
}
else
{
_output[r].Password = (string)dataTable_in.Rows[r][_dc_password];
}
if (dataTable_in.Rows[r][_dc_ifapplication] == System.DBNull.Value)
{
_output[r].IFApplication_isNull = true;
}
else
{
_output[r].IFApplication = (int)dataTable_in.Rows[r][_dc_ifapplication];
}
_output[r].HasChanges = false;
}
return(_output);
}
/// <summary>
/// Selects CRD_User values from Database and assigns them to the appropriate DO_CRD_User property.
/// </summary>
/// <param name="IDUser_in">IDUser</param>
/// <param name="dbConnection_in">Database connection, making the use of Database Transactions possible on a sequence of operations across the same or multiple DataObjects</param>
/// <returns>null if CRD_User doesn't exists at Database</returns>
public static SO_CRD_User getObject(
long IDUser_in,
DBConnection dbConnection_in
) {
SO_CRD_User _output = null;
DBConnection _connection = (dbConnection_in == null)
? DO__utils.DBConnection_createInstance(
DO__utils.DBServerType,
DO__utils.DBConnectionstring,
DO__utils.DBLogfile
)
: dbConnection_in;
IDbDataParameter[] _dataparameters = new IDbDataParameter[] {
_connection.newDBDataParameter("IDUser_", DbType.Int64, ParameterDirection.InputOutput, IDUser_in, 0),
_connection.newDBDataParameter("Login_", DbType.AnsiString, ParameterDirection.Output, null, 255),
_connection.newDBDataParameter("Password_", DbType.AnsiString, ParameterDirection.Output, null, 255),
_connection.newDBDataParameter("IFApplication_", DbType.Int32, ParameterDirection.Output, null, 0)
};
_connection.Execute_SQLFunction("sp0_CRD_User_getObject", _dataparameters);
if (dbConnection_in == null) { _connection.Dispose(); }
if (_dataparameters[0].Value != DBNull.Value) {
_output = new SO_CRD_User();
if (_dataparameters[0].Value == System.DBNull.Value) {
_output.IDUser = 0L;
} else {
_output.IDUser = (long)_dataparameters[0].Value;
}
if (_dataparameters[1].Value == System.DBNull.Value) {
_output.Login = string.Empty;
} else {
_output.Login = (string)_dataparameters[1].Value;
}
if (_dataparameters[2].Value == System.DBNull.Value) {
_output.Password = string.Empty;
} else {
_output.Password = (string)_dataparameters[2].Value;
}
if (_dataparameters[3].Value == System.DBNull.Value) {
_output.IFApplication_isNull = true;
} else {
_output.IFApplication = (int)_dataparameters[3].Value;
}
_output.haschanges_ = false;
return _output;
}
return null;
}
/// <summary>
/// Updates CRD_User values on Database.
/// </summary>
/// <param name="forceUpdate_in">assign with True if you wish to force an Update (even if no changes have been made since last time getObject method was run) and False if not</param>
/// <param name="constraintExist_out">returns True if constraint exists and Update failed, and False if no constraint and Update was successful</param>
public static void updObject(
SO_CRD_User CRD_User_in,
bool forceUpdate_in,
out bool constraintExist_out
)
{
updObject(
CRD_User_in,
forceUpdate_in,
out constraintExist_out,
null
);
}
/// <summary>
/// Inserts CRD_User values into Database.
/// </summary>
/// <param name="selectIdentity_in">assign with True if you wish to retrieve insertion sequence/identity seed and with False if not</param>
/// <param name="constraintExist_out">returns True if constraint exists and insertion failed, and False if no constraint and insertion was successful</param>
/// <returns>insertion sequence/identity seed</returns>
public static long insObject(
SO_CRD_User CRD_User_in,
bool selectIdentity_in,
out bool constraintExist_out
)
{
return(insObject(
CRD_User_in,
selectIdentity_in,
out constraintExist_out,
null
));
}
/// <summary>
/// Updates CRD_User values on Database.
/// </summary>
/// <param name="forceUpdate_in">assign with True if you wish to force an Update (even if no changes have been made since last time getObject method was run) and False if not</param>
/// <param name="constraintExist_out">returns True if constraint exists and Update failed, and False if no constraint and Update was successful</param>
/// <param name="dbConnection_in">Database connection, making the use of Database Transactions possible on a sequence of operations across the same or multiple DataObjects</param>
public static void updObject(
SO_CRD_User CRD_User_in,
bool forceUpdate_in,
out bool constraintExist_out,
DBConnection dbConnection_in
)
{
if (forceUpdate_in || CRD_User_in.HasChanges)
{
DBConnection _connection = (dbConnection_in == null)
? DO__Utilities.DBConnection_createInstance(
DO__Utilities.DBServerType,
DO__Utilities.DBConnectionstring,
DO__Utilities.DBLogfile
)
: dbConnection_in;
IDbDataParameter[] _dataparameters = new IDbDataParameter[] {
_connection.newDBDataParameter("IDUser_", DbType.Int64, ParameterDirection.Input, CRD_User_in.IDUser, 0),
_connection.newDBDataParameter("Login_", DbType.AnsiString, ParameterDirection.Input, CRD_User_in.Login, 255),
_connection.newDBDataParameter("Password_", DbType.AnsiString, ParameterDirection.Input, CRD_User_in.Password, 255),
_connection.newDBDataParameter("IFApplication_", DbType.Int32, ParameterDirection.Input, CRD_User_in.IFApplication_isNull ? null : (object)CRD_User_in.IFApplication, 0),
_connection.newDBDataParameter("ConstraintExist_", DbType.Boolean, ParameterDirection.Output, null, 1)
};
_connection.Execute_SQLFunction(
"sp0_CRD_User_updObject",
_dataparameters
);
if (dbConnection_in == null)
{
_connection.Dispose();
}
constraintExist_out = (bool)_dataparameters[4].Value;
if (!constraintExist_out)
{
CRD_User_in.HasChanges = false;
}
}
else
{
constraintExist_out = false;
}
}
/// <summary>
/// Inserts CRD_User values into Database.
/// </summary>
/// <param name="selectIdentity_in">assign with True if you wish to retrieve insertion sequence/identity seed and with False if not</param>
/// <param name="constraintExist_out">returns True if constraint exists and insertion failed, and False if no constraint and insertion was successful</param>
/// <param name="dbConnection_in">Database connection, making the use of Database Transactions possible on a sequence of operations across the same or multiple DataObjects</param>
/// <returns>insertion sequence/identity seed</returns>
public static long insObject(
SO_CRD_User CRD_User_in,
bool selectIdentity_in,
out bool constraintExist_out,
DBConnection dbConnection_in
)
{
DBConnection _connection = (dbConnection_in == null)
? DO__Utilities.DBConnection_createInstance(
DO__Utilities.DBServerType,
DO__Utilities.DBConnectionstring,
DO__Utilities.DBLogfile
)
: dbConnection_in;
IDbDataParameter[] _dataparameters = new IDbDataParameter[] {
_connection.newDBDataParameter("IDUser_", DbType.Int64, ParameterDirection.Output, null, 0),
_connection.newDBDataParameter("Login_", DbType.AnsiString, ParameterDirection.Input, CRD_User_in.Login, 255),
_connection.newDBDataParameter("Password_", DbType.AnsiString, ParameterDirection.Input, CRD_User_in.Password, 255),
_connection.newDBDataParameter("IFApplication_", DbType.Int32, ParameterDirection.Input, CRD_User_in.IFApplication_isNull ? null : (object)CRD_User_in.IFApplication, 0),
_connection.newDBDataParameter("SelectIdentity_", DbType.Boolean, ParameterDirection.Input, selectIdentity_in, 1)
};
_connection.Execute_SQLFunction(
"sp0_CRD_User_insObject",
_dataparameters
);
if (dbConnection_in == null)
{
_connection.Dispose();
}
CRD_User_in.IDUser = (long)_dataparameters[0].Value;
constraintExist_out = (CRD_User_in.IDUser == -1L);
if (!constraintExist_out)
{
CRD_User_in.HasChanges = false;
}
return(CRD_User_in.IDUser);
}
/// <summary>
/// Selects CRD_User values from Database and assigns them to the appropriate DO_CRD_User property.
/// </summary>
/// <param name="IDUser_in">IDUser</param>
/// <param name="dbConnection_in">Database connection, making the use of Database Transactions possible on a sequence of operations across the same or multiple DataObjects</param>
/// <returns>null if CRD_User doesn't exists at Database</returns>
public static SO_CRD_User getObject(
long IDUser_in,
DBConnection dbConnection_in
)
{
SO_CRD_User _output = null;
DBConnection _connection = (dbConnection_in == null)
? DO__Utilities.DBConnection_createInstance(
DO__Utilities.DBServerType,
DO__Utilities.DBConnectionstring,
DO__Utilities.DBLogfile
)
: dbConnection_in;
IDbDataParameter[] _dataparameters = new IDbDataParameter[] {
_connection.newDBDataParameter("IDUser_", DbType.Int64, ParameterDirection.InputOutput, IDUser_in, 0),
_connection.newDBDataParameter("Login_", DbType.AnsiString, ParameterDirection.Output, null, 255),
_connection.newDBDataParameter("Password_", DbType.AnsiString, ParameterDirection.Output, null, 255),
_connection.newDBDataParameter("IFApplication_", DbType.Int32, ParameterDirection.Output, null, 0)
};
_connection.Execute_SQLFunction("sp0_CRD_User_getObject", _dataparameters);
if (dbConnection_in == null)
{
_connection.Dispose();
}
if (_dataparameters[0].Value != DBNull.Value)
{
_output = new SO_CRD_User();
if (_dataparameters[0].Value == System.DBNull.Value)
{
_output.IDUser = 0L;
}
else
{
_output.IDUser = (long)_dataparameters[0].Value;
}
if (_dataparameters[1].Value == System.DBNull.Value)
{
_output.Login = string.Empty;
}
else
{
_output.Login = (string)_dataparameters[1].Value;
}
if (_dataparameters[2].Value == System.DBNull.Value)
{
_output.Password = string.Empty;
}
else
{
_output.Password = (string)_dataparameters[2].Value;
}
if (_dataparameters[3].Value == System.DBNull.Value)
{
_output.IFApplication_isNull = true;
}
else
{
_output.IFApplication = (int)_dataparameters[3].Value;
}
_output.HasChanges = false;
return(_output);
}
return(null);
}
internal static void login(
SO_CRD_User user_in,
Guid sessionGuid_in,
string login_forLogPurposes_in,
string ip_forLogPurposes_in,
bool andCheckPassword_in,
string password_in,
out long idUser_out,
out string login_out,
out long[] idPermissions_out,
ref List<int> errorlist_ref
) {
//// NOTES:
//// - this method allows login without password (if andCheckPassword_in == false),
//// hence MUST NEVER be distributed (at least not directly)
idPermissions_out = null;
idUser_out = -1L;
login_out = "";
if (
(user_in != null)
&&
(
!andCheckPassword_in
||
SimpleHash.VerifyHash(
password_in,
SimpleHash.HashAlgotithm.SHA256,
user_in.Password
)
)
) {
login_out = user_in.Login;
#region login...
#region idPermissions_out = ...;
long _count;
SO_CRD_Permission[] _so_permissions
= DO_CRD_Permission.getRecord_byUser(
user_in.IDUser,
-1, -1, -1, out _count,
null
);
idPermissions_out = new long[_so_permissions.Length];
for (int i = 0; i < _so_permissions.Length; i++) {
idPermissions_out[i] = _so_permissions[i].IDPermission;
}
#endregion
if (UserSession.ContainsKey(sessionGuid_in)) {
Sessionuser _usersession = UserSession[sessionGuid_in];
if (_usersession.IDUser == user_in.IDUser) {
_usersession.Sessionstart = DateTime.Now;
_usersession.IDUser = user_in.IDUser;
_usersession.IDPermissions = idPermissions_out;
} else {
errorlist_ref.Add(ErrorType.authentication__guid_not_yours);
UserSession.Remove(sessionGuid_in);
return;
}
} else {
UserSession.Add(
sessionGuid_in,
new Sessionuser(
user_in.IDUser,
idPermissions_out,
user_in.IFApplication,
DateTime.Now
)
);
}
idUser_out = user_in.IDUser;
#endregion
} else {
errorlist_ref.Add(ErrorType.authentication__invalid_login);
#region SBO_LOG_Log.log(...);
SBO_LOG_Log.log(
null,
LogType.error,
ErrorType.authentication,
-1L,
(user_in == null) ? -1 : user_in.IFApplication,
"login:{0};password[0]:{1};ip:{2};",
new string[] {
login_forLogPurposes_in,
password_in.Length > 0 ? password_in.Substring(0, 1) : "",
ip_forLogPurposes_in
}
);
#endregion
}
}
/// <summary>
/// Updates CRD_User values on Database.
/// </summary>
/// <param name="forceUpdate_in">assign with True if you wish to force an Update (even if no changes have been made since last time getObject method was run) and False if not</param>
/// <param name="constraintExist_out">returns True if constraint exists and Update failed, and False if no constraint and Update was successful</param>
/// <param name="dbConnection_in">Database connection, making the use of Database Transactions possible on a sequence of operations across the same or multiple DataObjects</param>
public static void updObject(
SO_CRD_User CRD_User_in,
bool forceUpdate_in,
out bool constraintExist_out,
DBConnection dbConnection_in
) {
if (forceUpdate_in || CRD_User_in.haschanges_) {
DBConnection _connection = (dbConnection_in == null)
? DO__utils.DBConnection_createInstance(
DO__utils.DBServerType,
DO__utils.DBConnectionstring,
DO__utils.DBLogfile
)
: dbConnection_in;
IDbDataParameter[] _dataparameters = new IDbDataParameter[] {
_connection.newDBDataParameter("IDUser_", DbType.Int64, ParameterDirection.Input, CRD_User_in.IDUser, 0),
_connection.newDBDataParameter("Login_", DbType.AnsiString, ParameterDirection.Input, CRD_User_in.Login, 255),
_connection.newDBDataParameter("Password_", DbType.AnsiString, ParameterDirection.Input, CRD_User_in.Password, 255),
_connection.newDBDataParameter("IFApplication_", DbType.Int32, ParameterDirection.Input, CRD_User_in.IFApplication_isNull ? null : (object)CRD_User_in.IFApplication, 0),
_connection.newDBDataParameter("ConstraintExist_", DbType.Boolean, ParameterDirection.Output, null, 1)
};
_connection.Execute_SQLFunction(
"sp0_CRD_User_updObject",
_dataparameters
);
if (dbConnection_in == null) { _connection.Dispose(); }
constraintExist_out = (bool)_dataparameters[4].Value;
if (!constraintExist_out) {
CRD_User_in.haschanges_ = false;
}
} else {
constraintExist_out = false;
}
}
private static SO_CRD_User[] getRecord(
DataTable dataTable_in
) {
DataColumn _dc_iduser = null;
DataColumn _dc_login = null;
DataColumn _dc_password = null;
DataColumn _dc_ifapplication = null;
SO_CRD_User[] _output
= new SO_CRD_User[dataTable_in.Rows.Count];
for (int r = 0; r < dataTable_in.Rows.Count; r++) {
if (r == 0) {
_dc_iduser = dataTable_in.Columns["IDUser"];
_dc_login = dataTable_in.Columns["Login"];
_dc_password = dataTable_in.Columns["Password"];
_dc_ifapplication = dataTable_in.Columns["IFApplication"];
}
_output[r] = new SO_CRD_User();
if (dataTable_in.Rows[r][_dc_iduser] == System.DBNull.Value) {
_output[r].iduser_ = 0L;
} else {
_output[r].iduser_ = (long)dataTable_in.Rows[r][_dc_iduser];
}
if (dataTable_in.Rows[r][_dc_login] == System.DBNull.Value) {
_output[r].login_ = string.Empty;
} else {
_output[r].login_ = (string)dataTable_in.Rows[r][_dc_login];
}
if (dataTable_in.Rows[r][_dc_password] == System.DBNull.Value) {
_output[r].password_ = string.Empty;
} else {
_output[r].password_ = (string)dataTable_in.Rows[r][_dc_password];
}
if (dataTable_in.Rows[r][_dc_ifapplication] == System.DBNull.Value) {
_output[r].IFApplication_isNull = true;
} else {
_output[r].ifapplication_ = (int)dataTable_in.Rows[r][_dc_ifapplication];
}
_output[r].haschanges_ = false;
}
return _output;
}
/// <summary>
/// Updates CRD_User values on Database.
/// </summary>
/// <param name="forceUpdate_in">assign with True if you wish to force an Update (even if no changes have been made since last time getObject method was run) and False if not</param>
/// <param name="constraintExist_out">returns True if constraint exists and Update failed, and False if no constraint and Update was successful</param>
public static void updObject(
SO_CRD_User CRD_User_in,
bool forceUpdate_in,
out bool constraintExist_out
) {
updObject(
CRD_User_in,
forceUpdate_in,
out constraintExist_out,
null
);
}
/// <summary>
/// Inserts CRD_User values into Database.
/// </summary>
/// <param name="selectIdentity_in">assign with True if you wish to retrieve insertion sequence/identity seed and with False if not</param>
/// <param name="constraintExist_out">returns True if constraint exists and insertion failed, and False if no constraint and insertion was successful</param>
/// <param name="dbConnection_in">Database connection, making the use of Database Transactions possible on a sequence of operations across the same or multiple DataObjects</param>
/// <returns>insertion sequence/identity seed</returns>
public static long insObject(
SO_CRD_User CRD_User_in,
bool selectIdentity_in,
out bool constraintExist_out,
DBConnection dbConnection_in
) {
DBConnection _connection = (dbConnection_in == null)
? DO__utils.DBConnection_createInstance(
DO__utils.DBServerType,
DO__utils.DBConnectionstring,
DO__utils.DBLogfile
)
: dbConnection_in;
IDbDataParameter[] _dataparameters = new IDbDataParameter[] {
_connection.newDBDataParameter("IDUser_", DbType.Int64, ParameterDirection.Output, null, 0),
_connection.newDBDataParameter("Login_", DbType.AnsiString, ParameterDirection.Input, CRD_User_in.Login, 255),
_connection.newDBDataParameter("Password_", DbType.AnsiString, ParameterDirection.Input, CRD_User_in.Password, 255),
_connection.newDBDataParameter("IFApplication_", DbType.Int32, ParameterDirection.Input, CRD_User_in.IFApplication_isNull ? null : (object)CRD_User_in.IFApplication, 0),
_connection.newDBDataParameter("SelectIdentity_", DbType.Boolean, ParameterDirection.Input, selectIdentity_in, 1)
};
_connection.Execute_SQLFunction(
"sp0_CRD_User_insObject",
_dataparameters
);
if (dbConnection_in == null) { _connection.Dispose(); }
CRD_User_in.IDUser = (long)_dataparameters[0].Value;
constraintExist_out = (CRD_User_in.IDUser == -1L);
if (!constraintExist_out) {
CRD_User_in.haschanges_ = false;
}
return CRD_User_in.IDUser;
}
/// <summary>
/// Inserts CRD_User values into Database.
/// </summary>
/// <param name="selectIdentity_in">assign with True if you wish to retrieve insertion sequence/identity seed and with False if not</param>
/// <param name="constraintExist_out">returns True if constraint exists and insertion failed, and False if no constraint and insertion was successful</param>
/// <returns>insertion sequence/identity seed</returns>
public static long insObject(
SO_CRD_User CRD_User_in,
bool selectIdentity_in,
out bool constraintExist_out
) {
return insObject(
CRD_User_in,
selectIdentity_in,
out constraintExist_out,
null
);
}
public static void ChangePassword(
string sessionGuid_in,
string ip_forLogPurposes_in,
string password_old_in,
string password_new_in,
out int[] errors_out
)
{
List <int> _errorlist;
Guid _sessionguid;
Sessionuser _sessionuser;
#region check...
if (!SBO_CRD_Authentication.isSessionGuid_valid(
sessionGuid_in,
ip_forLogPurposes_in,
out _sessionguid,
out _sessionuser,
out _errorlist,
out errors_out
))
{
//// no need!
//errors_out = _errors.ToArray();
return;
}
SO_CRD_User _user = DO_CRD_User.getObject(_sessionuser.IDUser);
if (_user == null)
{
_errorlist.Add(ErrorType.authentication__no_such_user);
UserSession.Remove(_sessionguid);
errors_out = _errorlist.ToArray();
return;
}
#endregion
bool _constraint;
if (
!SimpleHash.VerifyHash(
password_old_in,
SimpleHash.HashAlgotithm.SHA256,
_user.Password
)
)
{
_errorlist.Add(ErrorType.authentication__change_password__wrong_password);
}
else if (string.IsNullOrEmpty(password_new_in))
{
_errorlist.Add(ErrorType.authentication__change_password__invalid_password);
}
else
{
_user.Password
= SimpleHash.ComputeHash(
password_new_in,
SimpleHash.HashAlgotithm.SHA256,
null
);
DO_CRD_User.updObject(
_user,
true,
out _constraint
);
}
errors_out = _errorlist.ToArray();
}
internal static void login(
SO_CRD_User user_in,
Guid sessionGuid_in,
string login_forLogPurposes_in,
string ip_forLogPurposes_in,
bool andCheckPassword_in,
string password_in,
out long idUser_out,
out string login_out,
out long[] idPermissions_out,
ref List <int> errorlist_ref
)
{
//// NOTES:
//// - this method allows login without password (if andCheckPassword_in == false),
//// hence MUST NEVER be distributed (at least not directly)
idPermissions_out = null;
idUser_out = -1L;
login_out = "";
if (
(user_in != null)
&&
(
!andCheckPassword_in
||
SimpleHash.VerifyHash(
password_in,
SimpleHash.HashAlgotithm.SHA256,
user_in.Password
)
)
)
{
login_out = user_in.Login;
#region login...
#region idPermissions_out = ...;
long _count;
SO_CRD_Permission[] _so_permissions
= DO_CRD_Permission.getRecord_byUser(
user_in.IDUser,
-1, -1, -1, out _count,
null
);
idPermissions_out = new long[_so_permissions.Length];
for (int i = 0; i < _so_permissions.Length; i++)
{
idPermissions_out[i] = _so_permissions[i].IDPermission;
}
#endregion
if (UserSession.ContainsKey(sessionGuid_in))
{
Sessionuser _usersession = UserSession[sessionGuid_in];
if (_usersession.IDUser == user_in.IDUser)
{
_usersession.Sessionstart = DateTime.Now;
_usersession.IDUser = user_in.IDUser;
_usersession.IDPermissions = idPermissions_out;
}
else
{
errorlist_ref.Add(ErrorType.authentication__guid_not_yours);
UserSession.Remove(sessionGuid_in);
return;
}
}
else
{
UserSession.Add(
sessionGuid_in,
new Sessionuser(
user_in.IDUser,
idPermissions_out,
user_in.IFApplication,
DateTime.Now
)
);
}
idUser_out = user_in.IDUser;
#endregion
}
else
{
errorlist_ref.Add(ErrorType.authentication__invalid_login);
#region SBO_LOG_Log.log(...);
SBO_LOG_Log.log(
null,
LogType.error,
ErrorType.authentication,
-1L,
(user_in == null) ? -1 : user_in.IFApplication,
"login:{0};password[0]:{1};ip:{2};",
new string[] {
login_forLogPurposes_in,
password_in.Length > 0 ? password_in.Substring(0, 1) : "",
ip_forLogPurposes_in
}
);
#endregion
}
}
