private static void RefreshByType(eDataSyncCacheType type)
{
using (DataTable dt = DataCopy.GetDataTable(ConnectionManager.GetConnection(), null, "SELECT * FROM UpdateFileEntry WHERE DataSyncCacheType = '{0}' ORDER BY DataSyncCacheID DESC", type))
{
CheckTime ct = new CheckTime();
ct.AddEvent("UpdateFileEntry SQL Done (Count = {0})", dt.Rows.Count);
if (dt.Rows.Count > 0)
{
SetLastUpdate(UpdateFileEntrySr.CreateFromDataRow(dt.Rows[0]));
}
foreach (DataRow dr in dt.Rows)
{
try
{
UpdateFileEntrySr ufe = UpdateFileEntrySr.CreateFromDataRow(dr);
if (m_diUpdates.ContainsKey(ufe.DataSyncCacheID))
{
m_diUpdates.Add(ufe.DataSyncCacheID, ufe);
}
}
catch (Exception excp)
{
m_logger.ErrorFormat("RefreshByType Row Exception:{0}\r\n{1}", excp, excp.Message, excp.StackTrace);
}
}
ct.AddEvent("RefreshByType({0}) filled up (Count = {1})", type, m_diUpdates.Count);
ct.Info(m_logger);
}
}
private void SplitCollection()
{
CheckTime ct = new CheckTime("SplitCollection() entered.");
pages.Clear();
ct.AddEvent("Cleared");
SyncList <IMatchVw> lMatches = Matches.ToSyncList();
foreach (var match in lMatches)
{
if (!pages.ContainsKey(match.StartDate))
{
pages.Add(match.StartDate, new SortableObservableCollection <IMatchVw>());
match.IsHeaderForPreMatch = true;
pages[match.StartDate].Add(match);
}
else
{
match.IsHeaderForPreMatch = false;
pages[match.StartDate].Add(match);
}
}
lMatches.Clear();
ct.AddEvent("Cycle completed");
totalPages = pages.Count;
if (pages.Count == 0)
{
SampleMatches.Clear();
return;
}
if (currentPage > pages.Count - 1)
{
currentPage = pages.Count - 1;
}
if (currentPage == 0)
{
currentPage = GetSavedPage();
}
if (pages.ElementAt(currentPage).Value.ElementAt(0) != null)
{
CurrentSeason = pages.ElementAt(currentPage).Value.ElementAt(0).VirtualSeason.ToString();
CurrentPageToShow = pages.ElementAt(currentPage).Value.ElementAt(0).VirtualDay.ToString();
}
SampleMatches.ApplyChanges(pages.ElementAt(currentPage).Value);
ct.AddEvent("ApplyChanges completed");
ct.Info(_logger);
}
public void SearchResults(SyncList <MatchResultVw> lResultsToSync, DelegateFilterResults dfr)
{
CheckTime ct = new CheckTime("SearchResults() entered");
lock (m_oReadLocker)
{
ct.AddEvent("Inside of lock");
if (lResultsToSync != null)
{
HashSet <MatchResultVw> hsMatches = new HashSet <MatchResultVw>();
SyncList <MatchResultLn> lAllResults = m_diAll.MatchResults.ToSyncList();
foreach (MatchResultLn result in lAllResults)
{
if (dfr == null || dfr(result))
{
hsMatches.Add(result.MatchResultView);
if (!lResultsToSync.Contains(result.MatchResultView))
{
lResultsToSync.Add(result.MatchResultView);
}
}
}
for (int i = 0; i < lResultsToSync.Count;)
{
MatchResultVw matchResultView = lResultsToSync[i];
if (!hsMatches.Contains(matchResultView))
{
lResultsToSync.RemoveAt(i);
}
else
{
i++;
}
}
}
}
ct.AddEvent("Completed");
ct.Info(m_logger);
}
public static bool MergeFromLineContainer(LineContainer lc)
{
CheckTime ct = new CheckTime(false, "MergeFromLineContainer() entered");
long lOperationMask = 0L;
eServerSourceType esst = eServerSourceType.BtrPre;
if (lc.Attributes.ContainsKey("line"))
{
string sLine = lc.Attributes["line"];
ExcpHelper.ThrowIf(!Enum.TryParse(sLine, true, out esst), "Cannot parse LineType from '{0}'", sLine);
}
string sType = lc.Attributes["type"];
string sMessageId = lc.Attributes["messageid"];
try
{
/*
* sTrace += string.Format("{0} docid={1}\r\n", sTrace, sMessageId);
*
* if (bExtendTrace)
* {
* sTrace += lc.BuildTraceString();
* }
*/
// TimeTypeLn
{
TimeTypeDictionary ttd = LineSr.Instance.AllObjects.GetLineObjectCollection <TimeTypeLn>() as TimeTypeDictionary;
int iCount = LineSr.MergeLineObjects <TimeTypeLn>(lc, ttd, new LineSr.MergeLineObjectsCallBack <TimeTypeLn>()
{
GetLineObject = delegate(ISerializableObject so)
{
SerializableProperty <string> spTag = so.GetSerializableProperty("Tag") as SerializableProperty <string>;
return(ttd.GetObject(spTag.Value));
},
CreateLineObject = delegate()
{
return(new TimeTypeLn());
}
});
ct.AddEvent("TimeType(s) Succeeded ({0})", iCount);
}
// ScoreTypeLn
{
ScoreTypeDictionary std = LineSr.Instance.AllObjects.GetLineObjectCollection <ScoreTypeLn>() as ScoreTypeDictionary;
int iCount = LineSr.MergeLineObjects <ScoreTypeLn>(lc, std, new LineSr.MergeLineObjectsCallBack <ScoreTypeLn>()
{
GetLineObject = delegate(ISerializableObject so)
{
SerializableProperty <string> spTag = so.GetSerializableProperty("Tag") as SerializableProperty <string>;
return(std.GetObject(spTag.Value));
},
CreateLineObject = delegate()
{
return(new ScoreTypeLn());
}
});
ct.AddEvent("ScoreType(s) Succeeded ({0})", iCount);
}
// BetTypeLn
{
BetTypeDictionary btd = LineSr.Instance.AllObjects.GetLineObjectCollection <BetTypeLn>() as BetTypeDictionary;
int iCount = LineSr.MergeLineObjects <BetTypeLn>(lc, btd, new LineSr.MergeLineObjectsCallBack <BetTypeLn>()
{
GetLineObject = delegate(ISerializableObject so)
{
SerializableProperty <string> spTag = so.GetSerializableProperty("Tag") as SerializableProperty <string>;
return(btd.GetObject(spTag.Value));
},
CreateLineObject = delegate()
{
return(new BetTypeLn());
}
});
ct.AddEvent("BetType(s) Succeeded ({0})", iCount);
}
// BetDomainTypeLn
{
BetDomainTypeDictionary bdtd = LineSr.Instance.AllObjects.GetLineObjectCollection <BetDomainTypeLn>() as BetDomainTypeDictionary;
int iCount = LineSr.MergeLineObjects <BetDomainTypeLn>(lc, bdtd, new LineSr.MergeLineObjectsCallBack <BetDomainTypeLn>()
{
GetLineObject = delegate(ISerializableObject so)
{
SerializableProperty <string> spTag = so.GetSerializableProperty("Tag") as SerializableProperty <string>;
return(bdtd.GetObject(spTag.Value));
},
CreateLineObject = delegate()
{
return(new BetDomainTypeLn());
}
});
ct.AddEvent("BetDomainType(s) Succeeded ({0})", iCount);
}
// Groups
{
GroupDictionary gd = LineSr.Instance.AllObjects.GetLineObjectCollection <GroupLn>() as GroupDictionary;
int iCount = LineSr.MergeLineObjects <GroupLn>(lc, gd, new LineSr.MergeLineObjectsCallBack <GroupLn>()
{
GetLineObject = delegate(ISerializableObject so)
{
// 143881406612
SerializableProperty <string> spType = so.GetSerializableProperty("Type") as SerializableProperty <string>;
SerializableProperty <long> spSvrId = so.GetSerializableProperty("SvrGroupId") as SerializableProperty <long>;
Debug.Assert(spType != null);
Debug.Assert(spSvrId != null);
return(gd.SafelyGetGroupByKeyName(spType.Value, spSvrId.Value));
},
CreateLineObject = delegate()
{
return(new GroupLn());
}
});
ct.AddEvent("Group(s) Succeeded ({0})", iCount);
}
// Competitors
{
CompetitorDictionary cd = LineSr.Instance.AllObjects.GetLineObjectCollection <CompetitorLn>() as CompetitorDictionary;
int iCount = LineSr.MergeLineObjects <CompetitorLn>(lc, cd, new LineSr.MergeLineObjectsCallBack <CompetitorLn>()
{
GetLineObject = delegate(ISerializableObject so)
{
SerializableProperty <long> spCompetitor = so.GetSerializableProperty("CompetitorId") as SerializableProperty <long>;
Debug.Assert(spCompetitor != null);
return(cd.GetObject(spCompetitor.Value));
},
CreateLineObject = delegate()
{
return(new CompetitorLn());
}
});
ct.AddEvent("Competitor(s) Succeeded ({0})", iCount);
}
// CompetitorToOutrightLn
{
var cd = LineSr.Instance.AllObjects.GetLineObjectCollection <CompetitorToOutrightLn>() as CompetitorToOutrightDictionary;
int iCount = LineSr.MergeLineObjects <CompetitorToOutrightLn>(lc, cd, new LineSr.MergeLineObjectsCallBack <CompetitorToOutrightLn>()
{
GetLineObject = delegate(ISerializableObject so)
{
SerializableProperty <long> spCompetitor = so.GetSerializableProperty("match2competitorid") as SerializableProperty <long>;
Debug.Assert(spCompetitor != null);
return(cd.GetObject(spCompetitor.Value));
},
CreateLineObject = delegate()
{
return(new CompetitorToOutrightLn());
}
});
ct.AddEvent("Competitor(s) Succeeded ({0})", iCount);
}
// Strings
{
TaggedStringDictionary tsd = LineSr.Instance.AllObjects.GetLineObjectCollection <TaggedStringLn>() as TaggedStringDictionary;
int iCount = LineSr.MergeLineObjects <TaggedStringLn>(lc, tsd, new LineSr.MergeLineObjectsCallBack <TaggedStringLn>()
{
GetLineObject = delegate(ISerializableObject so)
{
SerializableProperty <long> spStringId = so.GetSerializableProperty("StringId") as SerializableProperty <long>;
return(tsd.GetObject(spStringId.Value));
},
CreateLineObject = delegate()
{
return(new TaggedStringLn());
}
});
ct.AddEvent("String(s) Succeeded ({0})", iCount);
}
SyncList <MatchLn> lMatchesToRemove = new SyncList <MatchLn>();
// Matches
{
SyncHashSet <long> lMatchIds = new SyncHashSet <long>();
MatchDictionary md = LineSr.Instance.AllObjects.GetLineObjectCollection <MatchLn>() as MatchDictionary;
int iCount = LineSr.MergeLineObjects <MatchLn>(lc, md, new LineSr.MergeLineObjectsCallBack <MatchLn>()
{
GetLineObject = delegate(ISerializableObject so)
{
SerializableProperty <long> spMatchId = so.GetSerializableProperty("MatchId") as SerializableProperty <long>;
lMatchIds.Add(spMatchId.Value);
return(md.GetObject(spMatchId.Value));
},
CreateLineObject = delegate()
{
return(new MatchLn());
},
OnLineObjectMerged = delegate(MatchLn match)
{
if (match != null)
{
if (match.Code.Value == 0)
{
match.Code.Value = Math.Abs((int)(match.MatchId % 100000));
}
if (match.EndDate.Value == null)
{
match.EndDate.Value = new DateTimeSr(DateTime.MaxValue);
}
}
},
RemoveLineObject = delegate(MatchLn match)
{
lMatchesToRemove.Add(match);
}
}, ref lOperationMask);
if (sType.ToLowerInvariant() == "initial")
{
SyncList <MatchLn> lAllLiveMatches = LineSr.Instance.QuickSearchMatches(delegate(MatchLn match)
{
return(match.IsLiveBet.Value && match.SourceType == esst);
});
foreach (var match in lAllLiveMatches)
{
if (!lMatchIds.Contains(match.MatchId))
{
lMatchesToRemove.Add(match);
}
}
}
ct.AddEvent("Match(es) Succeeded ({0})", iCount);
}
// MatchToGroup items
{
MatchToGroupDictionary mtogd = LineSr.Instance.AllObjects.GetLineObjectCollection <MatchToGroupLn>() as MatchToGroupDictionary;
int iCount = LineSr.MergeLineObjects <MatchToGroupLn>(lc, mtogd, new LineSr.MergeLineObjectsCallBack <MatchToGroupLn>()
{
GetLineObject = delegate(ISerializableObject so)
{
SerializableProperty <long> spMatchId = so.GetSerializableProperty("MatchId") as SerializableProperty <long>;
SerializableProperty <long> spGroupId = so.GetSerializableProperty("GroupId") as SerializableProperty <long>;
return(mtogd.GetObject(MatchToGroupLn.GetKeyName(spMatchId.Value, spGroupId.Value)));
},
CreateLineObject = delegate()
{
return(new MatchToGroupLn());
}
});
ct.AddEvent("MatchToGroup(s) Succeeded ({0})", iCount);
}
// LiveMatchInfo
{
LiveMatchInfoDictionary lmid = LineSr.Instance.AllObjects.GetLineObjectCollection <LiveMatchInfoLn>() as LiveMatchInfoDictionary;
int iCount = LineSr.MergeLineObjects <LiveMatchInfoLn>(lc, lmid, new LineSr.MergeLineObjectsCallBack <LiveMatchInfoLn>()
{
GetLineObject = delegate(ISerializableObject so)
{
SerializableProperty <long> spMatchId = so.GetSerializableProperty("MatchId") as SerializableProperty <long>;
return(lmid.GetObject(spMatchId.Value));
},
CreateLineObject = delegate()
{
return(new LiveMatchInfoLn());
},
OnLineObjectMerged = delegate(LiveMatchInfoLn matchInfo)
{
if (matchInfo != null)
{
if (matchInfo.ExpiryDate.Value == null)
{
matchInfo.ExpiryDate.Value = new DateTimeSr(DateTime.Now.AddMinutes(30)); // Half an hour
}
if (matchInfo.ChangedProps.Contains(matchInfo.PeriodInfo))
{
lOperationMask |= (long)eOperationMask.MatchPeriodInfoChanged;
}
}
},
RemoveLineObject = delegate(LiveMatchInfoLn lmi)
{
}
});
ct.AddEvent("LiveMatchInfo(s) Succeeded ({0})", iCount);
}
// BetDomainLn
{
BetDomainDictionary bdmd = LineSr.Instance.AllObjects.GetLineObjectCollection <BetDomainLn>() as BetDomainDictionary;
int iCount = LineSr.MergeLineObjects <BetDomainLn>(lc, bdmd, new LineSr.MergeLineObjectsCallBack <BetDomainLn>()
{
GetLineObject = delegate(ISerializableObject so)
{
SerializableProperty <long> spBetDomainId = so.GetSerializableProperty("BetDomainId") as SerializableProperty <long>;
return(bdmd.GetObject(spBetDomainId.Value));
},
CreateLineObject = delegate()
{
return(new BetDomainLn());
},
RemoveLineObject = delegate(BetDomainLn bdmn)
{
LineSr.Instance.RemoveBetDomain(bdmn);
}
}, ref lOperationMask);
ct.AddEvent("BetDomain(s) Succeeded ({0})", iCount);
}
// OddLn
{
OddDictionary oddd = LineSr.Instance.AllObjects.GetLineObjectCollection <OddLn>() as OddDictionary;
int iCount = LineSr.MergeLineObjects <OddLn>(lc, oddd, new LineSr.MergeLineObjectsCallBack <OddLn>()
{
GetLineObject = delegate(ISerializableObject so)
{
SerializableProperty <long> spOutcomeId = so.GetSerializableProperty("OutcomeId") as SerializableProperty <long>;
return(oddd.GetObject(spOutcomeId.Value));
},
CreateLineObject = delegate()
{
return(new OddLn());
},
RemoveLineObject = delegate(OddLn odd)
{
odd.Active.Value = false;
//LineSr.Instance.RemoveOdd(odd);
}
});
ct.AddEvent("Odd(s) Succeeded ({0})", iCount);
}
// Process Removed matches
foreach (var match in lMatchesToRemove)
{
LiveMatchInfoLn lmi = match.LiveMatchInfo;
if (lmi.Status.Value == eMatchStatus.Ended && match.SourceType == eServerSourceType.BtrLive)
{
MergeMatchResult(match);
}
LineSr.Instance.RemoveMatch(match);
}
}
catch (Exception excp)
{
ct.AddEvent("ERROR");
m_logger.Error(excp.Message, excp);
m_logger.Excp(excp, "MergeFromLigaStavok() ERROR");
throw;
}
finally
{
//m_logger.Info(sTrace);
//m_logger.DebugFormat("LineContainer Trace Length = {0}", sTrace.Length);
ct.AddEvent("MergeFromLigaStavok(Type={0}, MessageId={1}) completed", sType, sMessageId);
ct.Info(m_logger);
}
#if DEBUG
if ((lOperationMask & EVENT_REASON_MASK) > 0)
{
m_logger.InfoFormat("MergeFromLineContainer() result {0}", lOperationMask);
}
#endif
return(true);
}
public void FromXml(XmlTextReader tr)
{
CheckTime ct = new CheckTime(false, "LineContainer.FromXml() entered.");
try
{
while (tr.Read())
{
string sCurrentTagName = tr.Name;
switch (tr.NodeType)
{
case XmlNodeType.Attribute:
break;
case XmlNodeType.Element:
while (tr.MoveToNextAttribute())
{
this.Attributes[tr.Name] = tr.Value;
}
if (sCurrentTagName == this.XmlTagName)
{
break;
}
if (!tr.IsEmptyElement)
{
try
{
Type contentType = ObjectListNameToContentType(sCurrentTagName);
SerializableObjectList lObjects = m_di.EnsureSerializableObjectList(contentType, sCurrentTagName);
lObjects.FromXml(tr);
ct.AddEvent("{0} completed", sCurrentTagName);
}
catch (Exception excp)
{
throw;
}
}
break;
case XmlNodeType.EndElement:
if (tr.Name == this.XmlTagName)
{
return;
}
break;
}
}
}
finally
{
ct.AddEvent("LineContainer.FromXml() completed.");
ct.Info(m_logger);
}
}
/*
* private static bool DeleteMatches(IDbConnection conn, IDbTransaction transaction)
* {
* LineObjectCollection<MatchLn> locMatches = LineSr.Instance.ObjectsToRemove.GetLineObjectCollection<MatchLn>();
*
* if (locMatches != null && locMatches.Count > 0)
* {
* IdentityList il = new IdentityList();
*
* foreach (MatchLn mtch in locMatches.Values)
* {
* il.AddUnique(mtch.MatchId);
* }
*
* string sMatchIds = il.FormatIds();
*
* DataCopy.ExecuteScalar(conn, transaction, DELETE_MATCH_ODDS_QUERY, sMatchIds);
* DataCopy.ExecuteScalar(conn, transaction, DELETE_MATCH_BETDOMAIN_QUERY, sMatchIds);
* DataCopy.ExecuteScalar(conn, transaction, DELETE_MATCH_TO_GROUP_QUERY, sMatchIds);
* DataCopy.ExecuteScalar(conn, transaction, DELETE_LIVE_MATCH_INFO_QUERY, sMatchIds);
* DataCopy.ExecuteScalar(conn, transaction, DELETE_MATCHES_QUERY, sMatchIds);
*
* return true;
* }
*
* return false;
* }
*/
public static eFileSyncResult UpdateDatabase(IDbConnection conn, eUpdateType eut, string sProviderDescription, UpdateStatistics us)
{
eFileSyncResult fsr = eFileSyncResult.Failed;
DateTime dtStart = DateTime.Now;
string sErrorString = string.Empty;
DataCopy dc = null;
string sUpdateDescription = eut.ToString();
CheckTime ct = new CheckTime("UpdateAll({0}) Entered", sUpdateDescription);
DictionaryOfLineObjectCollectionLight dlocToModify = LineSr.Instance.NewOrChangedObjects;
DictionaryOfLineObjectCollectionLight dlocToDelete = LineSr.Instance.ObjectsToRemove;
try
{
using (IDbTransaction transaction = conn.BeginTransaction())
{
dc = new DataCopy(conn, transaction, sUpdateDescription);
try
{
UpdatesLn updatesLn = new UpdatesLn(eut, string.Format("Saving {0} and Deleting {1} line tables", dlocToModify.Count, dlocToDelete.Count), sProviderDescription);
updatesLn.Save(conn, transaction);
Debug.Assert(updatesLn.UpdateId > 0);
// Insert or Update objects
dc.InsertOrUpdate(dlocToModify.GetLineObjectCollection <TaggedStringLn>(), TaggedStringLn.TableSpec, updatesLn);
dc.InsertOrUpdate(dlocToModify.GetLineObjectCollection <TimeTypeLn>(), TimeTypeLn.TableSpec, updatesLn);
dc.InsertOrUpdate(dlocToModify.GetLineObjectCollection <ScoreTypeLn>(), ScoreTypeLn.TableSpec, updatesLn);
dc.InsertOrUpdate(dlocToModify.GetLineObjectCollection <BetTypeLn>(), BetTypeLn.TableSpec, updatesLn);
dc.InsertOrUpdate(dlocToModify.GetLineObjectCollection <BetDomainTypeLn>(), BetDomainTypeLn.TableSpec, updatesLn);
dc.InsertOrUpdate(dlocToModify.GetLineObjectCollection <GroupLn>(), GroupLn.TableSpec, updatesLn);
dc.InsertOrUpdate(dlocToModify.GetLineObjectCollection <CompetitorLn>(), CompetitorLn.TableSpec, updatesLn);
dc.InsertOrUpdate(dlocToModify.GetLineObjectCollection <MatchLn>(), MatchLn.TableSpec, updatesLn);
dc.InsertOrUpdate(dlocToModify.GetLineObjectCollection <CompetitorToOutrightLn>(), CompetitorToOutrightLn.TableSpec, updatesLn);
dc.InsertOrUpdate(dlocToModify.GetLineObjectCollection <LiveMatchInfoLn>(), LiveMatchInfoLn.TableSpec, updatesLn);
dc.InsertOrUpdate(dlocToModify.GetLineObjectCollection <MatchResultLn>(), MatchResultLn.TableSpec, updatesLn);
dc.InsertOrUpdate(dlocToModify.GetLineObjectCollection <MatchToGroupLn>(), MatchToGroupLn.TableSpec, updatesLn);
dc.InsertOrUpdate(dlocToModify.GetLineObjectCollection <BetDomainLn>(), BetDomainLn.TableSpec, updatesLn);
dc.InsertOrUpdate(dlocToModify.GetLineObjectCollection <ResourceRepositoryLn>(), ResourceRepositoryLn.TableSpec, updatesLn);
dc.InsertOrUpdate(dlocToModify.GetLineObjectCollection <ResourceAssignmentLn>(), ResourceAssignmentLn.TableSpec, updatesLn);
dc.InsertOrUpdate(dlocToModify.GetLineObjectCollection <CompetitorInfosLn>(), CompetitorInfosLn.TableSpec, updatesLn);
dc.InsertOrUpdate(dlocToModify.GetLineObjectCollection <MatchInfosLn>(), MatchInfosLn.TableSpec, updatesLn);
dc.InsertOrUpdate(dlocToModify.GetLineObjectCollection <TournamentInfosLn>(), TournamentInfosLn.TableSpec, updatesLn);
dc.InsertOrUpdate(dlocToModify.GetLineObjectCollection <OddLn>(), OddLn.TableSpec, updatesLn);
//dc.InsertOrUpdate(dlocToModify.GetLineObjectCollection<LiabilityLn>(), LiabilityLn.TableSpec, updatesLn);
dc.InsertOrUpdate(dlocToModify.GetLineObjectCollection <LanguageLn>(), LanguageLn.TableSpec, updatesLn);
dc.InsertOrUpdate(dlocToModify.GetLineObjectCollection <MultistringGroupLn>(), MultistringGroupLn.TableSpec, updatesLn);
//dc.InsertOrUpdate(dlocToModify.GetLineObjectCollection<TournamentMatchLocksLn>(), TournamentMatchLocksLn.TableSpec, updatesLn);
// Delete Objects
dc.DeleteObjects(dlocToDelete.GetLineObjectCollection <OddLn>(), OddLn.TableSpec);
dc.DeleteObjects(dlocToDelete.GetLineObjectCollection <BetDomainLn>(), BetDomainLn.TableSpec);
dc.DeleteObjects(dlocToDelete.GetLineObjectCollection <MatchToGroupLn>(), MatchToGroupLn.TableSpec);
dc.DeleteObjects(dlocToDelete.GetLineObjectCollection <LiveMatchInfoLn>(), LiveMatchInfoLn.TableSpec);
dc.DeleteObjects(dlocToDelete.GetLineObjectCollection <CompetitorToOutrightLn>(), CompetitorToOutrightLn.TableSpec);
dc.DeleteObjects(dlocToDelete.GetLineObjectCollection <MatchLn>(), MatchLn.TableSpec);
if (dc.Statistics.IsInsrtedOrUpdatedOrDeleted)
{
// DK: If You like to test data import then uncomment line bellow:
// throw new SystemException("Developer Exception: Always rollback transaction for test purposes");
transaction.Commit();
fsr = eFileSyncResult.Succeeded;
ct.AddEvent("Commited");
}
else
{
transaction.Rollback();
fsr = eFileSyncResult.Skipped;
ct.AddEvent("Rolled Back");
}
if (us != null)
{
us.Append(dc.Statistics);
}
}
catch (Exception excp)
{
transaction.Rollback();
m_logger.Excp(excp, "UpdateAllWithSqlBulkCopy General Transaction Exception");
}
finally
{
DateTime dtEnd = DateTime.Now;
if (fsr != eFileSyncResult.Skipped)
{
// DK: Let's write to log ONLY Succeeded or Failed file syncrhonization info.
string sInfo = @"
{7} UpdateAllWithSqlBulkCopy({0}) {1}
{2}
{3}
Start: {4};
End: {5};
Time: {6};
";
m_logger.InfoFormat(
sInfo, // Format
sProviderDescription, // Provider Description
fsr, // Result
sErrorString, // Errors if any
dc.Statistics, // Statistic
dtStart,
dtEnd,
dtEnd - dtStart, // Time
sUpdateDescription); // LiveBet or PreMatch
}
else
{
m_logger.InfoFormat("{0} UpdateAllWithSqlBulkCopy Skipped. Time: {1}", sUpdateDescription, dtEnd - dtStart);
}
if (fsr == eFileSyncResult.Succeeded)
{
}
ct.AddEvent("UpdateAll({0}) completed", sUpdateDescription);
ct.Info(m_logger);
}
}
// }
}
catch (Exception excp)
{
sErrorString += ExcpHelper.FormatException(excp, "UpdateAllWithSqlBulkCopy General Exception");
m_logger.Error(sErrorString, excp);
}
return(fsr);
}
public void InsertOrUpdate <T>(LineObjectCollection <T> locLineObjects, TableSpecification ts, UpdatesLn updatesLn) where T : ILineObject <T>
{
CheckTime ct = new CheckTime(false, "InsertOrUpdate for '{0}' entered", ts.TableName);
List <object> lInserted = new List <object>();
List <object> lUpdated = new List <object>();
m_diInserted.Add(ts.TableName, lInserted);
m_diUpdated.Add(ts.TableName, lUpdated);
if (locLineObjects == null)
{
return;
}
UpdateStatistic us = m_uss.EnsureStatistic(ts.TableName);
string sInfo = string.Format("{0} table [{1}] {2}; ", m_sLiveBet, ts.TableName, locLineObjects);
#if DEBUG
int iInsertCount = 0;
int iUpdateCount = 0;
#endif
try
{
ct.AddEvent("Empty DataTables created.");
foreach (string sKey in locLineObjects.Keys)
{
using (DataCopyTables dct = DataCopyTables.GetDataCopyTables(m_conn, m_transaction, ts.TableName))
{
T obj = locLineObjects[sKey];
obj.UpdateId = updatesLn.UpdateId;
if (obj.IsNew)
{
DataRow drNew = obj.CreateDataRow(dct.InsertDataTable);
dct.InsertDataTable.Rows.Add(drNew);
lInserted.Add(obj);
}
else
{
DataRow drNew = obj.CreateDataRow(dct.UpdateDataTable);
dct.UpdateDataTable.Rows.Add(drNew);
lUpdated.Add(obj);
}
#if DEBUG
iInsertCount = dct.InsertDataTable.Rows.Count;
iUpdateCount = dct.UpdateDataTable.Rows.Count;
#endif
if (dct.InsertDataTable.Rows.Count > 0)
{
using (IDbCommand cmdInsert = GenerateInsertCommand(m_conn, m_transaction, dct.InsertDataTable, ts))
{
using (IDisposable dsp = SqlObjectFactory.CreateDbAdapter(null) as IDisposable)
{
IDbDataAdapter daInsert = dsp as IDbDataAdapter;
Debug.Assert(daInsert != null);
daInsert.InsertCommand = cmdInsert;
dct.InsertDataTable.AcceptChanges();
foreach (DataRow dr in dct.InsertDataTable.Rows)
{
dr.SetAdded();
}
using (DataSet ds = new DataSet())
{
ds.Tables.Add(dct.InsertDataTable);
daInsert.Update(ds);
}
}
}
us.InsertCount = dct.InsertDataTable.Rows.Count;
ct.AddEvent("Insert completed ({0})", dct.InsertDataTable.Rows.Count);
}
if (dct.UpdateDataTable.Rows.Count > 0)
{
using (IDbCommand cmdUpdate = GenerateUpdateCommand(m_conn, m_transaction, dct.UpdateDataTable, ts))
{
using (IDisposable dsp = SqlObjectFactory.CreateDbAdapter(null) as IDisposable)
{
IDbDataAdapter daUpdate = dsp as IDbDataAdapter;
Debug.Assert(daUpdate != null);
daUpdate.UpdateCommand = cmdUpdate;
dct.UpdateDataTable.AcceptChanges();
foreach (DataRow dr in dct.UpdateDataTable.Rows)
{
dr.SetModified();
}
using (DataSet ds = new DataSet())
{
ds.Tables.Add(dct.UpdateDataTable);
daUpdate.Update(ds);
}
}
}
us.UpdateCount = dct.UpdateDataTable.Rows.Count;
ct.AddEvent("Update completed ({0})", dct.UpdateDataTable.Rows.Count);
}
ct.AddEvent("Insert/Update filled up (I.Cnt={0}; U.Cnt={1})", dct.InsertDataTable.Rows.Count, dct.UpdateDataTable.Rows.Count);
}
}
//Debug.Assert(us.Count == arrObjects.Length);
//m_elInfo.AddFormat("{0} Result: Succeeded; Inserted: {1}; Updated: {2}; Skipped; {3}", sInfo, us.InsertCount, us.UpdateCount, us.SkipCount);
}
catch (Exception excp)
{
m_elInfo.AddFormat("{0} Result: FAILED; Inserted: {1}; Updated: {2};", sInfo, us.InsertCount, us.UpdateCount);
#if DEBUG
if (typeof(T) == typeof(TaggedStringLn))
{
FindDuplucates(locLineObjects);
}
int iCount = 0;
string sObjectList = string.Format("ERROR objects (Count={0})\r\n", locLineObjects.Count);
foreach (T obj in locLineObjects.Values)
{
sObjectList += obj.ToString() + "\r\n";
if (++iCount > MAX_ERROR_LIST_COUNT)
{
sObjectList += string.Format("And More {0} objects not listed", locLineObjects.Count - iCount);
break;
}
}
m_logger.Error(sObjectList, excp);
#endif
ExcpHelper.ThrowUp(excp, "ERROR InsertOrUpdate() for {0}", locLineObjects);
}
finally
{
ct.AddEvent("InsertOrUpdate for '{0}' completed", ts.TableName);
ct.Info(m_logger);
}
}
public static eFileSyncResult SyncRoutines(eUpdateType eut, string sProviderDescription, bool bUseDatabase, UpdateStatistics us, DelegateMerge dm)
{
Debug.Assert(dm != null);
CheckTime ct = new CheckTime(true, "SyncRoutines(UseDatabase={0}) entered", bUseDatabase);
/*
* if (DalStationSettings.Instance.EnableRunProcessControl)
* {
* string sInfo = SystemControl.GetSystemInfo() + "\r\n" + ProcessControl.Current.ToDetailedString();
* m_logger.Info(sInfo);
*
#if DEBUG
* m_logger.Info(ProcessControl.Current.GetThreadSummary());
#endif
*
* ct.AddEvent("Control completed");
* }
*/
try
{
eFileSyncResult fsr = eFileSyncResult.Failed;
lock (m_oUpdateLocker)
{
ct.AddEvent("Inside of lock");
LineSr.Instance.NewOrChangedObjects.UnsetPropertiesChanged();
LineSr.Instance.NewOrChangedObjects.Clear();
bool bProcessUpdateSucceeded = false;
lock (m_oReadLocker)
{
ct.AddEvent("Cache Update Started");
bProcessUpdateSucceeded = dm(null);
ct.AddEvent("Cache Update Completed ({0}, {1})", LineSr.Instance.NewOrChangedObjects.Count, LineSr.Instance.ObjectsToRemove.Count);
}
if (bUseDatabase)
{
// We use database to store Live Data
fsr = DataCopy.UpdateDatabase(ConnectionManager.GetConnection(), eut, sProviderDescription, us);
ct.AddEvent("Database Update Completed");
if (fsr == eFileSyncResult.Succeeded)
{
LineSr.Instance.NewOrChangedObjects.NotifyPropertiesChanged();
DatabaseCache.Instance.AddNewObjectsAfterCommit();
DatabaseCache.Instance.RemoveObjectsAfterCommit();
LineSr.Instance.ObjectsToRemove.Clear();
ct.AddEvent("Routines Completed (fsr=Succeeded)");
}
else
{
ct.AddEvent("Routines Completed (fsr=Skipped or Failed)");
}
}
else
{
// We DON'T use database to store Live Data
fsr = eFileSyncResult.Succeeded;
LineSr.Instance.NewOrChangedObjects.NotifyPropertiesChanged();
ct.AddEvent("Routines Completed");
}
if (fsr == eFileSyncResult.Succeeded && bProcessUpdateSucceeded)
{
ct.AddEvent("ProcessDataSqlUpdateSucceeded() Completed");
}
}
return(fsr);
}
catch (Exception excp)
{
LineSr.Instance.ObjectsToRemove.Clear();
m_logger.Excp(excp, "SyncRoutines(eUpdateType={0}, sProviderDescription='{1}') ERROR", eut, sProviderDescription);
ct.AddEvent("Exception Completed");
ct.Error(m_logger);
}
finally
{
ct.AddEvent("Completed");
ct.Info(m_logger);
}
return(eFileSyncResult.Failed);
}
public void VerifySelectedOdds(SortableObservableCollection <ITipItemVw> socSelectedOdds, SyncHashSet <ITipItemVw> hsOddsToRemove = null)
{
CheckTime ct = new CheckTime(true, "VerifySelectedOdds(TipCount={0})", socSelectedOdds.Count);
ExcpHelper.ThrowIf <ArgumentNullException>(socSelectedOdds == null, "VerifySelectedOdds(NULL) ERROR");
lock (_verifyLocker)
{
ct.AddEvent("Lock Entered");
if (hsOddsToRemove != null)
{
hsOddsToRemove.Clear();
}
else
{
hsOddsToRemove = new SyncHashSet <ITipItemVw>();
}
SyncList <ITipItemVw> lTipItems = socSelectedOdds.ToSyncList();
foreach (TipItemVw tiv in lTipItems)
{
// Check if selected odd is not expired
if (!CheckOdd(tiv.Odd))
{
hsOddsToRemove.Add(tiv);
}
// Check if selected odd is not yet in current collection (m_lSelectedOdds)
else if (!m_lSelectedOdds.Contains(tiv.Odd))
{
m_lSelectedOdds.Add(tiv.Odd);
tiv.Odd.BetDomain.Match.SetSelected(tiv.Odd, true);
}
}
ct.AddEvent("Check Completed");
// Remove from socSelectedOdds and m_lSelectedOdds
for (int i = 0; i < lTipItems.Count;)
{
var tiv = lTipItems[i];
if (hsOddsToRemove.Contains(tiv))
{
// This Odd is expired
lTipItems.Remove(tiv);
socSelectedOdds.Remove(tiv);
m_lSelectedOdds.Remove(tiv.Odd);
tiv.Odd.BetDomain.Match.SetSelected(tiv.Odd, false);
}
else
{
i++;
}
}
ct.AddEvent("Remove from List Completed");
// Remove from m_lSelectedOdd those items were not removed in previous cycle
for (int i = 0; i < m_lSelectedOdds.Count;)
{
IOddLn odd = m_lSelectedOdds[i];
TipItemVw tiv = new TipItemVw(odd);
if (!lTipItems.Contains(tiv))
{
m_lSelectedOdds.Remove(odd);
tiv.Odd.BetDomain.Match.SetSelected(tiv.Odd, false);
}
else
{
i++;
}
}
ct.AddEvent("Remove from List2 Completed");
}
ct.Info(m_logger);
}
public void SearchMatches(SyncList <IMatchVw> lMatchesToSync, string sSearch, string sLanguage, DelegateFilterMatches dfm)
{
CheckTime ct = new CheckTime(false, "SearchMatches('{0}', '{1}') entered", sSearch, sLanguage);
lock (m_oReadLocker)
{
if (lMatchesToSync != null)
{
HashSet <IMatchVw> hsMatches = new HashSet <IMatchVw>();
SyncList <MatchLn> lAllMatches = m_diAll.Matches.ToSyncList();
if (!string.IsNullOrEmpty(sSearch))
{
ct.AddEvent("Search by string in {0} matches", lAllMatches.Count);
IdentityList ilGroups = new IdentityList();
IdentityList ilCompetitors = new IdentityList();
m_diAll.TaggedStrings.SearchRelatedStrings(sSearch, sLanguage, ilGroups, ilCompetitors);
int iCode = 0;
bool bIsNumber = int.TryParse(sSearch, out iCode) && 0 < iCode && iCode < MAX_MATCH_CODE;
if (ilCompetitors.Count > 0 || bIsNumber)
{
foreach (var mtch in lAllMatches)
{
#if DEBUG || TRACE_ID_FROM_FILE
if (TraceHelper.TraceFromFileLongValues("MatchIds.txt", (long)mtch.MatchId, new TraceHelper.DelegateLongFromRegistryFound(MatchIdFromFileFound), mtch))
{
// Put breakpoint here to catch certain match by mtch.MatchId
}
#endif
string sCode = mtch.Code.Value.ToString("G");
if (sCode.IndexOf(sSearch, StringComparison.OrdinalIgnoreCase) >= 0 || ilCompetitors.Contains(mtch.HomeCompetitorId.Value) || ilCompetitors.Contains(mtch.AwayCompetitorId.Value))
{
SearchMatchImp(hsMatches, lMatchesToSync, mtch, dfm);
}
//else
//{
// SyncList<GroupLn> lGroups = LineSr.Instance.AllObjects.MatchesToGroups.GetMatchGroups(mtch.MatchId);
// foreach (GroupLn group in lGroups)
// {
// if (ilGroups.Contains(group.GroupId))
// {
// SearchMatchImp(hsMatches, lMatchesToSync, mtch, dfm);
// }
// }
//}
}
}
}
else
{
ct.AddEvent("Search directly in {0} matches", lAllMatches.Count);
foreach (var mtch in lAllMatches)
{
#if DEBUG || TRACE_ID_FROM_FILE
if (TraceHelper.TraceFromFileLongValues("MatchIds.txt", (long)mtch.MatchId, new TraceHelper.DelegateLongFromRegistryFound(MatchIdFromFileFound), mtch))
{
// Put breakpoint here to catch certain match by mtch.MatchId
}
#endif
SearchMatchImp(hsMatches, lMatchesToSync, mtch, dfm);
}
}
ct.AddEvent("Search Completed");
for (int i = 0; i < lMatchesToSync.Count;)
{
IMatchVw matchView = lMatchesToSync[i];
if (!hsMatches.Contains(matchView))
{
lMatchesToSync.RemoveAt(i);
}
else
{
i++;
}
}
ct.AddEvent("Remove Completed");
}
}
ct.AddEvent("Completed (Found {0} match(es))", lMatchesToSync.Count);
ct.Info(m_logger);
}