public void SimpleChunkCompressTest()
{
ChunkByteArray zip = BinaryCompressor.Zip(new ChunkByteArray(new byte[] { 1 }));
ChunkByteArray result = BinaryCompressor.Unzip(zip);
Assert.AreEqual(1, result[0]);
}
public ViewDTO GetCachedView(string sessionId, long layoutId, string lang)
{
try
{
m_ViewSemaphore.Wait();
Console.WriteLine(" Waited {0} tics for the semaphore", (DateTime.Now.Ticks - m_Ticks) / 100000 * 100000);
Thread.Sleep(100);
byte[] viewBytes = BinarySerializer.SerializeFromString(SerializedViewStub.ViewXml);
byte[] viewZippedBytes = BinaryCompressor.Zip(viewBytes);
DataTable sourceData = DataTableSerializer.Deserialize(SerializedViewStub.DataXml);
BaseTableDTO serializedDTO = BinarySerializer.SerializeFromTable(sourceData);
BaseTableDTO zippedDTO = BinaryCompressor.Zip(serializedDTO);
var result = new ViewDTO(zippedDTO, viewZippedBytes);
return(result);
}
finally
{
m_ViewSemaphore.Release();
}
}
public void SerializeIntegrationArchiveTest()
{
QueryTableModel tableModel;
using (var manager = new DbManager(new SqlDataProvider(), Config.GetSetting("TestConnectionString")))
{
using (DbManager command = manager.SetCommand(@"select * from dbo.AVR_HumanCaseReport"))
{
tableModel = BinarySerializer.SerializeFromCommand(command, 123, "en", true, 10);
}
}
Assert.AreEqual(54, tableModel.Header.RowCount);
Assert.AreEqual(true, tableModel.UseArchivedData);
Assert.AreEqual(true, tableModel.Header.IsArchive);
QueryTablePacketDTO zippedHeader = BinaryCompressor.Zip(tableModel.Header);
Assert.AreEqual(true, zippedHeader.IsArchive);
List <QueryTablePacketDTO> zippedBody = tableModel.BodyPackets.Select(BinaryCompressor.Zip).ToList();
Assert.IsFalse(zippedBody.Any(p => !p.IsArchive));
QueryTablePacketDTO unzipedHeader = BinaryCompressor.Unzip(zippedHeader);
Assert.AreEqual(true, unzipedHeader.IsArchive);
List <QueryTablePacketDTO> unzippedBody = zippedBody.Select(BinaryCompressor.Unzip).ToList();
Assert.IsFalse(unzippedBody.Any(p => !p.IsArchive));
}
public void ZeroChunkCompressTest()
{
ChunkByteArray zip = BinaryCompressor.Zip(new ChunkByteArray(new byte[0]));
ChunkByteArray result = BinaryCompressor.Unzip(zip);
Assert.AreEqual(0, result.Length);
}
public ChartExportDTO ExportChartToJpg(ChartTableDTO zippedData, object syncLock)
{
Utils.CheckNotNull(zippedData, "zippedData");
if (m_ChartDetail == null)
{
throw new AvrException("Chart already disposed.");
}
BaseTableDTO unzippedData = BinaryCompressor.Unzip(zippedData);
DataTable data = BinarySerializer.DeserializeToTable(unzippedData);
if (zippedData.TextPatterns != null)
{
foreach (string col in zippedData.TextPatterns.Keys)
{
data.Columns[col].ExtendedProperties.Add("TextPattern", zippedData.TextPatterns[col]);
}
}
ChartExportDTO result;
lock (syncLock)
{
m_ChartDetail.DataSource = data;
object id = zippedData.ViewId;
m_ChartDetail.LoadData(ref id);
m_ChartDetail.ChartControlSize = new Size(zippedData.Width, zippedData.Height);
result = m_ChartDetail.ExportToJpgBytes(zippedData.ChartSettings, zippedData.ChartType);
}
return(result);
}
public void StringCompressTest()
{
const string source = "sdfwsf234349785423\\'dfg;5;425n\\фффыыыы```";
byte[] zip = BinaryCompressor.ZipString(source);
string result = BinaryCompressor.UnzipString(zip);
Assert.AreEqual(source, result);
}
public void SerializeZipViewTableTest()
{
DataTable sourceData = DataTableSerializer.Deserialize(SerializedViewStub.DataXml);
BaseTableDTO serializedDTO = BinarySerializer.SerializeFromTable(sourceData, 10000);
BaseTableDTO zippedDTO = BinaryCompressor.Zip(serializedDTO);
BaseTableDTO unzippedDTO = BinaryCompressor.Unzip(zippedDTO);
DataTable resultData = BinarySerializer.DeserializeToTable(unzippedDTO);
AssertTablesAreEqual(sourceData, resultData);
}
public QueryTableHeaderModel(QueryTableHeaderDTO headerDTO)
{
QueryCacheId = headerDTO.QueryCacheId;
PacketCount = headerDTO.PacketCount;
QueryTablePacketDTO unzipedHeader = BinaryCompressor.Unzip(headerDTO.BinaryHeader);
List <BaseColumnModel> deserializedHeader = BinarySerializer.DeserializeHeader(unzipedHeader);
ColumnTypeByName = deserializedHeader;
ColumnTypes = deserializedHeader.Select(c => c.FinalType).ToArray();
}
public void TableCompressTest()
{
var source = new QueryTableModel(123, "en")
{
Header = new QueryTablePacketDTO
{
RowCount = 1,
BinaryBody = new ChunkByteArray(new byte[] { 1, 2, 3 }),
IsArchive = true
},
BodyPackets = new List <QueryTablePacketDTO>
{
new QueryTablePacketDTO
{
RowCount = 2,
BinaryBody = new ChunkByteArray(new byte[] { 4, 5, 6, 7, 8, 9 }),
IsArchive = false
},
new QueryTablePacketDTO
{
RowCount = 3,
BinaryBody = new ChunkByteArray(new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 10 }),
IsArchive = true
},
}
};
QueryTableModel zip = BinaryCompressor.Zip(source);
QueryTableModel result = BinaryCompressor.Unzip(zip);
Assert.AreEqual(source.Header.RowCount, result.Header.RowCount);
Assert.AreEqual(source.Language, result.Language);
Assert.AreEqual(source.QueryId, result.QueryId);
Assert.AreEqual(source.Header.BinaryBody.Length, result.Header.BinaryBody.Length);
for (int i = 0; i < source.Header.BinaryBody.Length; i++)
{
Assert.AreEqual(source.Header.BinaryBody[i], result.Header.BinaryBody[i]);
}
Assert.AreEqual(source.BodyPackets.Count, result.BodyPackets.Count);
for (int i = 0; i < source.BodyPackets.Count; i++)
{
var sourcePacket = source.BodyPackets[i];
var resultPacket = result.BodyPackets[i];
Assert.AreEqual(sourcePacket.BinaryBody.Length, resultPacket.BinaryBody.Length);
for (int j = 0; j < sourcePacket.BinaryBody.Length; j++)
{
Assert.AreEqual(sourcePacket.BinaryBody[j], resultPacket.BinaryBody[j]);
}
}
}
private static ViewDTO GetCachedView()
{
byte[] viewBytes = BinarySerializer.SerializeFromString(SerializedViewStub.ViewXml);
byte[] viewZippedBytes = BinaryCompressor.Zip(viewBytes);
DataTable sourceData = DataTableSerializer.Deserialize(SerializedViewStub.DataXml);
BaseTableDTO serializedDTO = BinarySerializer.SerializeFromTable(sourceData);
BaseTableDTO zippedDTO = BinaryCompressor.Zip(serializedDTO);
var result = new ViewDTO(zippedDTO, viewZippedBytes);
return(result);
}
public void ComplexCompressTest()
{
const int length = 1000000;
var source = new byte[length];
new Random().NextBytes(source);
byte[] zip = BinaryCompressor.Zip(source);
byte[] result = BinaryCompressor.Unzip(zip);
Assert.AreEqual(source.Length, result.Length);
for (int i = 0; i < length; i++)
{
Assert.AreEqual(source[i], result[i]);
}
}
public void TableEmptyCompressTest()
{
var source = new QueryTableModel(123, "en");
QueryTableModel zip = BinaryCompressor.Zip(source);
QueryTableModel result = BinaryCompressor.Unzip(zip);
Assert.AreEqual(0, result.Header.RowCount);
Assert.AreEqual(source.Header.RowCount, result.Header.RowCount);
Assert.AreEqual(source.Language, result.Language);
Assert.AreEqual(source.QueryId, result.QueryId);
Assert.AreEqual(source.UseArchivedData, result.UseArchivedData);
Assert.AreEqual(source.Header.BinaryBody.Length, result.Header.BinaryBody.Length);
Assert.AreEqual(0, result.Header.BinaryBody.Length);
}
public AVRFacadeStub(long queryCacheId, int multiplier = 1)
{
QueryTableModel tableModel;
using (DbManagerProxy manager = DbManagerFactory.Factory.Create())
{
using (DbManager command = manager.SetCommand(@"select * from dbo.AVR_HumanCaseReport"))
{
tableModel = BinarySerializer.SerializeFromCommand(command, 123, "en", false, 10);
}
}
m_ZippedBody = tableModel.BodyPackets.Select(BinaryCompressor.Zip).ToList();
m_ZippedHeader = new QueryTableHeaderDTO(BinaryCompressor.Zip(tableModel.Header), queryCacheId, m_ZippedBody.Count * multiplier);
}
public void SerializeZipViewStrictureTest()
{
byte[] serializedView = BinarySerializer.SerializeFromString(SerializedViewStub.ViewXml);
byte[] zippedView = BinaryCompressor.Zip(serializedView);
byte[] unzippedView = BinaryCompressor.Unzip(zippedView);
Assert.AreEqual(serializedView.Length, unzippedView.Length);
for (int i = 0; i < serializedView.Length; i++)
{
Assert.AreEqual(serializedView[i], unzippedView[i]);
}
string viewXml = BinarySerializer.DeserializeToString(unzippedView);
Assert.AreEqual(SerializedViewStub.ViewXml, viewXml);
}
public void SerializeZipHumanTableTest()
{
DataTable sourceData;
using (new StopwathTransaction("+++ Select from DB +++"))
{
using (var manager = new DbManager(new SqlDataProvider(), Config.GetSetting("EidssConnectionString")))
{
using (DbManager command = manager.SetCommand(@"select * from fn_AVR_HumanCaseReport('en')"))
{
command.Command.CommandTimeout = 120;
sourceData = command.ExecuteDataTable();
}
}
}
BaseTableDTO serializedDTO;
using (new StopwathTransaction("+++ SerializeFromTable +++"))
{
serializedDTO = BinarySerializer.SerializeFromTable(sourceData, 10000);
}
BaseTableDTO zippedDTO;
using (new StopwathTransaction("+++ ZipFromTable +++"))
{
zippedDTO = BinaryCompressor.Zip(serializedDTO);
}
BaseTableDTO unzippedDTO;
using (new StopwathTransaction("+++ UnzipFromTable +++"))
{
unzippedDTO = BinaryCompressor.Unzip(zippedDTO);
}
DataTable resultData;
using (new StopwathTransaction("+++ DeserializeToTable +++"))
{
resultData = BinarySerializer.DeserializeToTable(unzippedDTO);
}
AssertTablesAreEqual(sourceData, resultData);
}
public void PacketCompressTest()
{
var source = new QueryTablePacketDTO
{
RowCount = 1,
BinaryBody = new ChunkByteArray(new byte[] { 1, 2, 3 }),
IsArchive = true
};
QueryTablePacketDTO zip = BinaryCompressor.Zip(source);
QueryTablePacketDTO result = BinaryCompressor.Unzip(zip);
Assert.AreEqual(source.RowCount, result.RowCount);
Assert.AreEqual(source.BinaryBody.Length, result.BinaryBody.Length);
Assert.AreEqual(source.IsArchive, result.IsArchive);
for (int i = 0; i < source.BinaryBody.Length; i++)
{
Assert.AreEqual(source.BinaryBody[i], result.BinaryBody[i]);
}
}
public static QueryTableModel GetQueryResult(long queryId, string lang, bool isArchive)
{
string queryString;
QueryTableModel zippedTable;
var watch = new Stopwatch();
watch.Start();
m_Trace.Trace(TraceTitle, "Executing actual query '{0}' for lang '{1}'", queryId, lang);
using (DbManagerProxy manager = DbManagerFactory.Factory.Create())
{
queryString = QueryHelper.GetQueryText(manager, queryId, false);
QueryTableModel serializedTable = QueryHelper.GetInnerQueryResult(manager, queryString, lang,
c => BinarySerializer.SerializeFromCommand(c, queryId, lang, false));
zippedTable = BinaryCompressor.Zip(serializedTable);
}
if (isArchive)
{
m_Trace.Trace(TraceTitle, "Executing archive query '{0}' for lang '{1}'", queryId, lang);
using (DbManagerProxy archiveManager = DbManagerFactory.Factory[DatabaseType.Archive].Create())
{
using (DbManagerProxy manager = DbManagerFactory.Factory.Create())
{
QueryHelper.DropAndCreateArchiveQuery(manager, archiveManager, queryId);
}
QueryTableModel serializedArchiveTable = QueryHelper.GetInnerQueryResult(archiveManager, queryString, lang,
c => BinarySerializer.SerializeFromCommand(c, queryId, lang, true));
QueryTableModel zippedArchiveTable = BinaryCompressor.Zip(serializedArchiveTable);
zippedTable.UseArchivedData = true;
foreach (QueryTablePacketDTO packet in zippedArchiveTable.BodyPackets)
{
packet.IsArchive = true;
zippedTable.BodyPackets.Add(packet);
}
}
}
m_Trace.Trace(TraceTitle, "Executing query '{0}' for lang '{1}' finished, duration={2},", queryId, lang, watch.Elapsed);
return(zippedTable);
}
private static DataSet GetPivotDataSet()
{
var dataSet = new LayoutDetailDataSet {
EnforceConstraints = false
};
LayoutDetailDataSet.LayoutRow row = dataSet.Layout.NewLayoutRow();
row.idflLayout = 1;
row.idflQuery = 1;
row.idfPerson = 1;
row.strPivotGridSettings = "xxx";
row.blbPivotGridSettings = BinaryCompressor.ZipString(row.strPivotGridSettings);
row.strLayoutName = Guid.NewGuid().ToString();
row.strDefaultLayoutName = Guid.NewGuid().ToString();
dataSet.Layout.AddLayoutRow(row);
dataSet.AcceptChanges();
return(dataSet);
}
public void ZlibLayoutTest()
{
string streamXml;
using (PresenterFactory.BeginSharedPresenterTransaction(m_Container, new BaseForm()))
{
using (var pivotGrid = new AvrPivotGrid())
{
var dataTable = new AvrDataTable(DataHelper.GenerateTestTable());
pivotGrid.SetDataSourceAndCreateFields(dataTable);
streamXml = ViewReportTests.GetLayoutXml(pivotGrid);
}
}
byte[] bytes = BinaryCompressor.ZipString(streamXml);
string uncompressed = BinaryCompressor.UnzipString(bytes);
Assert.AreEqual(streamXml, uncompressed);
}
public void GetCachedViewTest()
{
BaseReportTests.InitDBAndLogin();
var facade = new AVRFacade(m_Container);
long layoutId = LayoutFormSave();
List <long> queryIdList = facade.GetQueryIdList();
Assert.IsNotNull(queryIdList);
Assert.IsTrue(queryIdList.Count > 0);
List <long> layoutIdList = facade.GetLayoutIdList();
Assert.IsNotNull(layoutIdList);
Assert.IsTrue(layoutIdList.Count > 0);
ViewDTO model = facade.GetCachedView("xxx", layoutId, "en");
Assert.IsNotNull(model);
Assert.IsNotNull(model.BinaryViewHeader);
Assert.IsNotNull(model.Header);
Assert.IsNotNull(model.BodyPackets);
byte[] unzippedViewStructure = BinaryCompressor.Unzip(model.BinaryViewHeader);
string xmlViewStructure = BinarySerializer.DeserializeToString(unzippedViewStructure);
AvrView view = AvrViewSerializer.Deserialize(xmlViewStructure);
string viewXmlNew = AvrViewSerializer.Serialize(view);
Assert.IsNotNull(viewXmlNew);
BaseTableDTO unzippedDTO = BinaryCompressor.Unzip(model);
DataTable viewData = BinarySerializer.DeserializeToTable(unzippedDTO);
string dataXmlNew = DataTableSerializer.Serialize(viewData);
Assert.IsNotNull(dataXmlNew);
}
public void ViewFacedeTest()
{
var facade = new AVRFacadeStub(123);
ViewDTO model = facade.GetCachedView("xxx", -1, "en");
Assert.IsNotNull(model);
Assert.IsNotNull(model.BinaryViewHeader);
Assert.IsNotNull(model.Header);
Assert.IsNotNull(model.BodyPackets);
byte[] unzippedViewStructure = BinaryCompressor.Unzip(model.BinaryViewHeader);
string xmlViewStructure = BinarySerializer.DeserializeToString(unzippedViewStructure);
AvrView view = AvrViewSerializer.Deserialize(xmlViewStructure);
string viewXmlNew = AvrViewSerializer.Serialize(view);
Assert.AreEqual(SerializedViewStub.ViewXml, viewXmlNew);
BaseTableDTO unzippedDTO = BinaryCompressor.Unzip(model);
DataTable viewData = BinarySerializer.DeserializeToTable(unzippedDTO);
string dataXmlNew = DataTableSerializer.Serialize(viewData);
Assert.AreEqual(SerializedViewStub.DataXml, dataXmlNew);
}
public void GetCachedQueryTest()
{
AVRFacade facade;
using (new StopwathTransaction("AVRFacade .ctor"))
{
facade = new AVRFacade(m_Container);
}
QueryTableHeaderDTO headerDTO;
using (new StopwathTransaction("GetCachedQueryTableHeader"))
{
//fn_AVR_HumanCaseReport
headerDTO = facade.GetCachedQueryTableHeader(49539640000000, "en", false);
}
var headerModel = new QueryTableHeaderModel(headerDTO);
Assert.AreEqual(m_FieldCount, headerModel.ColumnCount);
Assert.IsTrue(headerModel.ColumnTypeByName.Exists(c => c.Name == "sflHC_FinalDiagnosis"));
Type stringType = headerModel.ColumnTypeByName.Find(c => c.Name == "sflHC_FinalDiagnosis").FinalType;
Assert.AreEqual(typeof(string), stringType);
Assert.IsTrue(headerModel.ColumnTypeByName.Exists(c => c.Name == "sflHC_FinalDiagnosisDate"));
stringType = headerModel.ColumnTypeByName.Find(c => c.Name == "sflHC_FinalDiagnosisDate").FinalType;
Assert.AreEqual(typeof(DateTime), stringType);
for (int i = 0; i < headerDTO.PacketCount; i++)
{
QueryTablePacketDTO packetDTO;
using (new StopwathTransaction("GetCachedQueryTablePacket " + i))
{
packetDTO = facade.GetCachedQueryTablePacket(headerModel.QueryCacheId, i, headerDTO.PacketCount);
}
QueryTablePacketDTO unzipped;
using (new StopwathTransaction(string.Format("-Unzip Packet #{0}", i)))
{
unzipped = BinaryCompressor.Unzip(packetDTO);
}
StreamTablePacketDTO unzippedStream;
using (new StopwathTransaction(string.Format("-Unzip Packet #{0} into stream", i)))
{
unzippedStream = BinaryCompressor.UnzipStream(packetDTO);
}
AvrDataTable deserialized = new AvrDataTable(headerModel, 10240);
using (new StopwathTransaction(string.Format("--Deserialize Packet #{0}", i)))
{
BinarySerializer.DeserializeBodyPacket(unzipped, headerModel.ColumnTypes, deserialized);
}
AvrDataTable deserializedStream = new AvrDataTable(headerModel, 10240);
using (new StopwathTransaction(string.Format("--Deserialize Packet #{0} into stream", i)))
{
BinarySerializer.DeserializeBodyPacket(unzippedStream, headerModel.ColumnTypes, deserializedStream);
}
Assert.AreNotSame(deserialized, deserializedStream);
Assert.AreEqual(deserialized.Count, deserializedStream.Count);
Assert.AreEqual(deserialized.Columns.Count, deserializedStream.Columns.Count);
int diagnosisIndex = headerModel.ColumnTypeByName
.Select(c => c.Name)
.TakeWhile(key => key != "sflHC_FinalDiagnosis")
.Count();
bool found = false;
for (int j = 0; j < deserialized.Count; j++)
{
var row = (AvrDataRowEx)deserialized[j];
var rowStream = (AvrDataRowEx)deserializedStream[j];
Assert.AreNotSame(row, rowStream);
Assert.AreEqual(row.Count, rowStream.Count);
for (int k = 0; k < row.Count; k++)
{
Assert.AreEqual(row[k], rowStream[k]);
}
if (row[diagnosisIndex].ToString() == "Smallpox")
{
found = true;
}
}
Assert.IsTrue(found);
}
}
public void UpdateLayoutDetailTest()
{
lock (m_LayoutDB.Connection)
{
OpenConnection();
using (new CultureInfoTransaction(new CultureInfo("ru-RU")))
{
long layoutId = CreateLayout();
var layoutDetail = (LayoutDetailDataSet)m_LayoutDB.GetDetail(layoutId);
var row = (LayoutDetailDataSet.LayoutRow)layoutDetail.Layout.Rows[0];
m_LayoutDB.SetQueryID(m_TestQueryId);
Assert.IsFalse(row.blnApplyPivotGridFilter);
Assert.IsFalse(row.blnReadOnly);
Assert.IsFalse(row.blnShareLayout);
Assert.IsFalse(row.blnShowColGrandTotals);
Assert.IsFalse(row.blnShowColsTotals);
Assert.IsFalse(row.blnShowForSingleTotals);
Assert.IsFalse(row.blnShowRowGrandTotals);
Assert.IsFalse(row.blnShowRowsTotals);
Assert.AreEqual(layoutId, row.idflLayout);
Assert.AreEqual((long)DBGroupInterval.gitDateYear, row.idfsDefaultGroupDate);
Assert.AreEqual(EidssUserContext.User.EmployeeID, row.idfPerson);
row.blnApplyPivotGridFilter = true;
row.blnReadOnly = true;
row.blnShareLayout = true;
row.blnShowColGrandTotals = true;
row.blnShowColsTotals = true;
row.blnShowForSingleTotals = true;
row.blnShowRowGrandTotals = true;
row.blnShowRowsTotals = true;
row.idfsDefaultGroupDate = (long)DBGroupInterval.gitDateMonth;
row.strPivotGridSettings = string.Empty;
row.blbPivotGridSettings = BinaryCompressor.ZipString(row.strPivotGridSettings);
row.strDefaultLayoutName = "English name";
row.strLayoutName = "russian";
row.strDescription = "descr aaa";
UpdateLayout(layoutDetail);
var newLayoutDetail = (LayoutDetailDataSet)m_LayoutDB.GetDetail(layoutId);
var newRow =
(LayoutDetailDataSet.LayoutRow)newLayoutDetail.Layout.Rows[0];
Assert.AreEqual(row.blnApplyPivotGridFilter, newRow.blnApplyPivotGridFilter);
Assert.AreEqual(row.blnReadOnly, newRow.blnReadOnly);
Assert.AreEqual(row.blnShareLayout, newRow.blnShareLayout);
Assert.AreEqual(row.blnShowColGrandTotals, newRow.blnShowColGrandTotals);
Assert.AreEqual(row.blnShowColsTotals, newRow.blnShowColsTotals);
Assert.AreEqual(row.blnShowForSingleTotals, newRow.blnShowForSingleTotals);
Assert.AreEqual(row.blnShowRowGrandTotals, newRow.blnShowRowGrandTotals);
Assert.AreEqual(row.blnShowRowsTotals, newRow.blnShowRowsTotals);
Assert.AreEqual(row.idfsDefaultGroupDate, newRow.idfsDefaultGroupDate);
Assert.AreEqual(row.strPivotGridSettings, newRow.strPivotGridSettings);
Assert.AreEqual(BinaryCompressor.UnzipString(row.blbPivotGridSettings),
BinaryCompressor.UnzipString(newRow.blbPivotGridSettings));
Assert.AreEqual(row.strDefaultLayoutName, newRow.strDefaultLayoutName);
Assert.AreEqual(row.strLayoutName, newRow.strLayoutName);
Assert.AreEqual(row.strDescription, newRow.strDescription);
Assert.AreEqual(row.idflLayout, newRow.idflLayout);
Assert.AreEqual(row.idflQuery, newRow.idflQuery);
Assert.AreEqual(row.idflDescription, newRow.idflDescription);
Assert.AreEqual(row.IsidflLayoutFolderNull(), newRow.IsidflLayoutFolderNull());
if (!row.IsidflLayoutFolderNull())
{
Assert.AreEqual(row.idflLayoutFolder, newRow.idflLayoutFolder);
}
DeleteLayout(layoutId);
}
CloseConnection();
}
}
public void ZeroCompressTest()
{
byte[] zip = BinaryCompressor.Zip(new byte[0]);
byte[] result = BinaryCompressor.Unzip(zip);
Assert.AreEqual(0, result.Length);
}
public void SerializeIntegrationTest()
{
QueryTableModel tableModel;
using (var manager = new DbManager(new SqlDataProvider(), Config.GetSetting("TestConnectionString")))
{
using (DbManager command = manager.SetCommand(@"select * from dbo.AVR_HumanCaseReport"))
{
tableModel = BinarySerializer.SerializeFromCommand(command, 123, "en", false, 10);
}
}
Assert.AreEqual(54, tableModel.Header.RowCount);
Assert.AreEqual(false, tableModel.UseArchivedData);
Assert.AreEqual(false, tableModel.Header.IsArchive);
QueryTablePacketDTO zippedHeader = BinaryCompressor.Zip(tableModel.Header);
Assert.AreEqual(false, zippedHeader.IsArchive);
List <QueryTablePacketDTO> zippedBody = tableModel.BodyPackets.Select(BinaryCompressor.Zip).ToList();
Assert.IsFalse(zippedBody.Any(p => p.IsArchive));
QueryTablePacketDTO unzipedHeader = BinaryCompressor.Unzip(zippedHeader);
Assert.AreEqual(false, unzipedHeader.IsArchive);
List <QueryTablePacketDTO> unzippedBody = zippedBody.Select(BinaryCompressor.Unzip).ToList();
Assert.IsFalse(unzippedBody.Any(p => p.IsArchive));
List <BaseColumnModel> resultHeader = BinarySerializer.DeserializeHeader(unzipedHeader);
Assert.IsTrue(resultHeader.Exists(c => c.Name == "sflHC_PatientDOB"));
Assert.IsTrue(resultHeader.Exists(c => c.Name == "sflHC_PatientSex_ID"));
Assert.IsTrue(resultHeader.Exists(c => c.Name == "sflHC_LabDiagBasis"));
Assert.AreEqual(typeof(DateTime), resultHeader.Find(c => c.Name == "sflHC_PatientDOB").FinalType);
Assert.AreEqual(typeof(long), resultHeader.Find(c => c.Name == "sflHC_PatientSex_ID").FinalType);
Assert.AreEqual(typeof(string), resultHeader.Find(c => c.Name == "sflHC_LabDiagBasis").FinalType);
Type[] types = resultHeader.Select(c => c.FinalType).ToArray();
AvrDataTable resultBody = new AvrDataTable(new DataTable());
foreach (var packetDTO in unzippedBody)
{
BinarySerializer.DeserializeBodyPacket(packetDTO, types, resultBody);
}
Assert.AreEqual(31, resultBody.Count);
Assert.AreEqual(54, resultBody[0].Count);
AvrDataRowEx row = (AvrDataRowEx)resultBody[30];
Assert.AreEqual(new DateTime(1990, 02, 01), row[0]);
Assert.AreEqual(23, row[1]);
Assert.AreEqual(DBNull.Value, row[3]);
Assert.AreEqual("xxx", row[4]);
Assert.AreEqual("Male", row[6]);
Assert.AreEqual(DBNull.Value, row[7]);
Assert.AreEqual(DateTime.Now.Year, ((DateTime)row[50]).Year);
Assert.AreEqual(DateTime.Now.Year, row[51]);
Assert.AreEqual(25460000000m, row[52]);
Assert.AreEqual("Yes", row[53]);
}
public ViewDTO GetCachedView(string sessionId, long layoutId, string lang)
{
try
{
m_ViewSemaphore.Wait();
var layout = AvrDbHelper.GetLayoutDTO(layoutId);
Stopwatch watch = TraceMethodCall(sessionId, layoutId, layout.DefaultLayoutName, lang);
EidssAvrServiceInitializer.CheckAndInitEidssCore();
ViewDTO view = null;
var cacheKey = new QueryCacheKey(layout.QueryId, lang, layout.UseArchivedData);
long? queryCacheId = AvrDbHelper.GetQueryCacheId(cacheKey, RefreshedCacheOnUserCallAfterDays);
if (queryCacheId.HasValue)
{
var viewCacheId = AvrDbHelper.GetViewCacheId(queryCacheId.Value, layoutId, RefreshedCacheOnUserCallAfterDays);
if (viewCacheId.HasValue)
{
view = AvrDbHelper.GetViewCache(viewCacheId.Value, false);
}
}
if (view == null)
{
AvrPivotViewModel model = VirtualPivot.CreateAvrPivotViewModel(layoutId, lang, m_Container);
string xmlViewHeader = AvrViewSerializer.Serialize(model.ViewHeader);
byte[] zippedViewHeader = BinaryCompressor.ZipString(xmlViewHeader);
BaseTableDTO serializedDTO = BinarySerializer.SerializeFromTable(model.ViewData);
BaseTableDTO zippedDTO = BinaryCompressor.Zip(serializedDTO);
view = new ViewDTO(zippedDTO, zippedViewHeader);
queryCacheId = AvrDbHelper.GetQueryCacheId(cacheKey, RefreshedCacheOnUserCallAfterDays);
if (queryCacheId.HasValue)
{
AvrDbHelper.SaveViewCache(queryCacheId.Value, layoutId, view);
}
}
TraceMethodCallFinished(watch, sessionId, layoutId, layout.DefaultLayoutName, lang);
return(view);
}
catch (OutOfMemoryException ex)
{
m_Trace.TraceMethodException(ex, Utils.GetCurrentMethodName(), m_TraceTitle, sessionId, layoutId, lang);
throw new AvrDataException(EidssMessages.Get("ErrAVROutOfMemory"), ex);
}
catch (Exception ex)
{
m_Trace.TraceMethodException(ex, Utils.GetCurrentMethodName(), m_TraceTitle, sessionId, layoutId, lang);
string format = EidssMessages.Get("msgCouldNotGetViewData",
"Could not get View Data from Layout. LayoutID={0}, Lang={1}, SessionId={2}");
string msg = String.Format(format, layoutId, lang, sessionId);
throw new AvrDataException(msg, ex);
}
finally
{
m_ViewSemaphore.Release();
}
}
public void SimpleCompressTest()
{
byte[] zip = BinaryCompressor.Zip(new byte[] { 1 });
byte[] result = BinaryCompressor.Unzip(zip);
Assert.AreEqual(1, result[0]);
}
public AvrView(DataSet ds, string tableView, string tableBands, string tableColumns)
{
var row = ds.Tables[tableView].Rows[0];
m_ViewID = (long)row["idflLayout"];
QueryID = (long)row["idflQuery"];
var ids = row["ChartXAxisViewColumn"];
if (!Utils.IsEmpty(ids))
{
m_ChartXAxisViewColumn = (string)ids;
}
ids = row["MapAdminUnitViewColumn"];
if (!Utils.IsEmpty(ids))
{
m_MapAdminUnitViewColumn = (string)ids;
}
ids = row["idfGlobalView"];
if (!Utils.IsEmpty(ids))
{
m_GlobalView = (long?)ids;
}
ids = row["intGisLayerPosition"];
if (!Utils.IsEmpty(ids))
{
m_GisLayerPosition = (int?)ids;
}
var readOnly = row["blnReadOnly"];
IsReadOnly = readOnly is bool && (bool)readOnly;
ids = row["blbChartLocalSettings"];
if (!Utils.IsEmpty(ids))
{
ChartLocalSettingsZip = (byte[])ids;
}
ids = row["blbGisLayerLocalSettings"];
if (!Utils.IsEmpty(ids))
{
GisLayerLocalSettingsZip = (byte[])ids;
}
ids = row["blbGisMapLocalSettings"];
if (!Utils.IsEmpty(ids))
{
GisMapLocalSettingsZip = (byte[])ids;
}
ids = row["blbViewSettings"];
if (!Utils.IsEmpty(ids))
{
ViewSettingsZip = (byte[])ids;
}
if (m_ChartLocalSettingsZip != null)
{
m_ChartLocalSettingsXml = BinaryCompressor.UnzipString(m_ChartLocalSettingsZip);
}
if (m_GisLayerLocalSettingsZip != null)
{
m_GisLayerLocalSettingsXml = BinaryCompressor.UnzipString(m_GisLayerLocalSettingsZip);
}
if (m_GisMapLocalSettingsZip != null)
{
m_GisMapLocalSettingsXml = BinaryCompressor.UnzipString(m_GisMapLocalSettingsZip);
}
if (m_ViewSettingsZip != null)
{
m_ViewSettingsXml = BinaryCompressor.UnzipString(m_ViewSettingsZip);
}
var drTop = ds.Tables[tableBands].Select("idfParentViewBand is null", "intOrder", DataViewRowState.CurrentRows);
foreach (var r in drTop)
{
Bands.Add(new AvrViewBand(r, ds, tableBands, tableColumns)
{
Owner = this
});
}
var drChildCols = ds.Tables[tableColumns].Select("idfViewBand is null", "intOrder", DataViewRowState.CurrentRows);
if (drChildCols.Length > 0)
{
foreach (var r in drChildCols)
{
AddColumn(r);
}
}
}
public static void GetAvrStyles
(long layoutId, out string gradLayerName, out ITheme gradLayerTheme, out string chartLayerName,
out ITheme chartLayerTheme)
{
gradLayerTheme = null;
chartLayerTheme = null;
gradLayerName = chartLayerName = string.Empty;
#region Get layer settings
const string TasLayout = "tasLayout";
byte[] GisLayerLocalSettingsZip;
string GisLayerLocalSettingsXml;
XmlDocument xmlSetting = null;
try
{
var ds = new DataSet();
//IDbCommand cmd = CreateSPCommand("spAsMapSettingsSelectDetail");
var cmd = new SqlCommand("spAsMapSettingsSelectDetail",
(SqlConnection)ConnectionManager.DefaultInstance.Connection)
{
CommandTimeout = 300,
CommandType = CommandType.StoredProcedure
};
cmd.Parameters.Add(new SqlParameter("@LangID", ModelUserContext.CurrentLanguage));
cmd.Parameters.Add(new SqlParameter("@LayoutID", layoutId));
DbDataAdapter adapter = new SqlDataAdapter(cmd);
adapter.Fill(ds, TasLayout);
ds.EnforceConstraints = false;
if (ds.Tables[TasLayout].Rows.Count > 0)
{
DataRow row = ds.Tables[TasLayout].Rows[0];
if (bv.common.Core.Utils.IsEmpty(row["blbGisLayerGeneralSettings"]))
{
return;
}
GisLayerLocalSettingsZip = (byte[])row["blbGisLayerGeneralSettings"];
GisLayerLocalSettingsXml = BinaryCompressor.UnzipString(GisLayerLocalSettingsZip);
xmlSetting = new XmlDocument();
xmlSetting.LoadXml(GisLayerLocalSettingsXml);
ds.EnforceConstraints = true;
}
}
catch (Exception ex)
{
Dbg.Debug(ex.ToString());
return;
}
#endregion
if (xmlSetting == null)
{
return;
}
var tmpGroup =
GIS_V4.Serializers.LayerSerializers.LayerGroupSerializer.Instance.Deserialize(
(XmlElement)xmlSetting.ChildNodes[0]);
foreach (var layer in tmpGroup.Layers)
{
if (layer is LabelLayer)
{
continue;
}
((EventLayer)layer).Theme = ReplaceColumnName((EventLayer)layer);
if ((string)layer.Tag == "event_gradient")
{
gradLayerName = layer.LayerName;
gradLayerTheme = ((VectorLayer)layer).Theme;
}
if ((string)layer.Tag == "event_chart")
{
chartLayerName = layer.LayerName;
chartLayerTheme = ((VectorLayer)layer).Theme;
}
}
}
