private bool AddToPasswordHistory(string userName, string newPassword, int historyCount)
{
using (DbCommand command = DatabaseProvider.DbProviderFactory.CreateCommand())
{
object result;
InitializeGetHistoryCount(command, userName);
result = DatabaseProvider.ExecuteScalar(command);
if (result != null && Convert.ToInt32(result) >= historyCount)
{
int count = Convert.ToInt32(result) - historyCount;
int itemCount = 0;
InitializeGetUserPasswordHistory(command, userName);
using (var reader = DatabaseProvider.ExecuteReader(command))
{
while (reader.Read())
{
if (itemCount <= count)
{
using (DbCommand delCommand = DatabaseProvider.DbProviderFactory.CreateCommand())
{
InitializeDeletePasswordHistory(delCommand, reader.GetColumnValue <long>("Id"));
DatabaseProvider.ExecuteNonQuery(delCommand);
}
}
itemCount++;
}
}
}
InitializeAddToPasswordHistory(command, userName, newPassword);
return(DatabaseProvider.ExecuteNonQuery(command) > 0);
}
}
public string IntGetuserType(string userName)
{
userName = FromInputUserName(userName);
try
{
object result;
using (var command = DatabaseProvider.DbProviderFactory.CreateCommand())
{
InitializeIsValidateOnDomainCommand(command, userName);
result = DatabaseProvider.ExecuteScalar(command);
if (null != result)
{
var typ = UserNameResolver.DecodeType(result.ToString());
return(typ);
}
}
}
catch {
}
return(null);
}
public virtual bool IsUserPasswordExpired(string username)
{
username = FromInputUserName(username);
using (var command = DatabaseProvider.DbProviderFactory.CreateCommand())
{
object result;
DateTime?expireDate = null;
InitializeIsUserPasswordExpiredCommand(command, username);
result = DatabaseProvider.ExecuteScalar(command);
if (result == DBNull.Value)
{
return(false);
}
if (result != null)
{
DateTime value;
if (DateTime.TryParse(result.ToString(), out value))
{
expireDate = value;
}
}
return(ReturnFromScalarResult(expireDate));
}
}
public bool IsForwarded(string sopInstanceUID)
{
using (DbCommand command = DatabaseProvider.DbProviderFactory.CreateCommand( ))
{
object value;
InitializeIsForwardedCommand(command, sopInstanceUID);
value = DatabaseProvider.ExecuteScalar(command);
if (value != null && value != DBNull.Value)
{
int count;
bool exists;
if (int.TryParse(value.ToString( ), out count))
{
return(count > 0);
}
else if (bool.TryParse(value.ToString( ), out exists))
{
return(exists);
}
else
{
return(!string.IsNullOrEmpty(value.ToString( )));
}
}
}
return(false);
}
public virtual bool IsPreviousPassword(string userName, SecureString password)
{
userName = FromInputUserName(userName);
using (DbCommand command = DatabaseProvider.DbProviderFactory.CreateCommand())
{
object result;
InitializeIsPreviousPassword(command, userName, GetHashedPassword(password));
result = DatabaseProvider.ExecuteScalar(command);
return(ReturnFromScalarResult(result));
}
}
public virtual bool UserExists(string userName)
{
var mappedUserName = FromInputUserName(userName);
using (var command = DatabaseProvider.DbProviderFactory.CreateCommand())
{
InitializeUserExistsCommand(command, userName);
var result = DatabaseProvider.ExecuteScalar(command);
//TODO: slight connection leak, scalar doesnt close the connection afterward
return ReturnFromScalarResult(result);
}
}
public long GetResetCount(DateRange range)
{
using (DbCommand command = DatabaseProvider.DbProviderFactory.CreateCommand())
{
object value;
InitializeGetResetCountCommand(command, range);
value = DatabaseProvider.ExecuteScalar(command);
if (value != null)
{
return(Convert.ToInt64(value));
}
}
return(0);
}
public virtual bool IsAdmin(string userName)
{
userName = FromInputUserName(userName);
object result;
using (var command = DatabaseProvider.DbProviderFactory.CreateCommand())
{
InitializeIsAdminCommand(command, userName);
result = DatabaseProvider.ExecuteScalar(command);
return(ReturnFromScalarResult(result));
}
}
public void Count_Active_Test_Plans()
{
if (_telemetry == null)
{
return;
}
string scope = "Database";
Dictionary <string, string> parameters = new Dictionary <string, string>();
using (DatabaseProvider provider = DatabaseProvider.Create("CountActiveTestPlans.sql", Program.Context.ConnectionString))
{
int activeTestPlans = (int)provider.ExecuteScalar();
parameters.Add("Database", provider.Database);
TrackMetric(scope, FormatMetricName(scope, "Active_Test_Plans"), activeTestPlans, parameters);
}
}
public long GetForwardCount()
{
using (DbCommand command = DatabaseProvider.DbProviderFactory.CreateCommand())
{
object value = null;
InitializeGetForwardCountCommand(command);
try
{
value = DatabaseProvider.ExecuteScalar(command);
}
catch { }
if (value != null)
{
return(Convert.ToInt64(value));
}
}
return(0);
}
public virtual bool SetUserPassword(string userName, SecureString newPassword, DateTime?expireDate, int historyCount)
{
userName = FromInputUserName(userName);
string oldPassword = string.Empty;
bool ret;
if (historyCount > 0)
{
using (DbCommand c = DatabaseProvider.DbProviderFactory.CreateCommand())
{
object result;
InitializeGetUserPassword(c, userName);
result = DatabaseProvider.ExecuteScalar(c);
oldPassword = result != null?result.ToString() : string.Empty;
}
}
if (expireDate.HasValue)
{
using (DbCommand command = DatabaseProvider.DbProviderFactory.CreateCommand())
{
InitializeSetUserPasswordExpired(command, userName, GetHashedPassword(newPassword), expireDate);
ret = DatabaseProvider.ExecuteNonQuery(command) > 0;
}
}
else
{
ret = SetUserPassword(userName, newPassword);
}
if (ret && historyCount > 0 && !string.IsNullOrEmpty(oldPassword))
{
AddToPasswordHistory(userName, oldPassword, historyCount);
}
return(ret);
}
