protected override void SynchronizeImpl()
{
ISerializableObject source = StateOwner.SourceObject;
ISerializableObject sink = StateOwner.SinkSerializer.CreateISerializableObject(StateOwner.SynchronizedType);
CopyUtils.PlainCopy(StateOwner.SinkSerializer, KeyCarrier, sink, new FieldLock(source.GetType()), true);
CopyUtils.PlainCopy(StateOwner.SinkSerializer, source, sink, new FieldLock(source.GetType()), false);
StateOwner.SinkSerializer.Connector.InsertPlain(sink);
StateOwner.SinkObject = sink;
SyncItem si1 = StateOwner.SyncSerializer.CreateISerializableObject <SyncItem>();
SyncItem si2 = StateOwner.SyncSerializer.CreateISerializableObject <SyncItem>();
si1.SyncGuid = AttributeWorker.RowGuid(source);
si2.SyncGuid = AttributeWorker.RowGuid(sink);
si1.ClassID = source.GetType().Name;
si2.ClassID = source.GetType().Name;
si1.Hashcode = SyncContainer.ComputeHashCode(StateOwner.SourceSerializer.Target, source);
si2.Hashcode = SyncContainer.ComputeHashCode(StateOwner.SinkSerializer.Target, sink);
si1.CounterPart = si2;
StateOwner.SyncSerializer.Connector.Save(si1);
StateOwner.SyncSerializer.ConnectOneToOne(si1, si2);
StateOwner.SyncSerializer.Connector.Save(si2);
StateOwner.SyncSerializer.ConnectOneToOne(si2, si1);
StateOwner.SyncSerializer.Connector.Save(si1);
StateOwner.UpdateFieldStates(StateOwner.SourceSerializer.Target, si1, source);//Deaktiviert
StateOwner.UpdateFieldStates(StateOwner.SinkSerializer.Target, si2, sink);
}
private void update(ListContainer sc)
{
try
{
ISerializableObject sourceObject = sc.iso;
SyncItem si = FetchSyncItem(sourceObject.Rowguid);
Guid sinkGuid = sourceObject.Rowguid;
ISerializableObject sinkObject = FetchObject(sinkSerializer, sinkGuid, sourceObject.GetType());
if (LookupSynchronizationInformation.getImageClasses().Contains(sourceObject.GetType()))
{
//Bilder können nicht aktualisiert werden
ignore(sc);
return;
}
else
{
copyToSinkObject(sourceObject, sinkObject);
adjustAutoIncKeys(sinkObject);//Kann man verhindern, dass "richtige" Schlüssel zunächst falsch überschrieben und dann wieder richt zurücküberschrieben werden?
}
sinkSerializer.Connector.UpdatePlain(sinkObject);
syncSerializer.Connector.Save(si);
sinkObject = FetchObject(sinkSerializer, sinkGuid, sourceObject.GetType());
sc.State = SyncStates_Enum.SynchronizedState;
}
catch (Exception e)
{
MessageBox.Show("Update Failure: " + e.Message);
}
}
public static String ToStringHelper(ISerializableObject iso, int width)
{
FieldInfo[] fis = iso.GetType().GetFields(BindingFlags.NonPublic | BindingFlags.Instance);
StringBuilder b = new StringBuilder();
b.Append(System.Environment.NewLine);
b.Append("-----------------------------------").Append(System.Environment.NewLine);
b.Append(iso.GetType().Name).Append(System.Environment.NewLine);
b.Append("-----------------------------------").Append(System.Environment.NewLine);
foreach (FieldInfo fi in fis)
{
Object tmp = fi.GetValue(iso);
if (tmp == null)
{
tmp = "null";
}
if (AttributeWorker.IsRelationField(fi))
{
continue;
}
b.Append(fi.Name).Append(" = ").Append(tmp).Append(System.Environment.NewLine);
}
return(b.ToString());
}
internal virtual String Delete(ISerializableObject iso)
{
AttributeWorker w = AttributeWorker.GetInstance(Target);
StringBuilder sql = new StringBuilder();
sql.Append("DELETE FROM ").Append(w.GetTableMapping(iso.GetType(), _praefix));
sql.Append(" WHERE ");
FieldInfo[] fis = AttributeWorker.RetrieveAllFields(iso.GetType());
bool start = true;
foreach (FieldInfo fi in fis)
{
if (w.IsID(fi))
{
String col = w.GetColumnMapping(fi);
Object val = fi.GetValue(iso);
if (val == null)
{
throw new SerializerException("Not deletable ...");
}
if (!start)
{
sql.Append(" AND ");
}
start = false;
sql.Append(col).Append("=").Append(SqlUtil.SqlConvert(val));
}
}
return(sql.ToString());
}
public CsvPimaryKey(ISerializableObject iso, String target)
{
_type = iso.GetType();
IDictionary<String, FieldInfo> ids = AttributeWorker.GetInstance(target).GetPrimaryKeyFields(iso.GetType());
List<String> tmpList = new List<String>(ids.Count);
StringBuilder csvKey = new StringBuilder();
String tmp;
foreach (String id in ids.Keys)
{
StringBuilder tmpBuilder = new StringBuilder();
_fields.Add(ids[id]);
_values.Add(ids[id].GetValue(iso));
try
{
//if (ids[id].GetValue(iso) is DateTime)
//{
// DateTime dt = (DateTime)ids[id].GetValue(iso);
// tmp = SqlUtil.SqlConvert(dt);
//}
//else
// tmp = ids[id].GetValue(iso).ToString();
tmp = SqlUtil.SqlConvert(ids[id].GetValue(iso)).ToString();
}
catch(NullReferenceException ex)
{
throw new KeyNotFoundException("", ex);
}
//Maskierung der Kommata
tmp = tmp.Replace("/", "//");
tmp = tmp.Replace(";", "/;");
tmp = tmp.Replace("=", "/=");
tmpBuilder.Append(id).Append("=");
tmpBuilder.Append(tmp);
tmpList.Add(tmpBuilder.ToString());
}
tmpList.Sort();
bool initial = true;
foreach (String s in tmpList)
{
if (!initial)
{
csvKey.Append(";");
}
initial = false;
csvKey.Append(s);
}
_csvKey = csvKey.ToString();
}
//Hier Anknüpfungspunkt für Transparent
internal virtual String SerializeInsert(ISerializableObject iso)
{
AttributeWorker w = AttributeWorker.GetInstance(Target);
StringBuilder sql = new StringBuilder();
StringBuilder values = new StringBuilder();
sql.Append("INSERT INTO ").Append(w.GetTableMapping(iso.GetType(), _praefix));
sql.Append(" (");
FieldInfo[] fis = AttributeWorker.RetrieveAllFields(iso.GetType());
bool start = true;
foreach (FieldInfo fi in fis)
{
if (w.IsAutoincID(fi))
{
continue;
}
try
{
String col = w.GetColumnMapping(fi);
Object val = fi.GetValue(iso);
if (val == null && (w.IsID(fi) && !w.IsAutoincID(fi)))
{
throw new SerializerException("PRIMARY KEY FIELD NOT SET!!!!!!!!");
}
if (!start)
{
sql.Append(", ");
values.Append(", ");
}
else
{
start = false;
}
sql.Append(col);
values.Append(SqlUtil.SqlConvert(val));
}
catch (SerializerException) { }
}
sql.Append(") VALUES (");
sql.Append(values);
sql.Append(")");
return(sql.ToString());
}
private void analyzeObject(ISerializableObject iso)
{
ISerializableObject source = iso;
ISerializableObject sink;
Guid syncGuid = source.Rowguid;
SyncItem syncItem = FetchSyncItem(syncGuid);
if (syncItem == null)//In der Synchronisationstabelle gibt es keinen korrepondierenden Eintrag
{
#if DEBUG
logger.Debug(source.GetType().Name + ", guid=" + syncGuid + " is not synchronized and will be inserted");
#endif
analyzedList.Add(new ListContainer(iso, SyncStates_Enum.InsertState));
}
else //in der Synchronisationstabelle ist ein Eintrag vorhanden
{
sink = FetchObject(sinkSerializer, syncGuid, source.GetType());
if (sink == null)//Wenn es nicht vorhanden ist wurde es gelöscht
{
#if DEBUG
logger.Debug(syncItem.ClassID + ", guid=" + syncGuid + " does not exist, the conflict has to be resolved");
#endif
analyzedList.Add(new ListContainer(iso, SyncStates_Enum.DeletedState));
}
else
{
DateTime sinkLogtime = sink.LogTime;
if (sinkLogtime > syncItem.LogTime)//Änderung der Daten in der Zieldatenbank--warum ist das schon ein Konflikt?
{
#if DEBUG
logger.Debug(syncItem.ClassID + ", guid=" + syncGuid + " is involved in a conflict, which has to be resolved");
#endif
analyzedList.Add(new ListContainer(iso, SyncStates_Enum.ConflictState));
}
else //zieldatenbank unverändert
{
DateTime sourceLogtime = source.LogTime;
if (sourceLogtime <= syncItem.LogTime)//Quelldatenbank unverändert
{
#if DEBUG
logger.Debug(syncItem.ClassID + ", guid=" + syncGuid + " has not changed and will not be synchronized");
#endif
analyzedList.Add(new ListContainer(iso, SyncStates_Enum.IgnoreState));
}
else//Quelldatenbank verändert-Zieldatenbank unverändert ->update
{
#if DEBUG
logger.Debug(syncItem.ClassID + ", guid=" + syncGuid + " has changed on the sourceside and will be updated");
#endif
analyzedList.Add(new ListContainer(iso, SyncStates_Enum.UpdateState));
}
}
}
}
}
public void InsertObject(ISerializableObject iso, DbConnection connection, ISerializerTransaction transaction)
{
AttributeWorker w = AttributeWorker.GetInstance(Target);
DbCommand com = connection.CreateCommand();
com.CommandText = _owner.SerializeInsert(iso);
transaction.Guard(com);
//Console.WriteLine(com.CommandText);
try
{
//Console.WriteLine(com.ExecuteNonQuery());
com.ExecuteNonQuery();
}
catch (Exception ex)
{
throw new SerializerException("insert failed", ex);
}
FieldInfo autoincField;
Guid g = AttributeWorker.RowGuid(iso);
if ((autoincField = w.GetAutoincField(iso.GetType())) != null)
{
StringBuilder b = new StringBuilder();
b.Append("SELECT * FROM ").Append(w.GetTableMapping(iso.GetType(), _owner.Praefix)).Append(" WHERE ");
b.Append(w.GetColumnMapping(AttributeWorker.RowGuid(iso.GetType()))).Append("='");
b.Append(g.ToString()).Append("'");
com.CommandText = b.ToString();
DbDataReader r = com.ExecuteReader();
if (r.Read())
{
Object o = r[w.GetColumnMapping(w.GetAutoincField(iso.GetType()))];
autoincField.SetValue(iso, o);
}
else
{
r.Close();
throw new SerializerException("Insert core method failed! error unknown...");
}
r.Close();
}
GenericWeakReference <ISerializableObject> tmp = new GenericWeakReference <ISerializableObject>(iso);
_persistentObjects[g] = tmp;
MemoriseKeys(iso, w, tmp);
}
public ConflictHandling(ISerializableObject o1, ISerializableObject o2)
{
if (o1 == null || o2 == null)
throw new Exception("Objects may not be null");
if(o1.GetType()!=o2.GetType())
throw new Exception("You can only compare objects of the same type.");
this.ownerType = o1.GetType();
this.object1 = o1;
this.object2 = o2;
this.conflicts = new List<Conflict>();
}
/// <summary>
/// Returns the table name for the passed object.
/// </summary>
/// <param name="data">The ISerializableObject object.</param>
/// <returns>string</returns>
public static string GetTableMapping(ISerializableObject data)
{
Attribute a = Attribute.GetCustomAttribute(data.GetType(), typeof(TableAttribute));
string ret = null;
if (a != null)
{
ret = ((TableAttribute)a).TableMapping;
}
if (ret == null)
{
ret = data.GetType().Name;
}
return(ret);
}
internal void Delete(ISerializableObject iso, ISerializerTransaction transaction)
{
if (!IsManaged(iso))
{
return;
}
AttributeWorker w = AttributeWorker.GetInstance(Target);
ResolverData <ISerializableObject> data = new ResolverData <ISerializableObject>();
data.FieldsToResolve = AttributeWorker.RetrieveAllFields(iso.GetType());
data.HandledItem = iso;
DeleteHandler h = new DeleteHandler(this);
RelationResolver <ISerializableObject> res = new RelationResolver <ISerializableObject>();
res.Handler = h;
h.MODE = DeleteHandler.DOWNMODE;
res.StartRelationResolving(data);
_objectPool.DeleteObject(iso, _connection, transaction);
h.MODE = DeleteHandler.UPMODE;
res.StartRelationResolving(data);
}
public ISerializableObject CreateISerializableObject(Type type)
{
AttributeWorker w = AttributeWorker.GetInstance(Target);
ISerializableObject iso = null;
try
{
iso = (ISerializableObject)Activator.CreateInstance(type);
}
catch (InvalidCastException)
{
throw new SerializerException();
}
_objectPool.Register(iso);
ResolverData <ISerializableObject> data = new ResolverData <ISerializableObject>();
data.FieldsToResolve = AttributeWorker.RetrieveAllFields(iso.GetType());
data.HandledItem = iso;
CreateHandler handler = new CreateHandler(this);
RelationResolver <ISerializableObject> resolver = new RelationResolver <ISerializableObject>();
resolver.Handler = handler;
resolver.StartRelationResolving(data);
return(iso);
}
public ConflictHandling(ISerializableObject o1, ISerializableObject o2)
{
if (o1 == null || o2 == null)
{
throw new Exception("Objects may not be null");
}
if (o1.GetType() != o2.GetType())
{
throw new Exception("You can only compare objects of the same type.");
}
this.ownerType = o1.GetType();
this.object1 = o1;
this.object2 = o2;
this.conflicts = new List <Conflict>();
}
internal void copyToSinkObject(ISerializableObject from, ISerializableObject to)
{
AttributeWorker w = AttributeWorker.GetInstance(sinkSerializer.Target);//Am besten durch Kopiervorgang ersetzen, der ohne Attributeworker auskommt.
FieldInfo[] fis = AttributeWorker.RetrieveAllFields(from.GetType());
foreach (FieldInfo fi in fis)
{
if (w.IsAutoincID(fi))
{
continue; //Kann man aus Lookup-Tabelle holen
}
if (!w.IsPersistentField(fi))
{
continue; //wirklich nötig?
}
//DirectSync wird im Moment nicht unterstützt
if (AttributeWorker.IsRowGuid(fi))
{
continue; //Kann man als Lookup-Tabelle definieren
}
Object val = fi.GetValue(from);
fi.SetValue(to, val);
}
}
internal static void PlainCopy(Serializer context, ISerializableObject from, ISerializableObject to, FieldLock fieldLock, bool forceForeignKeyCopy)
{
AttributeWorker w = AttributeWorker.GetInstance(context.Target);
FieldInfo[] fis = AttributeWorker.RetrieveAllFields(from.GetType());
foreach (FieldInfo fi in fis)
{
if (fieldLock.IsLocked(fi)) continue;
if (AttributeWorker.IsRelationField(fi)) continue;
if (w.IsAutoincID(fi)) continue;
if (!w.IsPersistentField(fi)) continue;
if (AttributeWorker.IsRowGuid(fi)) continue;
if (w.IsForeignKey(context, fi) && !forceForeignKeyCopy)
{
DirectSyncAttribute a = (DirectSyncAttribute)Attribute.GetCustomAttribute(fi, typeof(DirectSyncAttribute));
if (a == null) continue;
}
Object val = fi.GetValue(from);
fi.SetValue(to, val);
}
}
private void Serialize(XElement XElement, ISerializableObject SerializableObject)
{
System.Runtime.Serialization.SerializationInfo si = new System.Runtime.Serialization.SerializationInfo(SerializableObject.GetType(), new System.Runtime.Serialization.FormatterConverter());
SerializableObject.Serialize(si);
XElement elem = new XElement(SerializableObject.SerializationTag.Type);
elem.Add(new XAttribute("name", SerializableObject.SerializationTag.Name));
foreach (System.Runtime.Serialization.SerializationEntry entry in si)
{
elem.Add(new XElement(entry.Name, entry.Value));
}
if (SerializableObject.ChildrenSerializable != null)
{
foreach (ISerializableObject childSerializable in SerializableObject.ChildrenSerializable.Where(p=>p != null))
{
Serialize(elem, childSerializable);
}
}
if (!elem.IsEmpty)
XElement.Add(elem);
}
private void Deserialize(XElement XElement, ISerializableObject SerializableObject)
{
System.Runtime.Serialization.SerializationInfo si = new System.Runtime.Serialization.SerializationInfo(SerializableObject.GetType(), new System.Runtime.Serialization.FormatterConverter());
if (XElement != null)
{
foreach (XElement xelem in XElement.Elements())
{
if (!xelem.HasElements && !string.IsNullOrEmpty(xelem.Value))
{
si.AddValue(xelem.Name.LocalName, xelem.Value);
}
}
if (SerializableObject.ChildrenSerializable != null)
{
foreach (ISerializableObject childSerializable in SerializableObject.ChildrenSerializable.Where(p=> p!=null && !p.SerializationTag.IsEmpty))
{
XElement xelem = XElement.Elements().
Where(p => p.Name == childSerializable.SerializationTag.Type).
Where(p => XmlLinq.GetAttribute(p, "name") == childSerializable.SerializationTag.Name).FirstOrDefault();
Deserialize(xelem, childSerializable);
}
}
}
SerializableObject.Deserialize(si);
}
public CsvPimaryKey(ISerializableObject iso, String target)
{
_type = iso.GetType();
IDictionary <String, FieldInfo> ids = AttributeWorker.GetInstance(target).GetPrimaryKeyFields(iso.GetType());
List <String> tmpList = new List <String>(ids.Count);
StringBuilder csvKey = new StringBuilder();
String tmp;
foreach (String id in ids.Keys)
{
StringBuilder tmpBuilder = new StringBuilder();
_fields.Add(ids[id]);
_values.Add(ids[id].GetValue(iso));
try
{
//if (ids[id].GetValue(iso) is DateTime)
//{
// DateTime dt = (DateTime)ids[id].GetValue(iso);
// tmp = SqlUtil.SqlConvert(dt);
//}
//else
// tmp = ids[id].GetValue(iso).ToString();
tmp = SqlUtil.SqlConvert(ids[id].GetValue(iso)).ToString();
}
catch (NullReferenceException ex)
{
throw new KeyNotFoundException("", ex);
}
//Maskierung der Kommata
tmp = tmp.Replace("/", "//");
tmp = tmp.Replace(";", "/;");
tmp = tmp.Replace("=", "/=");
tmpBuilder.Append(id).Append("=");
tmpBuilder.Append(tmp);
tmpList.Add(tmpBuilder.ToString());
}
tmpList.Sort();
bool initial = true;
foreach (String s in tmpList)
{
if (!initial)
{
csvKey.Append(";");
}
initial = false;
csvKey.Append(s);
}
_csvKey = csvKey.ToString();
}
public AnalyzeForm(SyncContainer cont)
{
InitializeComponent();
sourceObject = cont.SourceObject;
sinkObject = cont.SinkObject;
if (sourceObject.GetType() != sinkObject.GetType())
{
MessageBox.Show("Incompatible Types!");
this.Close();
}
propertyGridRepository.SelectedObject = sourceObject;
propertyGridMobileDB.SelectedObject = sinkObject;
objectType = sourceObject.GetType();
readType(objectType);
editObject = (ISerializableObject)objectType.GetConstructor(new Type[] {}).Invoke(new object[] {});//Konstruktor für unbekanntes Objektt
propertyGridEdit.SelectedObject = editObject;
}
public AnalyzeForm(SyncContainer cont)
{
InitializeComponent();
sourceObject = cont.SourceObject;
sinkObject = cont.SinkObject;
if(sourceObject.GetType() != sinkObject.GetType())
{
MessageBox.Show("Incompatible Types!");
this.Close();
}
propertyGridRepository.SelectedObject = sourceObject;
propertyGridMobileDB.SelectedObject = sinkObject;
objectType =sourceObject.GetType();
readType(objectType);
editObject= (ISerializableObject) objectType.GetConstructor(new Type[] {}).Invoke(new object[] {});//Konstruktor für unbekanntes Objektt
propertyGridEdit.SelectedObject = editObject;
}
internal void Save(ISerializableObject iso, ISerializerTransaction transaction)
{
AttributeWorker w = AttributeWorker.GetInstance(Target);
if (!IsManaged(iso))
{
// Console.WriteLine("SERIALIZE");
_objectPool.InsertObject(iso, _connection, transaction);
ResolverData <ISerializableObject> rData = new ResolverData <ISerializableObject>();
rData.HandledItem = iso;
rData.FieldsToResolve = AttributeWorker.RetrieveAllFields(iso.GetType());
LoadHandler handler = new LoadHandler(this);
RelationResolver <ISerializableObject> res = new RelationResolver <ISerializableObject>();
res.Handler = handler;
res.StartRelationResolving(rData);
}
else
{
// Console.WriteLine("UPDATE");
UpdateStates state = _objectPool.UpdateObject(iso, _connection, transaction);
if (state == UpdateStates.NO_ROWS_AFFECTED)
{
throw new SerializerException("entry could not be updated ...");
}
else if (state == UpdateStates.PRIMARYKEY_MODIFIED)
{
UpdateEventArgs args = new UpdateEventArgs(state);
OnUpdateEvent(args);
}
ResolverData <ISerializableObject> data = new ResolverData <ISerializableObject>();
data.HandledItem = iso;
data.FieldsToResolve = AttributeWorker.RetrieveAllFields(iso.GetType());
RelationResolver <ISerializableObject> res = new RelationResolver <ISerializableObject>();
res.Handler = new UpdateHandler(this);
res.StartRelationResolving(data);
}
}
public void RemoveVirtualKeyFromTarget(ISerializableObject target)
{
if (_targetType != target.GetType())
{
throw new Serializer.SerializerException();
}
foreach (String key in _virtualJoinKeyFields.Keys)
{
_virtualJoinKeyFields[key].SetValue(target, null);
}
}
public void Apply(ISerializableObject iso)
{
if (iso.GetType() != _type)
{
throw new SerializerException();
}
for (int i = 0; i < _fields.Count; i++)
{
_fields[i].SetValue(iso, _values[i]);
}
}
private void insert(ListContainer sc)
{
ISerializableObject sourceObject = sc.iso;
ISerializableObject sinkObject = sinkSerializer.CreateISerializableObject(sourceObject.GetType(), sc.iso.Rowguid);//Hier werden die Relationen mitgefüllt. Eigentlich ist da nicht nötig->Methode ändern? Zeitersparnis?
//Evtl. Problem, dass nicht alle Beziehungen aufgelöst werden können, weil noch nicht alle Objekte "rübersynchronisert" wurden.
copyToSinkObject(sourceObject, sinkObject);
if (LookupSynchronizationInformation.getImageClasses().Contains(sourceObject.GetType()))
{
try
{
MessageBox.Show("Insert Picture:" + sinkObject.Rowguid.ToString());
if (this.pictrans == null)
{
throw new TransferException("No TransferService is added");
}
insertPicture(sinkObject);
}
catch (Exception ex)
{
MessageBox.Show("Picture SyncFailure: " + ex.Message);
return;
}
}
try
{
adjustAutoIncKeys(sinkObject);
sinkSerializer.Connector.InsertPlain(sinkObject);
SyncItem si = syncSerializer.CreateISerializableObject <SyncItem>();
si.SyncGuid = sourceObject.Rowguid;
si.ClassID = sourceObject.GetType().Name;
syncSerializer.Connector.Save(si);
sinkObject = FetchObject(sinkSerializer, sinkObject.Rowguid, sinkObject.GetType());//Mit angepasstem AutoIncSChlüssel aus der DB holen
sc.State = SyncStates_Enum.SynchronizedState;
}
catch (Exception e)
{
MessageBox.Show("Insert Failure: " + e.Message + " All dependent Insert will also Fail and notice You");
}
}
private static void MemoriseKeys(ISerializableObject iso, AttributeWorker w, GenericWeakReference <ISerializableObject> gwr)
{
IDictionary <String, FieldInfo> pkf = w.GetPrimaryKeyFields(iso.GetType());
foreach (FieldInfo fi in pkf.Values)
{
if (w.IsAutoincID(fi))
{
continue;
}
gwr.Properties[fi.Name] = fi.GetValue(iso);
}
}
//Konstruktor
internal SyncContainer(ISerializableObject iso, Serializer syncSerializer, Serializer sourceSerializer)
{
SyncState = new PrematureState(this);
_synchronizedType = iso.GetType();
_sourceGuid = AttributeWorker.RowGuid(iso);
_syncSerializer = syncSerializer;
_sourceSerializer = sourceSerializer;
_parents = new List <SyncContainer>();
_children = new List <SyncContainer>();
}
internal ISerializableObject Load(Type type, string table, IRestriction restriction, ISerializerTransaction transaction)
{
bool found = false;
bool multiple = false;
bool isLoaded = false;
DbDataReader reader = CreateDataReader(type, table, restriction, transaction);
ISerializableObject data = null;
if (reader.Read())
{
data = _objectPool.RetrieveObject(type, reader, ref isLoaded);
found = true;
}
if (reader.Read())
{
multiple = true;
}
reader.Close();
if (multiple)
{
throw new MultipleResultException("More than one Result found for the given Restriction ...");
}
if (data == null)
{
return(null);
}
bool doRelationLoading = found && isLoaded;
if (doRelationLoading)
{
ResolverData <ISerializableObject> rData = new ResolverData <ISerializableObject>();
rData.HandledItem = data;
rData.FieldsToResolve = AttributeWorker.RetrieveAllFields(data.GetType());
LoadHandler handler = new LoadHandler(this);
RelationResolver <ISerializableObject> res = new RelationResolver <ISerializableObject>();
res.Handler = handler;
res.StartRelationResolving(rData);
}
return(data);
}
public void ApplyVirtualKeyToTarget(ISerializableObject target)
{
if (_targetType != target.GetType())
{
throw new Serializer.SerializerException();
}
foreach (String key in _virtualKeyValues.Keys)
{
Object val = _virtualKeyValues[key];
String tranlatedKey = _keyTranslation[key];
_virtualJoinKeyFields[tranlatedKey].SetValue(target, val);
}
}
internal void InitSyncContainer(IDictionary <Guid, SyncContainer> pooledObjects)
{
ResolverData <ISerializableObject> data = new ResolverData <ISerializableObject>();
ISerializableObject iso = FetchObject(_sourceSerializer, _sourceGuid);
data.HandledItem = iso;
data.FieldsToResolve = AttributeWorker.RetrieveAllFields(iso.GetType());//Sind alle nötig?
DependencyRelationHandler h = new DependencyRelationHandler(this, pooledObjects);
RelationResolver <ISerializableObject> r = new RelationResolver <ISerializableObject>();
r.Handler = h;
r.StartRelationResolving(data);
}
/// <summary>
/// Gets the AutoIncPrimaryKey setter.
/// </summary>
/// <param name="data">The ISerializableObject object.</param>
/// <returns>MethodInfo</returns>
public static MethodInfo GetAutoIncPrimaryKeySetter(ISerializableObject data)
{
PropertyInfo[] properties = data.GetType().GetProperties();
foreach (PropertyInfo p in properties)
{
ColumnAttribute attribute = GetColumnAttribute(p);
if (attribute != null && attribute is AutoIncPrimaryKeyAttribute)
{
return p.GetSetMethod();
}
}
return null;
}
/// <summary>
/// Determines whether the ISerializableObject object contains an AutoIncPrimaryKey.
/// </summary>
/// <param name="data">The ISerializableObject object.</param>
/// <returns>
/// <c>true</c> if the ISerializableObject object contains an AutoIncPrimaryKey; otherwise, <c>false</c>.
/// </returns>
public static bool ContainsAutoIncPrimaryKey(ISerializableObject data)
{
PropertyInfo[] properties = data.GetType().GetProperties();
foreach (PropertyInfo p in properties)
{
ColumnAttribute attribute = GetColumnAttribute(p);
if (attribute != null && attribute is AutoIncPrimaryKeyAttribute)
{
return(true);
}
}
return(false);
}
/// <summary>
/// Determines whether the ISerializableObject object contains an AutoIncPrimaryKey.
/// </summary>
/// <param name="data">The ISerializableObject object.</param>
/// <returns>
/// <c>true</c> if the ISerializableObject object contains an AutoIncPrimaryKey; otherwise, <c>false</c>.
/// </returns>
public static bool ContainsAutoIncPrimaryKey(ISerializableObject data)
{
PropertyInfo[] properties = data.GetType().GetProperties();
foreach (PropertyInfo p in properties)
{
ColumnAttribute attribute = GetColumnAttribute(p);
if (attribute != null && attribute is AutoIncPrimaryKeyAttribute)
{
return true;
}
}
return false;
}
internal static void ForeignKeyCopy(Serializer context, ISerializableObject from, ISerializableObject to, FieldLock fieldLock)
{
AttributeWorker w = AttributeWorker.GetInstance(context.Target);
FieldInfo[] fis = AttributeWorker.RetrieveAllFields(from.GetType());
foreach (FieldInfo fi in fis)
{
if (fieldLock.IsLocked(fi)) continue;
if (!w.IsForeignKey(context, fi)) continue;
Object val = fi.GetValue(from);
fi.SetValue(to, val);
}
}
/// <summary>
/// Gets the AutoIncPrimaryKey setter.
/// </summary>
/// <param name="data">The ISerializableObject object.</param>
/// <returns>MethodInfo</returns>
public static MethodInfo GetAutoIncPrimaryKeySetter(ISerializableObject data)
{
PropertyInfo[] properties = data.GetType().GetProperties();
foreach (PropertyInfo p in properties)
{
ColumnAttribute attribute = GetColumnAttribute(p);
if (attribute != null && attribute is AutoIncPrimaryKeyAttribute)
{
return(p.GetSetMethod());
}
}
return(null);
}
protected List <String> GetConstrainingAttributes(String op)
{
List <string> list = new List <string>();
PropertyInfo[] properties = data.GetType().GetProperties();
foreach (PropertyInfo property in properties)
{
ColumnAttribute attribute =
(ColumnAttribute)Attribute.GetCustomAttribute(property, typeof(ColumnAttribute));
if (attribute != null)
{
MethodInfo method = property.GetGetMethod();
Object ret = method.Invoke(data, null);
SqlConvert(ref ret);
if (data.ContainsConstrainingAttribute(QueryStrategyConfiguration.PRIMARYKEY) && attribute is IPrimaryKeyAttribute)
{
StringBuilder tmp = new StringBuilder().Append(AttributeUtilities.GetColumnMapping(property));
string equal = " " + op + " ";
if (ret.ToString().Equals("NULL"))
{
equal = " IS ";
}
tmp.Append(equal).Append(ret.ToString());
list.Add(tmp.ToString());
}
else if (
data.ContainsConstrainingAttribute(property.Name) ||
data.ContainsConstrainingAttribute(AttributeUtilities.GetColumnMapping(property))
)
{
StringBuilder tmp = new StringBuilder().Append(AttributeUtilities.GetColumnMapping(property));
string equal = " " + op + " ";
if (ret.ToString().Equals("NULL"))
{
equal = " IS ";
}
tmp.Append(equal).Append(ret.ToString());
list.Add(tmp.ToString());
}
}
}
return(list);
}
public String ComputeObjectState(ISerializableObject iso)
{
StringBuilder objectState = new StringBuilder();
FieldInfo[] fis = RetrieveAllFields(iso.GetType());
foreach (FieldInfo fi in fis)
{
if (IsPersistentField(fi))
{
Object val = fi.GetValue(iso);
objectState.Append(val);
}
}
return(objectState.ToString());
}
internal static void PlainCopy(Serializer context, ISerializableObject from, ISerializableObject to, FieldLock fieldLock, bool forceForeignKeyCopy)
{
AttributeWorker w = AttributeWorker.GetInstance(context.Target);
FieldInfo[] fis = AttributeWorker.RetrieveAllFields(from.GetType());
foreach (FieldInfo fi in fis)
{
if (fieldLock.IsLocked(fi))
{
continue;
}
if (AttributeWorker.IsRelationField(fi))
{
continue;
}
if (w.IsAutoincID(fi))
{
continue;
}
if (!w.IsPersistentField(fi))
{
continue;
}
if (AttributeWorker.IsRowGuid(fi))
{
continue;
}
if (w.IsForeignKey(context, fi) && !forceForeignKeyCopy)
{
DirectSyncAttribute a = (DirectSyncAttribute)Attribute.GetCustomAttribute(fi, typeof(DirectSyncAttribute));
if (a == null)
{
continue;
}
}
Object val = fi.GetValue(from);
fi.SetValue(to, val);
}
}
public int ComputeHashCode(ISerializableObject iso)
{
int hashCode = 0;
FieldInfo[] fis = RetrieveAllFields(iso.GetType());
foreach (FieldInfo fi in fis)
{
if (IsPersistentField(fi))
{
Object val = fi.GetValue(iso);
if (val != null)
{
hashCode = hashCode ^ val.GetHashCode();
}
}
}
return(hashCode);
}
public static bool isRoot(ISerializableObject iso)
{
if (iso != null)
{
if (iso.GetType().Equals(typeof(CollectionEventSeries)))
return true;
else if (iso.GetType().Equals(typeof(CollectionEvent)))
{
CollectionEvent ce = (CollectionEvent)iso;
if (ce.SeriesID == null)
return true;
}
else if (iso.GetType().Equals(typeof(CollectionSpecimen)))
{
CollectionSpecimen spec = (CollectionSpecimen)iso;
if (spec.CollectionEventID == null)
return true;
}
}
return false;
}
internal static void ForeignKeyCopy(Serializer context, ISerializableObject from, ISerializableObject to, FieldLock fieldLock)
{
AttributeWorker w = AttributeWorker.GetInstance(context.Target);
FieldInfo[] fis = AttributeWorker.RetrieveAllFields(from.GetType());
foreach (FieldInfo fi in fis)
{
if (fieldLock.IsLocked(fi))
{
continue;
}
if (!w.IsForeignKey(context, fi))
{
continue;
}
Object val = fi.GetValue(from);
fi.SetValue(to, val);
}
}
internal void copyToSinkObject(ISerializableObject from, ISerializableObject to)
{
AttributeWorker w = AttributeWorker.GetInstance(sinkSerializer.Target);//Am besten durch Kopiervorgang ersetzen, der ohne Attributeworker auskommt.
FieldInfo[] fis = AttributeWorker.RetrieveAllFields(from.GetType());
foreach (FieldInfo fi in fis)
{
if (w.IsAutoincID(fi)) continue;//Kann man aus Lookup-Tabelle holen
if (!w.IsPersistentField(fi)) continue;//wirklich nötig?
//DirectSync wird im Moment nicht unterstützt
if (AttributeWorker.IsRowGuid(fi)) continue;//Kann man als Lookup-Tabelle definieren
Object val = fi.GetValue(from);
fi.SetValue(to, val);
}
}
private void bottomUp(ISerializableObject iso, List<ISerializableObject> parents)
{
if (iso.GetType().Equals(typeof(IdentificationUnitAnalysis)))
{
IdentificationUnitAnalysis iua = (IdentificationUnitAnalysis)iso;
IdentificationUnit iu = iua.IdentificationUnit;
if (iu != null)
{
parents.Add(iu);
bottomUp(iu, parents);
}
else throw new Exception();
}
else if (iso.GetType().Equals(typeof(IdentificationUnit)))
{
IdentificationUnit iu = (IdentificationUnit)iso;
/*
IDirectAccessIterator<Identification> identifications = iu.Identifications;
short i = 0;
Identification ident = null;
foreach (Identification id in identifications)
{
if (id.IdentificationSequence != null && id.IdentificationSequence > i)
{
i = (short)id.IdentificationSequence;
ident = id;
}
}
if (ident != null)
parents.Add(ident);*/
IdentificationUnit relatedUnit = iu.RelatedUnit;
if (relatedUnit != null)
{
parents.Add(relatedUnit);
bottomUp(relatedUnit, parents);
}
else
{
CollectionSpecimen spec = iu.CollectionSpecimen;
if (spec != null)
{
parents.Add(spec);
bottomUp(spec, parents);
}
else
throw new Exception();
}
}
else if (iso.GetType().Equals(typeof(CollectionSpecimen)))
{
CollectionSpecimen spec = (CollectionSpecimen)iso;
CollectionAgent ca = spec.CollectionAgent.First();
if (ca != null)
parents.Add(ca);
CollectionEvent ce = spec.CollectionEvent;
if (ce != null)
{
parents.Add(ce);
bottomUp(ce, parents);
}
else this.root = spec; ;//Warnung dass das Specimen nicht angezeigt werden kann
}
else if (iso.GetType().Equals(typeof(CollectionEvent)))
{
CollectionEvent ce = (CollectionEvent)iso;
IDirectAccessIterator<CollectionEventLocalisation> locations = ce.CollectionEventLocalisation;
foreach (CollectionEventLocalisation loc in locations)
{
parents.Add(loc);
}
IDirectAccessIterator<CollectionEventProperty> properties = ce.CollectionEventProperties;
foreach (CollectionEventProperty prop in properties)
{
parents.Add(prop);
}
CollectionEventSeries cs = ce.CollectionEventSeries;
if (cs != null)
{
parents.Add(cs);
this.root = cs;
}
else this.root = ce;
}
else if (iso.GetType().Equals(typeof(CollectionEventSeries)))
{
CollectionEventSeries cs = (CollectionEventSeries)iso;
this.root = cs;
}
}
public void Apply(ISerializableObject iso)
{
if (iso.GetType() != _type)
{
throw new SerializerException();
}
for (int i = 0; i < _fields.Count; i++)
{
_fields[i].SetValue(iso, _values[i]);
}
}
public TreeNode displayListTopDown(List<ISerializableObject> objects, ISerializableObject root)
{
TreeNode tn = new TreeNode();
if (root != null)
{
if (root.GetType().Equals(typeof(CollectionEventSeries)))
{
CollectionEventSeries cs = (CollectionEventSeries)root;
parametrizeEventSeriesNode(cs, tn);
foreach (ISerializableObject iso in objects)
{
if (iso != null)
{
if (iso.GetType().Equals(typeof(CollectionEvent)))
{
tn.Nodes.Add(displayListTopDown(objects, iso));
}
}
}
}
if (root.GetType().Equals(typeof(CollectionEvent)))
{
CollectionEvent ce = (CollectionEvent)root;
parametrizeEventNode(ce, tn, objects);
foreach (ISerializableObject iso in objects)
{
if (iso != null)
{
if (iso.GetType().Equals(typeof(CollectionSpecimen)))
tn.Nodes.Add(displayListTopDown(objects, iso));
}
}
}
if (root.GetType().Equals(typeof(CollectionSpecimen)))
{
CollectionSpecimen spec = (CollectionSpecimen)root;
parametrizeSpecimenNode(spec, tn, objects);
foreach (ISerializableObject iso in objects)
{
if (iso != null)
{
if (iso.GetType().Equals(typeof(IdentificationUnit)))
{
IdentificationUnit iu = (IdentificationUnit)iso;
if (iu.CollectionSpecimenID == spec.CollectionSpecimenID && iu.RelatedUnitID == null)
tn.Nodes.Add(displayListTopDown(objects, iu));
}
}
}
}
if (root.GetType().Equals(typeof(IdentificationUnit)))
{
IdentificationUnit iu = (IdentificationUnit)root;
parametrizeIUNode(iu, tn);//Muss nicht auf die Liste angewendet werden, da weder ein Iterator verwendet wird noch auf die DB zugegriffen wird)
foreach (ISerializableObject iso in objects)
{
if (iso != null)
{
/*if (iso.GetType().Equals(typeof(IdentificationUnitAnalysis)))
{
IdentificationUnitAnalysis iua = (IdentificationUnitAnalysis)iso;
if (iua.IdentificationUnitID == iu.IdentificationUnitID)
{
TreeNode analysisNode = new TreeNode();
parametrizeIUANode(iua, analysisNode);
tn.Nodes.Add(analysisNode);
}
}
else*/ if (iso.GetType().Equals(typeof(IdentificationUnit)))
{
IdentificationUnit childUnit = (IdentificationUnit)iso;
if (childUnit.RelatedUnitID == iu.IdentificationUnitID)
{
tn.Nodes.Add(displayListTopDown(objects, childUnit));
}
}
}
}
}
}
return tn;
}
protected QueryStrategy(ISerializableObject data)
{
this.data = data;
table = AttributeUtilities.GetTableMapping(data);
properties = data.GetType().GetProperties();
}
private void topDown(ISerializableObject iso, List<ISerializableObject> children)
{
if (iso.GetType().Equals(typeof(CollectionEventSeries)))
{
CollectionEventSeries cs = (CollectionEventSeries)iso;
IDirectAccessIterator<CollectionEvent> events = cs.CollectionEvents;
foreach (CollectionEvent ce in events)
{
children.Add(ce);
topDown(ce, children);
}
}
if (iso.GetType().Equals(typeof(CollectionEvent)))
{
CollectionEvent ce = (CollectionEvent)iso;
IDirectAccessIterator<CollectionEventLocalisation> locations = ce.CollectionEventLocalisation;
foreach (CollectionEventLocalisation loc in locations)
{
children.Add(loc);
}
IDirectAccessIterator<CollectionEventProperty> properties = ce.CollectionEventProperties;
foreach (CollectionEventProperty prop in properties)
{
children.Add(prop);
}
IDirectAccessIterator<CollectionSpecimen> specimen = ce.CollectionSpecimen;
foreach (CollectionSpecimen spec in specimen)
{
children.Add(spec);
topDown(spec, children);
}
}
if (iso.GetType().Equals(typeof(CollectionSpecimen)))
{
CollectionSpecimen spec = (CollectionSpecimen)iso;
CollectionAgent ca = spec.CollectionAgent.First();
if (ca != null)
children.Add(ca);
IDirectAccessIterator<CollectionProject> projects = spec.CollectionProject;
foreach (CollectionProject pr in projects)
{
children.Add(pr);
}
IDirectAccessIterator<IdentificationUnit> units = spec.IdentificationUnits;
foreach (IdentificationUnit iu in units)
{
if (iu.RelatedUnit == null)//Hier kann der Aufwand optimiert werden indem gleich alle IdentificationUnits angehängt werden, alerdings muss dann der Fall von einer IU als Startpunkt gesondert behandelt werden
{
children.Add(iu);
topDown(iu, children);
}
}
}
if (iso.GetType().Equals(typeof(IdentificationUnit)))
{
IdentificationUnit iu = (IdentificationUnit)iso;
IDirectAccessIterator<IdentificationUnitAnalysis> analyses = iu.IdentificationUnitAnalysis;
IDirectAccessIterator<IdentificationUnitGeoAnalysis> geoAnalyses = iu.IdentificationUnitGeoAnalysis;
IDirectAccessIterator<Identification> ids = iu.Identifications;
foreach (IdentificationUnitAnalysis iua in analyses)
{
children.Add(iua);
}
foreach (IdentificationUnitGeoAnalysis iuga in geoAnalyses)
{
children.Add(iuga);
}
foreach (Identification id in ids)
{
children.Add(id);
}
IDirectAccessIterator<IdentificationUnit> units = iu.ChildUnits;
foreach (IdentificationUnit childUnit in units)
{
children.Add(childUnit);
topDown(childUnit, children);
}
}
}
private static void MemoriseKeys(ISerializableObject iso, AttributeWorker w, GenericWeakReference<ISerializableObject> gwr)
{
IDictionary<String, FieldInfo> pkf = w.GetPrimaryKeyFields(iso.GetType());
foreach (FieldInfo fi in pkf.Values)
{
if (w.IsAutoincID(fi)) continue;
gwr.Properties[fi.Name] = fi.GetValue(iso);
}
}
private void adjustAutoIncKeys(ISerializableObject manipulatedObject)
{
try
{
Type t = manipulatedObject.GetType();
//1.Abhängigkeiten aus Liste holen <eigenes Feld,Klasse>
Dictionary<String, Type> foreignKeys = LookupSynchronizationInformation.getDeterminingFields(t);
foreach (KeyValuePair<String, Type> fk in foreignKeys)
{
FieldInfo foreignAutoInc = t.GetField(fk.Key, BindingFlags.NonPublic | BindingFlags.Instance);//Enthält die Information darüber in welchem Feld das manipulatedObject einen fremden AutoInc-Key stehen hat.
if (foreignAutoInc.GetValue(manipulatedObject) != null)
{
//2.AutoincFeld der PartnerKlasse holen
String autoInc = LookupSynchronizationInformation.getAutoIncFields()[fk.Value];
//3.In der QuelldatenBank nach dem referenzierten AutoincSchlüssel suchen und das entsprechnde Objekt laden.
IRestriction r = RestrictionFactory.Eq(fk.Value, autoInc, foreignAutoInc.GetValue(manipulatedObject));
ISerializableObject parent = sourceSerializer.Connector.Load(fk.Value, r);
Guid g = parent.Rowguid;
//4. synchronisierten Partner in der Zieldatenbank über Guid holen
ISerializableObject parentPartner = FetchObject(sinkSerializer, g, fk.Value);
FieldInfo partnerField = fk.Value.GetField(autoInc, BindingFlags.Instance | BindingFlags.NonPublic);
//5. Werte anpassen
foreignAutoInc.SetValue(manipulatedObject, partnerField.GetValue(parentPartner));
}
}
}
catch (Exception e)
{
MessageBox.Show("KeyAdjustmentError: " + e.Message);
if (e.InnerException != null)
MessageBox.Show(e.InnerException.Message);
throw new SerializerException("KeyAdjustmentError: " + e.Message);
}
}
/// <summary>
/// Returns the table name for the passed object.
/// </summary>
/// <param name="data">The ISerializableObject object.</param>
/// <returns>string</returns>
public static string GetTableMapping(ISerializableObject data)
{
Attribute a = Attribute.GetCustomAttribute(data.GetType(), typeof(TableAttribute));
string ret = null;
if (a != null) ret = ((TableAttribute)a).TableMapping;
if (ret == null) ret = data.GetType().Name;
return ret;
}
public void Remove(ISerializableObject iso)
{
if (iso != null)
{
try
{
con.Delete(iso);
}
catch (Exception)
{
throw new DataFunctionsException("Object (" + iso.GetType().Name + ") couldn't be removed.");
}
}
}
public static String ComputeHashCode(String target, ISerializableObject iso)
{
AttributeWorker w = AttributeWorker.GetInstance(target);
FieldInfo[] fis = AttributeWorker.RetrieveAllFields(iso.GetType());
StringBuilder b = new StringBuilder();
foreach (FieldInfo fi in fis)
{
if (w.IsPersistentField(fi) && !w.IsID(fi))
{
Object val = fi.GetValue(iso);
b.Append(val);
}
}
System.Text.ASCIIEncoding encoding = new System.Text.ASCIIEncoding();
Byte[] tmp = encoding.GetBytes(b.ToString());
return BitConverter.ToString(new MD5CryptoServiceProvider().ComputeHash(tmp)).Replace("-", "").ToLower();
}
public void InsertObject(ISerializableObject iso, DbConnection connection, ISerializerTransaction transaction, string table)
{
AttributeWorker w = AttributeWorker.GetInstance(Target);
DbCommand com = connection.CreateCommand();
com.CommandText = _owner.SerializeInsert(iso,table);
transaction.Guard(com);
//Console.WriteLine(com.CommandText);
try
{
//Console.WriteLine(com.ExecuteNonQuery());
com.ExecuteNonQuery();
}
catch (Exception ex)
{
throw new SerializerException("insert failed", ex);
}
FieldInfo autoincField;
Guid g = AttributeWorker.RowGuid(iso);
if ((autoincField = w.GetAutoincField(iso.GetType())) != null)
{
StringBuilder b = new StringBuilder();
b.Append("SELECT * FROM ").Append(w.GetTableMapping(iso.GetType(),_owner.Praefix)).Append(" WHERE ");
b.Append(w.GetColumnMapping(AttributeWorker.RowGuid(iso.GetType()))).Append("='");
b.Append(g.ToString()).Append("'");
com.CommandText = b.ToString();
DbDataReader r = com.ExecuteReader();
if (r.Read())
{
Object o = r[w.GetColumnMapping(w.GetAutoincField(iso.GetType()))];
autoincField.SetValue(iso, o);
}
else
{
r.Close();
throw new SerializerException("Insert core method failed! error unknown...");
}
r.Close();
/*com.CommandText = "SELECT @@IDENTITY";
Object o = com.ExecuteScalar();
Console.WriteLine("---->"+o);
if (o is DBNull)
{
throw new SerializerException();
}
autoincField.SetValue(iso, Decimal.ToInt32((Decimal)o));
*/
}
GenericWeakReference<ISerializableObject> tmp = new GenericWeakReference<ISerializableObject>(iso);
_persistentObjects[g] = tmp;
MemoriseKeys(iso, w, tmp);
}
public void transferPicture(ISerializableObject iso)
{
resetInformation();
_service = new DiversityMediaServiceClient();
if (_service.State != System.ServiceModel.CommunicationState.Opened)
{
try
{
_service.Open();
}
catch (Exception e)
{
StringBuilder sb = new StringBuilder("Cant Open Connection: ").Append(e.Message);
if (e.InnerException != null)
{
sb.Append(",");
sb.Append(e.InnerException.Message);
}
throw new Exception(sb.ToString());
}
}
_author = this._userName;
_projectId = this._project;
//Fallunterscheidung nach ImageTypeClasse um benötigte informationen zu bekommen
try
{
if (iso is CollectionEventImage)
{
CollectionEventImage cei = (CollectionEventImage)iso;
_rowGuid = cei.Rowguid.ToString();
string pureFileName = System.IO.Path.GetFileName(cei.URI);
string path = System.IO.Directory.GetCurrentDirectory();
StringBuilder sb = new StringBuilder(_pictureDirectory);
sb.Append("\\");
sb.Append(pureFileName);
_pathName = sb.ToString();
_type = cei.ImageType;
IRestriction re = RestrictionFactory.Eq(typeof(CollectionEvent), "_CollectionEventID", cei.CollectionEventID);
CollectionEvent ce = _sourceSerializer.Connector.Load<CollectionEvent>(re);
IRestriction r1 = RestrictionFactory.Eq(typeof(CollectionEventLocalisation), "_CollectionEventID", cei.CollectionEventID);
IRestriction r2 = RestrictionFactory.Eq(typeof(CollectionEventLocalisation), "_LocalisationSystemID", 8);
IRestriction r = RestrictionFactory.And().Add(r1).Add(r2);
CollectionEventLocalisation cel = _sourceSerializer.Connector.Load<CollectionEventLocalisation>(r);
if (cel != null)
{
if (cel.AverageAltitudeCache != null)
_longitude = (float)cel.AverageLongitudeCache;
if (cel.AverageLatitudeCache != null)
_latitude = (float)cel.AverageLatitudeCache;
if (cel.AverageLongitudeCache != null)
_altitude = (float)cel.AverageAltitudeCache;
}
_timestamp = cei.LogTime.ToString();
}
else if (iso.GetType().Equals(typeof(CollectionSpecimenImage)))
{
CollectionSpecimenImage csi = (CollectionSpecimenImage)iso;
_rowGuid = csi.Rowguid.ToString();
string pureFileName = System.IO.Path.GetFileName(csi.URI);
string path = System.IO.Directory.GetCurrentDirectory();
StringBuilder sb = new StringBuilder(_pictureDirectory);
sb.Append("\\");
sb.Append(pureFileName);
_pathName = sb.ToString();
_type = csi.ImageType;
IRestriction re = RestrictionFactory.Eq(typeof(CollectionSpecimen), "_CollectionSpecimenID", csi.CollectionSpecimenID);
CollectionSpecimen cs = _sourceSerializer.Connector.Load<CollectionSpecimen>(re);
CollectionEvent ce = cs.CollectionEvent;
IRestriction r1 = RestrictionFactory.Eq(typeof(CollectionEventLocalisation), "_CollectionEventID", ce.CollectionEventID);
IRestriction r2 = RestrictionFactory.Eq(typeof(CollectionEventLocalisation), "_LocalisationSystemID", 8);
IRestriction r = RestrictionFactory.And().Add(r1).Add(r2);
CollectionEventLocalisation cel = _sourceSerializer.Connector.Load<CollectionEventLocalisation>(r);
if (cel != null)
{
if (cel.AverageAltitudeCache != null)
_longitude = (float)cel.AverageLongitudeCache;
else
_longitude = 0;
if (cel.AverageLatitudeCache != null)
_latitude = (float)cel.AverageLatitudeCache;
else
_latitude = 0;
if (cel.AverageLongitudeCache != null)
_altitude = (float)cel.AverageAltitudeCache;
else
_altitude = 0;
}
else
{
_latitude = _longitude = _altitude = 0;
}
_timestamp = csi.LogTime.ToString();
}
else
{
throw new TransferException("ImageClass not Supported");
}
}
catch (Exception e)
{
StringBuilder sb = new StringBuilder("Corresponding data not found: ").Append(e.Message);
if (e.InnerException != null)
{
sb.Append(",");
sb.Append(e.InnerException.Message);
}
throw new Exception(sb.ToString());
}
FileStream fileStrm = null;
BinaryReader rdr = null;
byte[] data = null;
DateTime start = DateTime.Now;
String retString = String.Empty;
try
{
// Create stream and reader for file data
fileStrm = new FileStream(_pathName, FileMode.Open, FileAccess.Read);
rdr = new BinaryReader(fileStrm);
}
catch(Exception e)
{
StringBuilder sb = new StringBuilder("Picture not found: ").Append(e.Message);
if (e.InnerException != null)
{
sb.Append(",");
sb.Append(e.InnerException.Message);
}
if (rdr != null)
rdr.Close();
throw new Exception(sb.ToString());
}
try
{
// Number of bytes to be transferred
long numBytes = fileStrm.Length;
// Package counter
int count = 0;
// Return string
_fileName = Path.GetFileName(_pathName);
if (numBytes > 0)
{
data = rdr.ReadBytes((int)numBytes);
count++;
//retString = f.ReadFileAndTransfer(pathName);
retString = _service.Submit(_fileName, _fileName, _type, _latitude, _longitude, _altitude, _author, _timestamp, _projectId, data); // IDs 372, 373, 374
}
TimeSpan dif = DateTime.Now - start;
if (retString.StartsWith("http"))
{
MessageBox.Show(retString);
MessageBox.Show(dif.ToString() + " msec - " + count.ToString() + " packets transmitted");
}
else
{
MessageBox.Show("ERROR: " + retString);
}
// Close reader and stream
rdr.Close();
fileStrm.Close();
}
catch (Exception e)
{
StringBuilder sb = new StringBuilder("Transfer Error: ").Append(e.Message);
if (e.InnerException != null)
{
sb.Append(",");
sb.Append(e.InnerException.Message);
}
if (rdr != null)
rdr.Close();
if (fileStrm != null)
fileStrm.Close();
throw new Exception(sb.ToString());
}
finally
{
// Abort faulted proxy
if (_service.State == System.ServiceModel.CommunicationState.Faulted)
{
// Webservice method call
// proxy.Rollback();
_service.Abort();
}
// Close proxy
else if (_service.State == System.ServiceModel.CommunicationState.Opened)
{
_service.Close();
}
}
if (iso.GetType().Equals(typeof(CollectionEventImage)))
{
CollectionEventImage cei = (CollectionEventImage)iso;
cei.URI = retString;
}
if (iso.GetType().Equals(typeof(CollectionSpecimenImage)))
{
CollectionSpecimenImage csi = (CollectionSpecimenImage)iso;
csi.URI = retString;
}
// Close reader and stream
rdr.Close();
fileStrm.Close();
}
