public virtual void UpdateCaseList(CaseListUpdate listupdate)
{
try
{
lock (m_UpdateCaseListLock)
{
foreach (String awsId in connectionList.Keys)
{
ICaseRequestManagerCallback callback = connectionList[awsId];
try
{
callback.UpdatedCaseList(listupdate);
}
catch (Exception)
{
connectionList.Remove(awsId);
}
}
}
}
catch (Exception ex)
{
throw;
}
}
public override void UpdatedCaseList(CaseListUpdate updatelist)
{
if (updatelist.state == CaseListUpdateState.Add)
{
//caseList.Merge(updatelist.dsCaseList);
foreach (CaseListDataSet.CaseListTableRow row in updatelist.dsCaseList.CaseListTable.Rows)
{
try
{
lock (caseList.CaseListLock)
{
caseList.List.CaseListTable.AddCaseListTableRow(row.CaseId, row.AnalystComment, row.ObjectId, row.FlightNumber,
row.Analyst, row.CaseDirectory, row.ReferenceImage, row.Result,
row.UpdateTime, row.Archived, row.AnalysisTime, row.CreateTime, row.Area, row.Image, row.CTI, row.AssignedId);
}
}
catch (ConstraintException exp)
{
logger.listBox1.Dispatcher.Invoke(DispatcherPriority.Normal,
new Action(
delegate()
{
logger.listBox1.Items.Add("Exp: " + exp.ToString());
}));
}
}
}
else if (updatelist.state == CaseListUpdateState.Delete)
{
foreach (DataRow row in updatelist.dsCaseList.CaseListTable.Rows)
{
string caseId = row[updatelist.dsCaseList.CaseListTable.CaseIdColumn, DataRowVersion.Original].ToString();
bool refImg = (bool)row[updatelist.dsCaseList.CaseListTable.ReferenceImageColumn, DataRowVersion.Original];
DataRow foundRow = caseList.List.CaseListTable.FindByCaseIdReferenceImage(caseId, refImg);
if (foundRow != null)
{
foundRow.Delete();
}
}
}
else if (updatelist.state == CaseListUpdateState.Modify)
{
foreach (DataRow row in updatelist.dsCaseList.CaseListTable.Rows)
{
string caseId = row[updatelist.dsCaseList.CaseListTable.CaseIdColumn, DataRowVersion.Original].ToString();
bool refImg = (bool)row[updatelist.dsCaseList.CaseListTable.ReferenceImageColumn, DataRowVersion.Original];
DataRow foundRow = caseList.List.CaseListTable.FindByCaseIdReferenceImage(caseId, refImg);
if (foundRow != null)
{
foundRow.ItemArray = row.ItemArray;
}
}
}
//caseList.AcceptChanges();
}
public virtual void OnNext(CaseList caselist)
{
DataRowVersion rowVersion;
CaseListDataSet List;
CaseListUpdateState caseListState;
if ((List = (CaseListDataSet)caselist.List.GetChanges(DataRowState.Deleted)) != null)
{
caseListState = CaseListUpdateState.Delete;
rowVersion = DataRowVersion.Original;
}
else if ((List = (CaseListDataSet)caselist.List.GetChanges(DataRowState.Modified)) != null)
{
caseListState = CaseListUpdateState.Modify;
rowVersion = DataRowVersion.Current;
}
else if ((List = (CaseListDataSet)caselist.List.GetChanges(DataRowState.Added)) != null)
{
caseListState = CaseListUpdateState.Add;
rowVersion = DataRowVersion.Current;
}
else
{
return;
}
if (caseListState != CaseListUpdateState.Delete && !_sendCaseListThumbnail)
{
foreach (CaseListDataSet.CaseListTableRow row in caselist.List.CaseListTable.Rows)
{
row.SetImageNull();
}
}
if (logger != null)
{
logger.Print("caselist " + caseListState + " :");
foreach (DataRow row in List.CaseListTable.Rows)
{
foreach (DataColumn col in List.CaseListTable.Columns)
{
logger.Print(row[col, rowVersion] + " ");
}
logger.PrintLine();
}
}
CaseListUpdate listupdate = new CaseListUpdate(List, caseListState);
UpdateCaseList(listupdate);
}
public override void UpdateCaseList(CaseListUpdate listupdate)
{
List <String> callbacks = new List <String>();
lock (m_ClientListLock)
{
foreach (String key in m_Callbacks.Keys)
{
try
{
m_Callbacks[key].Callback.UpdatedCaseList(listupdate);
}
catch
{
callbacks.Add(key);
}
}
}
RemoveCallBacks(callbacks);
}
public virtual void UpdatedCaseList(CaseListUpdate listupdate)
{
}
public void UpdatedCaseList(CaseListUpdate listUpdate)
{
if (listUpdate.state == CaseListUpdateState.Add)
{
//m_CaseList.Merge(listUpdate.dsCaseList);
foreach (CaseListDataSet.CaseListTableRow row in listUpdate.dsCaseList.CaseListTable.Rows)
{
try
{
lock (m_CaseListLock)
{
m_CaseList.CaseListTable.AddCaseListTableRow(row.CaseId, row.AnalystComment, row.ObjectId, row.FlightNumber,
row.Analyst, row.CaseDirectory, row.ReferenceImage, row.Result,
row.UpdateTime, row.Archived, row.AnalysisTime, row.CreateTime, row.Area, row.Image, row.CTI, row.AssignedId, row.DFCMatch);
}
}
catch (Exception ex)
{
}
}
}
else if (listUpdate.state == CaseListUpdateState.Delete)
{
foreach (DataRow row in listUpdate.dsCaseList.CaseListTable.Rows)
{
String caseId = row[listUpdate.dsCaseList.CaseListTable.CaseIdColumn, DataRowVersion.Original].ToString();
Boolean IsReference = (Boolean)row[listUpdate.dsCaseList.CaseListTable.ReferenceImageColumn, DataRowVersion.Original];
DataRow foundRow = m_CaseList.CaseListTable.FindByCaseIdReferenceImage(caseId, IsReference);
if (foundRow != null)
{
foundRow.Delete();
}
}
}
else if (listUpdate.state == CaseListUpdateState.Modify)
{
foreach (CaseListDataSet.CaseListTableRow row in listUpdate.dsCaseList.CaseListTable.Rows)
{
String caseId = row[listUpdate.dsCaseList.CaseListTable.CaseIdColumn].ToString();
Boolean IsReference = (Boolean)row[listUpdate.dsCaseList.CaseListTable.ReferenceImageColumn];
CaseListDataSet.CaseListTableRow foundRow = m_CaseList.CaseListTable.FindByCaseIdReferenceImage(caseId, IsReference);
if (foundRow != null)
{
foundRow.BeginEdit();
if (foundRow.ObjectId != row.ObjectId && !String.IsNullOrWhiteSpace(row.ObjectId))
{
foundRow.ObjectId = row.ObjectId;
}
if (foundRow.FlightNumber != row.FlightNumber && !String.IsNullOrWhiteSpace(row.FlightNumber))
{
foundRow.FlightNumber = row.FlightNumber;
}
if (foundRow.Analyst != row.Analyst && !String.IsNullOrWhiteSpace(row.Analyst))
{
foundRow.Analyst = row.Analyst;
}
if (foundRow.AnalystComment != row.AnalystComment && !String.IsNullOrWhiteSpace(row.AnalystComment))
{
foundRow.AnalystComment = row.AnalystComment;
}
if (foundRow.AnalysisTime != row.AnalysisTime)
{
foundRow.AnalysisTime = row.AnalysisTime;
}
if (foundRow.CaseDirectory != row.CaseDirectory && !String.IsNullOrWhiteSpace(row.CaseDirectory))
{
foundRow.CaseDirectory = row.CaseDirectory;
}
if (foundRow.Result != row.Result)
{
foundRow.Result = row.Result;
}
if (foundRow.UpdateTime != row.UpdateTime && row.UpdateTime != null)
{
foundRow.UpdateTime = row.UpdateTime;
}
if (foundRow.Archived != row.Archived)
{
foundRow.Archived = row.Archived;
}
if (foundRow.Image != row.Image && row.Image != null)
{
foundRow.Image = row.Image;
}
if (foundRow.CreateTime != row.CreateTime)
{
foundRow.CreateTime = row.CreateTime;
}
if (foundRow.Area != row.Area && !String.IsNullOrWhiteSpace(row.Area))
{
foundRow.Area = row.Area;
}
if (foundRow.CTI != row.CTI)
{
foundRow.CTI = row.CTI;
}
if (foundRow.AssignedId != row.AssignedId && row.AssignedId != null)
{
foundRow.AssignedId = row.AssignedId;
}
if (foundRow.DFCMatch != row.DFCMatch)
{
foundRow.DFCMatch = row.DFCMatch;
}
foundRow.EndEdit();
}
}
}
}
public void SendCaseList(String awsID, CaseList caselist)
{
int CaseListCount = caselist.List.CaseListTable.Count;
int currentRowIndex = 0;
CaseListDataSet.CaseListTableRow CurrentRow = null;
if (CaseListCount > 0)
{
CurrentRow = (CaseListDataSet.CaseListTableRow)caselist.List.CaseListTable.Rows[currentRowIndex];
}
while (CaseListCount > 0)
{
CaseListDataSet dataset = new CaseListDataSet();
int MaxIndexValue;
//lock caselist
lock (caselist.CaseListLock)
{
currentRowIndex = caselist.List.CaseListTable.Rows.IndexOf(CurrentRow);
if (CaseListCount > MaxNumCasesPerBatch)
{
MaxIndexValue = currentRowIndex + MaxNumCasesPerBatch;
}
else
{
MaxIndexValue = currentRowIndex + CaseListCount;
}
for (int i = currentRowIndex; i < MaxIndexValue; i++)
{
CaseListDataSet.CaseListTableRow row = (CaseListDataSet.CaseListTableRow)caselist.List.CaseListTable.Rows[i];
dataset.CaseListTable.AddCaseListTableRow(row.CaseId, row.AnalystComment, row.ObjectId, row.FlightNumber,
row.Analyst, row.CaseDirectory, row.ReferenceImage, row.Result,
row.UpdateTime, row.Archived, row.AnalysisTime, row.CreateTime, row.Area, row.Image, row.CTI, row.AssignedId, row.DFCMatch);
}
if (CaseListCount > MaxNumCasesPerBatch)
{
CaseListCount = CaseListCount - MaxNumCasesPerBatch;
currentRowIndex = currentRowIndex + MaxNumCasesPerBatch;
CurrentRow = (CaseListDataSet.CaseListTableRow)caselist.List.CaseListTable.Rows[currentRowIndex];
}
else
{
CaseListCount = CaseListCount - CaseListCount;
}
//unlock caselist
}
try
{
CaseListUpdate listupdate = new CaseListUpdate(dataset, CaseListUpdateState.Add);
ICaseRequestManagerCallback callback = connectionList[awsID];
lock (m_UpdateCaseListLock)
{
callback.UpdatedCaseList(listupdate);
}
}
catch (Exception exp)
{
if (logger != null)
{
logger.PrintLine("SendCaseList exp: " + exp);
}
connectionList.Remove(awsID);
break;
}
}
if (logger != null)
{
logger.PrintInfoLine("SendCaseList in chunks to " + awsID + " Done.");
}
}
