///<summary>Generates a random primary key without using the cache.</summary>
public static long GetKeyNoCache(string tablename, string field)
{
long rangeStart = 10000;
long rangeEnd = long.MaxValue;
long server_id = GetServer_id();
if (server_id != 0)
{
ReplicationServer thisServer = ReplicationServers.GetServer(server_id);
if (thisServer != null && thisServer.RangeEnd - thisServer.RangeStart >= 999999)
{
rangeStart = thisServer.RangeStart;
rangeEnd = thisServer.RangeEnd;
}
}
long span = rangeEnd - rangeStart;
long rndLong = (long)(ODRandom.NextDouble() * span) + rangeStart;
while (rndLong == 0 ||
rndLong < rangeStart ||
rndLong > rangeEnd ||
KeyInUse(tablename, field, rndLong))
{
rndLong = (long)(ODRandom.NextDouble() * span) + rangeStart;
}
return(rndLong);
}
///<summary>Generates a random primary key. Tests to see if that key already exists before returning it for use. The range of returned values is greater than 0, and less than or equal to 9223372036854775807.</summary>
public static long GetKey(string tablename, string field)
{
//No need to check RemotingRole; no call to db.
//establish the range for this server
long rangeStart = 10000;
long rangeEnd = long.MaxValue;
//the following line triggers a separate call to db if server_id=-1. Must be cap.
if (Server_id != 0) //if it IS 0, then there is no server_id set.
{
ReplicationServer thisServer = GetFirstOrDefault(x => x.ServerId == Server_id);
if (thisServer != null) //a ReplicationServer row was found for this server_id
{
if (thisServer.RangeEnd - thisServer.RangeStart >= 999999) //and a valid range was entered that was at least 1,000,000
{
rangeStart = thisServer.RangeStart;
rangeEnd = thisServer.RangeEnd;
}
}
}
long rndLong;
long span = rangeEnd - rangeStart;
do
{
rndLong = (long)(ODRandom.NextDouble() * span) + rangeStart;
}while(rndLong == 0 ||
rndLong < rangeStart ||
rndLong > rangeEnd ||
KeyInUse(tablename, field, rndLong));
return(rndLong);
}
///<summary>Creates a username that is not yet in use. Should typically call UserWebs.GetNewPatientPortalCredentials() instead.
///If you are not inserting the name into UserWeb immediately then listExcludedNames should persist across multiple calls.</summary>
public static string CreateUserNameFromPat(Patient pat, UserWebFKeyType fkeyType, List <string> listExcludedNames)
{
//No need to check RemotingRole; no call to db.
string retVal = "";
bool isUserNameOk = false;
int i = 0;
while (!isUserNameOk)
{
retVal = pat.FName + ODRandom.Next(100, 100000);
if (!UserWebs.UserNameExists(retVal, fkeyType))
{
if (!listExcludedNames.Contains(retVal))
{
isUserNameOk = true;
}
}
if (i > 1000)
{
throw new CodeBase.ODException(Lans.g("UserWebs", "Unable to create username for patient."));
}
i++;
}
return(retVal);
}
///<summary>Generates a random password 8 char long containing at least one uppercase, one lowercase, and one number.</summary>
public static string GenerateRandomPassword(int length)
{
//No need to check RemotingRole; no call to db.
//Chracters like o(letter O), 0 (Zero), l (letter l), 1 (one) etc are avoided because they can be ambigious.
string PASSWORD_CHARS_LCASE = "abcdefgijkmnopqrstwxyz";
string PASSWORD_CHARS_UCASE = "ABCDEFGHJKLMNPQRSTWXYZ";
string PASSWORD_CHARS_NUMERIC = "23456789";
//Create a local array containing supported password characters grouped by types.
char[][] charGroups = new char[][] {
PASSWORD_CHARS_LCASE.ToCharArray(),
PASSWORD_CHARS_UCASE.ToCharArray(),
PASSWORD_CHARS_NUMERIC.ToCharArray(),
};
//Use this array to track the number of unused characters in each character group.
int[] charsLeftInGroup = new int[charGroups.Length];
//Initially, all characters in each group are not used.
for (int i = 0; i < charsLeftInGroup.Length; i++)
{
charsLeftInGroup[i] = charGroups[i].Length;
}
//Use this array to track (iterate through) unused character groups.
int[] leftGroupsOrder = new int[charGroups.Length];
//Initially, all character groups are not used.
for (int i = 0; i < leftGroupsOrder.Length; i++)
{
leftGroupsOrder[i] = i;
}
//This array will hold password characters.
char[] password = new char[length];
//Index of the next character to be added to password.
int nextCharIdx;
//Index of the next character group to be processed.
int nextGroupIdx;
//Index which will be used to track not processed character groups.
int nextLeftGroupsOrderIdx;
//Index of the last non-processed character in a group.
int lastCharIdx;
//Index of the last non-processed group.
int lastLeftGroupsOrderIdx = leftGroupsOrder.Length - 1;
//Generate password characters one at a time.
for (int i = 0; i < password.Length; i++)
{
//If only one character group remained unprocessed, process it;
//otherwise, pick a random character group from the unprocessed
//group list. To allow a special character to appear in the
//first position, increment the second parameter of the Next
//function call by one, i.e. lastLeftGroupsOrderIdx + 1.
if (lastLeftGroupsOrderIdx == 0)
{
nextLeftGroupsOrderIdx = 0;
}
else
{
nextLeftGroupsOrderIdx = ODRandom.Next(0, lastLeftGroupsOrderIdx);
}
//Get the actual index of the character group, from which we will
//pick the next character.
nextGroupIdx = leftGroupsOrder[nextLeftGroupsOrderIdx];
//Get the index of the last unprocessed characters in this group.
lastCharIdx = charsLeftInGroup[nextGroupIdx] - 1;
//If only one unprocessed character is left, pick it; otherwise,
//get a random character from the unused character list.
if (lastCharIdx == 0)
{
nextCharIdx = 0;
}
else
{
nextCharIdx = ODRandom.Next(0, lastCharIdx + 1);
}
//Add this character to the password.
password[i] = charGroups[nextGroupIdx][nextCharIdx];
//If we processed the last character in this group, start over.
if (lastCharIdx == 0)
{
charsLeftInGroup[nextGroupIdx] = charGroups[nextGroupIdx].Length;
//There are more unprocessed characters left.
}
else
{
//Swap processed character with the last unprocessed character
//so that we don't pick it until we process all characters in
//this group.
if (lastCharIdx != nextCharIdx)
{
char temp = charGroups[nextGroupIdx][lastCharIdx];
charGroups[nextGroupIdx][lastCharIdx] = charGroups[nextGroupIdx][nextCharIdx];
charGroups[nextGroupIdx][nextCharIdx] = temp;
}
//Decrement the number of unprocessed characters in
//this group.
charsLeftInGroup[nextGroupIdx]--;
}
//If we processed the last group, start all over.
if (lastLeftGroupsOrderIdx == 0)
{
lastLeftGroupsOrderIdx = leftGroupsOrder.Length - 1;
//There are more unprocessed groups left.
}
else
{
//Swap processed group with the last unprocessed group
//so that we don't pick it until we process all groups.
if (lastLeftGroupsOrderIdx != nextLeftGroupsOrderIdx)
{
int temp = leftGroupsOrder[lastLeftGroupsOrderIdx];
leftGroupsOrder[lastLeftGroupsOrderIdx] =
leftGroupsOrder[nextLeftGroupsOrderIdx];
leftGroupsOrder[nextLeftGroupsOrderIdx] = temp;
}
//Decrement the number of unprocessed groups.
lastLeftGroupsOrderIdx--;
}
}
//Convert password characters into a string and return the result.
return(new string(password));
}
