public int[] GetObjectsByOptionalData(ObjectType objectType, ObjectOptionalDataType dataType, string data)
{
List <int> objectIds = new List <int>();
using (DbConnection connection = GetMySqlDbConnection())
{
connection.Open();
DbCommand command =
GetDbCommand(
"SELECT" + objectOptionalDataFieldSequence + "WHERE ObjectTypes.Name='" + objectType + "' " + // objectType is an enum
"AND ObjectOptionalDataTypes.Name='" + dataType + "' " + // dataType is an enum; not user input
"AND ObjectOptionalData.Data=@dataString", connection);
AddParameterWithName(command, "dataString", data);
using (DbDataReader reader = command.ExecuteReader())
{
while (reader.Read())
{
objectIds.Add(reader.GetInt32(1));
}
return(objectIds.ToArray());
}
}
}
public int[] GetObjectsByOptionalData(ObjectType objectType, ObjectOptionalDataType dataType, string data)
{
List <int> objectIds = new List <int>();
using (DbConnection connection = GetMySqlDbConnection())
{
connection.Open();
DbCommand command =
GetDbCommand(
"SELECT" + objectOptionalDataFieldSequence + "WHERE ObjectTypes.Name='" + objectType + "' " +
"AND ObjectOptionalDataTypes.Name='" + dataType + "' " +
"AND ObjectOptionalData.Data='" + data.Replace("'", "''") + "';", connection);
using (DbDataReader reader = command.ExecuteReader())
{
while (reader.Read())
{
objectIds.Add(reader.GetInt32(1));
}
return(objectIds.ToArray());
}
}
}
public int[] GetObjectsByOptionalData (ObjectType objectType, ObjectOptionalDataType dataType, string data)
{
List<int> objectIds = new List<int>();
using (DbConnection connection = GetMySqlDbConnection())
{
connection.Open();
DbCommand command =
GetDbCommand(
"SELECT" + objectOptionalDataFieldSequence + "WHERE ObjectTypes.Name='" + objectType.ToString() + "' " +
"AND ObjectOptionalDataTypes.Name='" + dataType.ToString() + "' " +
"AND ObjectOptionalData.Data='" + data.Replace("'", "''") + "';", connection);
using (DbDataReader reader = command.ExecuteReader())
{
while (reader.Read())
{
objectIds.Add(reader.GetInt32(1));
}
return objectIds.ToArray();
}
}
}
public bool HasData(ObjectOptionalDataType dataType)
{
if (OptionalData.ContainsKey(dataType))
{
return(true);
}
return(false);
}
//static private IHasIdentity ConstructObject (ObjectType objectType, int objectId)
//{
// switch (objectType)
// {
// case ObjectType.Person:
// return Person.FromIdentity(objectId);
// case ObjectType.FinancialAccount:
// return FinancialAccount.FromIdentity(objectId);
// default:
// throw new NotImplementedException(
// "Unimplemented ObjectType in ObjectOptionalData.ConstructObject: " + objectType.ToString());
// }
//}
// Optional data support
public string GetOptionalDataString(ObjectOptionalDataType key)
{
if (HasData(key))
{
return(this[key]);
}
return(string.Empty);
}
// All bools default to false
public bool GetOptionalDataBool(ObjectOptionalDataType key)
{
if (HasData(key))
{
return(this[key] == "1" ? true : false);
}
return(false);
}
public Int64 GetOptionalDataInt64(ObjectOptionalDataType key)
{
if (HasData(key))
{
return(Int64.Parse(this[key]));
}
return(0);
}
// All ints default to 0
public int GetOptionalDataInt(ObjectOptionalDataType key)
{
if (HasData(key))
{
return(Int32.Parse(this[key]));
}
return(0);
}
//static private IHasIdentity ConstructObject (ObjectType objectType, int objectId)
//{
// switch (objectType)
// {
// case ObjectType.Person:
// return Person.FromIdentity(objectId);
// case ObjectType.FinancialAccount:
// return FinancialAccount.FromIdentity(objectId);
// default:
// throw new NotImplementedException(
// "Unimplemented ObjectType in ObjectOptionalData.ConstructObject: " + objectType.ToString());
// }
//}
// Optional data support
public string GetOptionalDataString (ObjectOptionalDataType key)
{
if (this.HasData(key))
{
return this[key];
}
return string.Empty;
}
public bool HasData (ObjectOptionalDataType dataType)
{
if (this.OptionalData.ContainsKey(dataType))
{
return true;
}
else
{
return false;
}
}
public void SetOptionalData(ObjectOptionalDataType dataType, string data)
{
SwarmDb.GetDatabaseForWriting().SetObjectOptionalData(this.forObject, dataType, data);
if (data == null && OptionalData.ContainsKey(dataType))
{
OptionalData.Remove(dataType);
}
else
{
this[dataType] = data;
}
}
public string this[ObjectOptionalDataType dataType]
{
get
{
if (this.OptionalData.ContainsKey(dataType))
{
return this.OptionalData[dataType];
}
return null;
}
set
{
SwarmDb.GetDatabaseForWriting().SetObjectOptionalData((IHasIdentity)forObject, dataType, value);
this.OptionalData[dataType] = value;
}
}
public void SetObjectOptionalData(IHasIdentity thisObject, ObjectOptionalDataType dataType, string data)
{
using (DbConnection connection = GetMySqlDbConnection())
{
connection.Open();
DbCommand command = GetDbCommand("SetObjectOptionalData", connection);
command.CommandType = CommandType.StoredProcedure;
AddParameterWithName(command, "objectType", GetObjectTypeForObject(thisObject).ToString());
AddParameterWithName(command, "objectId", thisObject.Identity);
AddParameterWithName(command, "objectOptionalDataType", dataType.ToString());
AddParameterWithName(command, "data", data);
command.ExecuteNonQuery();
}
}
protected static Organization FromOptionalDataString(ObjectOptionalDataType dataType, string data)
{
int[] organizationIds = SwarmDb.GetDatabaseForReading().GetObjectsByOptionalData(ObjectType.Organization, dataType, data.Trim());
if (organizationIds.Length < 1)
{
return(null);
}
else if (organizationIds.Length == 1)
{
return(Organization.FromIdentity(organizationIds[0]));
}
else
{
throw new InvalidOperationException("Invalid state: multiple organizations with same " + dataType.ToString());
}
}
public string this [ObjectOptionalDataType dataType]
{
get
{
if (OptionalData.ContainsKey(dataType))
{
return(OptionalData[dataType]);
}
return(null);
}
set
{
SwarmDb.GetDatabaseForWriting().SetObjectOptionalData(this.forObject, dataType, value);
OptionalData[dataType] = value;
}
}
public BasicObjectOptionalData GetObjectOptionalData(IHasIdentity forObject)
{
Dictionary <ObjectOptionalDataType, string> initialData = new Dictionary <ObjectOptionalDataType, string>();
ObjectType objectType = GetObjectTypeForObject(forObject);
int objectId = forObject.Identity;
using (DbConnection connection = GetMySqlDbConnection())
{
connection.Open();
DbCommand command =
GetDbCommand(
"SELECT" + objectOptionalDataFieldSequence + "WHERE ObjectTypes.Name='" + objectType + "' " +
"AND ObjectOptionalData.ObjectId=" + objectId + ";", connection);
using (DbDataReader reader = command.ExecuteReader())
{
while (reader.Read())
{
string objectOptionalDataTypeString = reader.GetString(2);
string data = reader.GetString(3);
try
{
ObjectOptionalDataType objectOptionalDataType =
(ObjectOptionalDataType)
Enum.Parse(typeof(ObjectOptionalDataType), objectOptionalDataTypeString);
initialData[objectOptionalDataType] = data;
}
catch (Exception)
{
// Ignore unknown enums at this point - too many disconnects between v4 and v5 -Rick
}
}
return(new BasicObjectOptionalData(objectType, objectId, initialData));
}
}
}
public void SetOptionalDataInt (ObjectOptionalDataType key, int value)
{
SetOptionalData(key, value.ToString());
}
public void SetOptionalDataBool (ObjectOptionalDataType key, bool value)
{
SetOptionalData(key, value ? "1" : "0");
}
public void SetOptionalDataBool(ObjectOptionalDataType key, bool value)
{
SetOptionalData(key, value ? "1" : "0");
}
public void SetOptionalData (ObjectOptionalDataType dataType, string data)
{
SwarmDb.GetDatabaseForWriting().SetObjectOptionalData((IHasIdentity)forObject, dataType, data);
if (data == null && this.OptionalData.ContainsKey(dataType))
this.OptionalData.Remove(dataType);
else
this[dataType] = data;
}
public void SetOptionalDataInt64(ObjectOptionalDataType key, Int64 value)
{
SetOptionalData(key, value.ToString());
}
public void SetOptionalDataString (ObjectOptionalDataType key, string value)
{
this.SetOptionalData(key, value);
}
public static People FromOptionalData(ObjectOptionalDataType dataType, string data)
{
return
(FromIdentities(SwarmDb.GetDatabaseForReading()
.GetObjectsByOptionalData(ObjectType.Person, dataType, data)));
}
// All ints default to 0
public int GetOptionalDataInt (ObjectOptionalDataType key)
{
if (this.HasData(key))
{
return Int32.Parse(this[key]);
}
return 0;
}
// All bools default to false
public bool GetOptionalDataBool (ObjectOptionalDataType key)
{
if (this.HasData(key))
{
return (this[key] == "1" ? true : false);
}
return false;
}
public static void Migrate()
{
SwarmDb db = SwarmDb.GetDatabaseForAdmin();
using (DbConnection connection = db.GetSqlServerDbConnection())
{
connection.Open();
DbCommand command = connection.CreateCommand();
command.CommandText =
"SELECT PeopleOptionalData.PersonId, PersonOptionalDataTypes.Name AS PersonOptionalDataType, " +
"PeopleOptionalData.Data FROM PeopleOptionalData,PersonOptionalDataTypes " +
"WHERE PeopleOptionalData.PersonOptionalDataTypeId=PersonOptionalDataTypes.PersonOptionalDataTypeId ORDER BY PersonId";
using (DbDataReader reader = command.ExecuteReader())
{
int lastPersonId = 0;
while (reader.Read())
{
int personId = reader.GetInt32(0);
string personOptionalDataTypeString = reader.GetString(1);
string data = reader.GetString(2);
string displayData = data;
if (displayData.Length > 40)
{
displayData = displayData.Substring(0, 40);
}
displayData = displayData.Replace("\r\n", "#");
PersonOptionalDataKey key =
(PersonOptionalDataKey)
Enum.Parse(typeof(PersonOptionalDataKey), personOptionalDataTypeString);
// Display
Person person = null;
try
{
person = Person.FromIdentity(personId);
}
catch (Exception)
{
Console.WriteLine("PERSON #{0} IS NOT IN DATABASE", personId);
}
if (person != null)
{
if (personId != lastPersonId)
{
Console.WriteLine(person.Canonical + " -- ");
lastPersonId = personId;
}
ObjectOptionalDataType dataType =
(ObjectOptionalDataType)
Enum.Parse(typeof(ObjectOptionalDataType), personOptionalDataTypeString);
Console.WriteLine(" -- {0,-20} {1}", dataType.ToString(), displayData);
if (data.Trim().Length > 0)
{
db.SetObjectOptionalData(person, dataType, data);
}
}
}
}
}
}
public void SetOptionalDataString(ObjectOptionalDataType key, string value)
{
SetOptionalData(key, value);
}
public void SetObjectOptionalData (IHasIdentity thisObject, ObjectOptionalDataType dataType, string data)
{
using (DbConnection connection = GetMySqlDbConnection())
{
connection.Open();
DbCommand command = GetDbCommand("SetObjectOptionalData", connection);
command.CommandType = CommandType.StoredProcedure;
AddParameterWithName(command, "objectType", GetObjectTypeForObject(thisObject).ToString());
AddParameterWithName(command, "objectId", thisObject.Identity);
AddParameterWithName(command, "objectOptionalDataType", dataType.ToString());
AddParameterWithName(command, "data", data);
command.ExecuteNonQuery();
}
}
private static FinancialAccounts FromOptionalData(ObjectOptionalDataType dataType, string data)
{
return
(FromIdentities(SwarmDb.GetDatabaseForReading()
.GetObjectsByOptionalData(ObjectType.FinancialAccount, dataType, data)));
}
internal PersonQuarantine(Person person, ObjectOptionalDataType quarantineType) // internal: can only be constructed in assembly
{
this._person = person;
this._quarantineType = quarantineType;
}
