private static void MergeCollections <T>(SyncList <T> lSource, DictionaryOfLineObjectCollection dlocTarget) where T : ILineObject <T>
{
Debug.Assert(lSource != null);
ILineObjectCollection <T> locTarget = dlocTarget.GetLineObjectCollection <T>();
foreach (T objSource in lSource)
{
ILineObjectWithId <T> objById = objSource as ILineObjectWithId <T>;
ILineObjectWithKey <T> objByKey = objSource as ILineObjectWithKey <T>;
try
{
if (objById != null)
{
if (objById.Id != 0)
{
locTarget.MergeLineObject(objSource);
}
}
else if (objByKey != null)
{
locTarget.MergeLineObject(objSource);
}
else
{
Debug.Assert(false);
}
}
catch (Exception excp)
{
m_logger.Excp(excp, "Could not merge object {0}", objSource);
}
}
}
public static void EnsureFromCache()
{
DictionaryOfLineObjectCollection dlocSource = DatabaseCache.Instance.AllObjects;
DictionaryOfLineObjectCollection dlocTarget = LineSr.Instance.AllObjects;
MergeCollections <TimeTypeLn>(dlocSource, dlocTarget);
MergeCollections <ScoreTypeLn>(dlocSource, dlocTarget);
MergeCollections <BetTypeLn>(dlocSource, dlocTarget);
MergeCollections <BetDomainTypeLn>(dlocSource, dlocTarget);
MergeCollections <TaggedStringLn>(dlocSource, dlocTarget);
ILineObjectCollection <GroupLn> locGroups = dlocSource.GetLineObjectCollection <GroupLn>();
SyncList <GroupLn> lGroups = locGroups.ToSyncList();
lGroups.Sort(delegate(GroupLn g1, GroupLn g2)
{
long lParentGroupId1 = g1.ParentGroupId.Value ?? 0;
long lParentGroupId2 = g2.ParentGroupId.Value ?? 0;
if (lParentGroupId1 == lParentGroupId2)
{
return(g1.GroupId.CompareTo(g2.GroupId));
}
return(lParentGroupId1.CompareTo(lParentGroupId2));
});
MergeCollections <GroupLn>(lGroups, dlocTarget);
MergeCollections <CompetitorLn>(dlocSource, dlocTarget);
MergeCollections <CompetitorToOutrightLn>(dlocSource, dlocTarget);
MergeCollections <MatchLn>(dlocSource, dlocTarget);
MergeCollections <LiveMatchInfoLn>(dlocSource, dlocTarget);
MergeCollections <MatchToGroupLn>(dlocSource, dlocTarget);
MergeCollections <BetDomainLn>(dlocSource, dlocTarget);
MergeCollections <OddLn>(dlocSource, dlocTarget);
MergeCollections <MatchResultLn>(dlocSource, dlocTarget);
MergeCollections <ResourceRepositoryLn>(dlocSource, dlocTarget);
MergeCollections <ResourceAssignmentLn>(dlocSource, dlocTarget);
MergeCollections <CompetitorInfosLn>(dlocSource, dlocTarget);
MergeCollections <MatchInfosLn>(dlocSource, dlocTarget);
MergeCollections <TournamentInfosLn>(dlocSource, dlocTarget);
MergeCollections <LiabilityLn>(dlocSource, dlocTarget);
MergeCollections <LanguageLn>(dlocSource, dlocTarget);
MergeCollections <TournamentMatchLocksLn>(dlocSource, dlocTarget);
LineSr.Instance.NewOrChangedObjects.UnsetPropertiesChanged();
LineSr.Instance.NewOrChangedObjects.Clear();
LineSr.Instance.ObjectsToRemove.Clear();
}
private void FillFromDataTable <T>(IDbConnection conn, string sQuery, ILineObjectCollection <T> locObjects) where T : ILineObject <T>
{
try
{
using (DataTable dt = DataCopy.GetDataTable(conn, null, sQuery))
{
foreach (var dr in dt.AsEnumerable())
{
T obj = Activator.CreateInstance <T>();
obj.FillFromDataRow(dr);
locObjects.AddStrictly(obj);
}
}
}
catch (Exception excp)
{
m_logger.Error(excp.Message, excp);
throw;
}
}
public static int MergeLineObjects <T>(LineContainer lc, ILineObjectCollection <T> loc, MergeLineObjectsCallBack <T> objectsCallBack, ref long lOperationMask) where T : ILineObject <T>
{
Debug.Assert(objectsCallBack.GetLineObject != null);
Debug.Assert(objectsCallBack.CreateLineObject != null);
int iSucceededCount = 0;
if (loc != null)
{
string sObjectListName = LineContainer.ContentTypeToObjectListName(typeof(T));
SerializableObjectList lObjects = lc.Objects.SafelyGetValue(sObjectListName);
if (lObjects != null)
{
foreach (ISerializableObject so in lObjects)
{
//so.MethodTag = dgo;
try
{
T tObj = objectsCallBack.GetLineObject(so);
if (so.IsToRemove())
{
if (tObj != null)
{
tObj = loc.MergeLineObject(tObj, so);
if (objectsCallBack.RemoveLineObject != null)
{
objectsCallBack.RemoveLineObject(tObj);
//m_logger.InfoFormat("Removed from Line {0}", tObj);
lOperationMask |= (long)eOperationMask.RemovedFromCollection;
}
}
}
else
{
if (tObj == null)
{
// Object is NEW - DOES NOT exist yet in line
tObj = objectsCallBack.CreateLineObject();
tObj.Deserialize(so);
tObj = loc.MergeLineObject(tObj);
lOperationMask |= (long)eOperationMask.AddedToCollection;
//m_logger.DebugFormat("Added to Line {0}", tObj);
}
else
{
// Object Already Exists
tObj = loc.MergeLineObject(tObj, so);
if (tObj.ChangedProps != null && tObj.ChangedProps.Count > 0)
{
lOperationMask |= (long)eOperationMask.ObjectEdited;
}
}
if (objectsCallBack.OnLineObjectMerged != null)
{
objectsCallBack.OnLineObjectMerged(tObj);
}
}
iSucceededCount++;
}
catch (Exception excp)
{
m_logger.Error(excp.Message, excp);
ExcpHelper.ThrowUp(excp, "MergeLineObjects<{0}>() ERROR for {1}", typeof(T).Name, so);
}
}
}
}
return(iSucceededCount);
}
public static int MergeLineObjects <T>(LineContainer lc, ILineObjectCollection <T> loc, MergeLineObjectsCallBack <T> objectsCallBack) where T : ILineObject <T>
{
long lOperationMask = 0L;
return(MergeLineObjects <T>(lc, loc, objectsCallBack, ref lOperationMask));
}
private static void LineObjectCollectionToSerializableObjectList <T>(LineContainer lc, ILineObjectCollection <T> locObjects) where T : ILineObject <T>
{
string sObjectListName = LineContainer.ContentTypeToObjectListName(typeof(T));
SyncList <T> lObjects = locObjects.ToSyncList();
SerializableObjectList lSerializableObjects = lc.Objects.EnsureSerializableObjectList(typeof(T), sObjectListName);
foreach (T objSource in lObjects)
{
try
{
ISerializableObject so = objSource.Serialize();
lSerializableObjects.Add(so);
}
catch (Exception excp)
{
m_logger.Excp(excp, "ToLineContainer() ERROR. Could not add serializable object for {0}", objSource);
}
}
Thread.Sleep(1);
}
private static void MergeCollections <T>(DictionaryOfLineObjectCollection dlocSource, DictionaryOfLineObjectCollection dlocTarget) where T : ILineObject <T>
{
ILineObjectCollection <T> loc = dlocSource.GetLineObjectCollection <T>();
MergeCollections <T>(loc.ToSyncList(), dlocTarget);
}
