public static ViewDTO GetViewCache(long viewCacheId, bool isSchedulerCall)
{
ViewDTO view;
using (var avrTran = new AvrDbTransaction())
{
DbManagerProxy manager = avrTran.Manager;
DbManager headerCmd = manager.SetSpCommand("spAsViewCacheGetHeader",
manager.Parameter("idfViewCache", viewCacheId),
manager.Parameter("blnSchedulerCall", isSchedulerCall));
lock (m_DbSyncLock)
{
int packetCount;
using (IDataReader reader = headerCmd.ExecuteReader())
{
if (!reader.Read())
{
return(null);
}
BaseTableDTO viewTableDTO = new BaseTableDTO
{
Header =
{
RowCount = (int)reader["intViewColumnCount"],
BinaryBody = new ChunkByteArray((byte[])reader["blbViewSchema"])
}
};
var binaryHeader = (byte[])reader["blbViewHeader"];
view = new ViewDTO(viewTableDTO, binaryHeader);
packetCount = (int)reader["intPacketCount"];
}
for (int packetNumber = 0; packetNumber < packetCount; packetNumber++)
{
DbManager packetCmd = manager.SetSpCommand("spAsViewCacheGetPacket",
manager.Parameter("idfViewCache", viewCacheId),
manager.Parameter("intViewCachePacketNumber", packetNumber));
var packetDTO = new BaseTablePacketDTO();
using (IDataReader packetReader = packetCmd.ExecuteReader())
{
if (!packetReader.Read())
{
return(null);
}
packetDTO.RowCount = (int)packetReader["intTableRowCount"];
packetDTO.BinaryBody = new ChunkByteArray((byte[])packetReader["blbViewCachePacket"]);
}
view.BodyPackets.Add(packetDTO);
}
avrTran.CommitTransaction();
}
}
return(view);
}
public void ViewFacedeSemaphoreTest()
{
int taskNumber = 0;
var facade = new AVRFacadeStub(123);
const int taskCount = 10;
Action act = () =>
{
var number = Interlocked.Increment(ref taskNumber);
Console.WriteLine("->View task {0} started", number);
ViewDTO model = facade.GetCachedView("xxx", -1, "en");
Console.WriteLine("<-View task {0} finished", number);
};
Task[] tasks = new Task[taskCount];
for (int i = 0; i < taskCount; i++)
{
tasks[i] = new Task(act);
}
foreach (var task in tasks)
{
task.Start();
}
Task.WaitAll(tasks);
}
private void OnDeleteViewClicked(object sender, EventArgs args)
{
TreeIter iter;
if (viewsTreeView.Selection.GetSelected(out iter))
{
string viewName = viewTableModel.ListStore.GetValue(iter, 0).ToString();
ViewDTO auxViewDTO = null;
foreach (ViewDTO viewDTO in viewTableModel.ListModel)
{
if (viewDTO.ViewName.Equals(viewName))
{
auxViewDTO = viewDTO;
break;
}
}
//Siempre será != null
if (auxViewDTO != null)
{
viewTableModel.ListModel.Remove(auxViewDTO);
viewTableModel = new ViewTableModel(viewTableModel.ListModel);
viewsTreeView.Model = viewTableModel.ListStore;
}
}
}
public async Task <ViewDTO> UpdateAsync(ViewDTO view)
{
view.AccessKey = "----";
var rawViewContent = JsonConvert.SerializeObject(view);
var sqlParams = new
{
Id = view.Id.RawValue,
CustomerId = view.CustomerId.RawValue,
Content = rawViewContent
};
string sql = @";
UPDATE dbo.Views
SET Content = @Content
WHERE Id = @Id
AND CustomerId = @CustomerId;
SELECT Id,
CustomerId,
AccessKey,
Content
FROM dbo.Views V
WHERE V.Id = @Id
AND V.CustomerId = @CustomerId;
";
return(await GetSingleOrDefaultAsync(sql, sqlParams));
}
public async Task <IActionResult> UpdateViewAsync([FromBody] ViewConfigurationModel view)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var customerId = _membership.GetCustomerId(User);
var viewDTO = new ViewDTO(
view.Id,
customerId,
"----",
new ViewCustomizationDTO(
view.Custom.Url,
view.Custom.Logo,
view.Custom.Title,
view.Custom.HeaderLinks.Select(hl => new ViewCustomizationHeaderLinkDTO(hl.Label, hl.Url))
.ToList(),
view.Custom.Copyright),
view.Columns.Select(c => new ViewColumnDTO(
c.Order,
c.Label,
c.Lines.Select(line => new ViewColumnLineDTO(line.Field))
.ToList()
)).ToList());
viewDTO = await _persistence.Views.UpdateAsync(viewDTO);
return(Ok(new ViewConfigurationModel(viewDTO)));
}
public async Task <ViewDTO> CreateNewAsync(ViewDTO view)
{
var origAccessKey = view.AccessKey;
view.AccessKey = "----";
var rawViewContent = JsonConvert.SerializeObject(view);
var sqlParams = new
{
Id = Guid.NewGuid(),
CustomerId = view.CustomerId.RawValue,
AccessKey = origAccessKey,
Content = rawViewContent
};
string sql = @";
INSERT INTO dbo.Views(Id, CustomerId, AccessKey, Content)
VALUES(@Id, @CustomerId, @AccessKey, @Content);
SELECT Id,
CustomerId,
AccessKey,
Content
FROM dbo.Views V
WHERE V.Id = @Id
AND V.CustomerId = @CustomerId;
";
return(await GetSingleOrDefaultAsync(sql, sqlParams));
}
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();
}
}
private Hashtable InitComponentTable(ComponentDTO componentDTO, Hashtable templateTable)
{
Hashtable componentTable = new Hashtable();
//Key fileName without path, string value.
componentTable.Add(componentDTO.ComponentName + "ComponentModel.cs", templateTable[TemplateNamesDTO.BusinessObject]);
//Añadimos el gestor de exceptions
componentTable.Add(componentDTO.ClassExceptionManager + ".cs", templateTable[TemplateNamesDTO.ExceptionManager]);
//Añadimos el manifiesto.
/**
* StringBuilder manifestBuilder = new StringBuilder (TemplateNamesDTO.AssemblyInfo);
* manifestBuilder = manifestBuilder.Replace ("template", "cs");
* componentTable.Add (manifestBuilder.ToString (), templateTable[TemplateNamesDTO.AssemblyInfo]);
*/
//Añaidmos las vistas
IEnumerator enumerator = componentDTO.ViewCollection.GetEnumerator();
while (enumerator.MoveNext())
{
ViewDTO currentView = (ViewDTO)enumerator.Current;
componentTable.Add(currentView.ViewName + ".cs", templateTable[TemplateNamesDTO.ViewHandler]);
}
//Añadimos el file nant.
if (preferencesDTO.GenerateBuildfile)
{
componentTable.Add(componentDTO.ComponentName + ".build", templateTable[TemplateNamesDTO.NAntBuildfile]);
}
return(componentTable);
}
public IDataTransferObject GetDataForm()
{
Dialog newViewDialog = (Dialog)GetWidget();
ViewDTO viewDTO = null;
switch (newViewDialog.Run())
{
case (int)ResponseType.Ok:
if (viewNameEntry.Text.Length != 0)
{
viewDTO = new ViewDTO();
viewDTO.ViewName = viewNameEntry.Text;
}
break;
case (int)ResponseType.Cancel:
break;
default:
break;
}
newViewDialog.Destroy();
newViewDialog = null;
return(viewDTO);
}
public void LoadDataForm(IDataTransferObject dto)
{
if (dto is ViewDTO)
{
ViewDTO viewDTO = (ViewDTO)dto;
viewNameEntry.Text = viewDTO.ViewName;
}
}
public ViewConfigurationModel(ViewDTO view)
{
Id = view.Id.RawValue;
AccessKey = view.AccessKey;
Custom = new ViewCustomizationModel(view.Customization);
Columns = view.Columns.Select(c => new ViewColumnConfigurationModel(c))
.ToList();
}
public void Add(IDataTransferObject dto)
{
if (dto is ViewDTO)
{
ViewDTO viewDTO = (ViewDTO)dto;
listStore.AppendValues(viewDTO.ViewName);
list.Add(viewDTO);
}
}
private async Task <ViewDTO> CreateDefaultViewAsync(CustomerId customerId)
{
var customer = await _persistence.Customers.GetAsync(customerId);
var accessKey = ConfigurationController.GenerateAPIKey();
var newView = new ViewDTO(null, customerId, accessKey, new ViewCustomizationDTO("", "https://app.auditlog.co/images/logo56.png", customer.DisplayName, new List <ViewCustomizationHeaderLinkDTO>(), ""), CreateDefaultColumnLayout());
return(await _persistence.Views.CreateNewAsync(newView));
}
public static long SaveViewCache(long queryCacheId, long layoutId, ViewDTO zippedTable)
{
using (var avrTran = new AvrDbTransaction())
{
long id = SaveViewCacheWithoutTransaction(queryCacheId, layoutId, zippedTable);
avrTran.CommitTransaction();
return(id);
}
}
private void DeleteView(object sender, EventArgs e)
{
if (listBoxViews.SelectedItem != null)
{
ViewDTO view = (ViewDTO)listBoxViews.SelectedItem;
Services.ViewService.RemoveView(view.Id);
LoadZone();
}
}
private void OnNewViewClicked(object sender, EventArgs args)
{
formView = new FormView();
ViewDTO viewDTO = (ViewDTO)formView.GetDataForm();
if (viewDTO != null)
{
viewTableModel.Add(viewDTO);
}
formView = null;
}
private void ChangeViewName(object sender, EventArgs e)
{
if (listBoxViews.SelectedItem != null)
{
ViewDTO view = (ViewDTO)listBoxViews.SelectedItem;
Services.ViewService.SetNameView(view.Id, textBoxNameView.Text);
LoadZone();
}
}
public void TestViewCache()
{
QueryTableModel actualTable = GetTestTableModel();
AvrDbHelper.InvalidateQueryCache(actualTable.QueryId, "en");
Assert.IsFalse(AvrDbHelper.GetQueryCacheId(actualTable.QueryId, "en", false).HasValue);
AvrDbHelper.SaveQueryCache(actualTable);
long?queryCacheId = AvrDbHelper.GetQueryCacheId(actualTable.QueryId, "en", false);
Assert.IsTrue(queryCacheId.HasValue);
ViewDTO sourceView = GetCachedView();
var viewCacheId = AvrDbHelper.SaveViewCache(queryCacheId.Value, 1, sourceView);
long?loadedViewCasheId = AvrDbHelper.GetViewCacheId(queryCacheId.Value, 11);
Assert.IsFalse(loadedViewCasheId.HasValue);
loadedViewCasheId = AvrDbHelper.GetViewCacheId(queryCacheId.Value, 1);
Assert.IsTrue(loadedViewCasheId.HasValue);
Assert.AreEqual(viewCacheId, loadedViewCasheId);
var loadedView = AvrDbHelper.GetViewCache(viewCacheId, false);
Assert.IsNotNull(loadedView);
AvrDbHelper.InvalidateQueryCache(actualTable.QueryId);
Assert.IsFalse(AvrDbHelper.GetQueryCacheId(actualTable.QueryId, "en", false).HasValue);
loadedViewCasheId = AvrDbHelper.GetViewCacheId(queryCacheId.Value, 1);
Assert.IsFalse(loadedViewCasheId.HasValue);
loadedView = AvrDbHelper.GetViewCache(viewCacheId, false);
Assert.IsNotNull(loadedView);
AssertAreArrayEqual(sourceView.BinaryViewHeader, loadedView.BinaryViewHeader);
AssertAreArrayEqual(sourceView.Header.BinaryBody, loadedView.Header.BinaryBody);
Assert.AreEqual(sourceView.BodyPackets.Count, loadedView.BodyPackets.Count);
for (int i = 0; i < loadedView.BodyPackets.Count; i++)
{
AssertAreArrayEqual(sourceView.BodyPackets[i].BinaryBody, loadedView.BodyPackets[i].BinaryBody);
}
AvrDbHelper.SaveViewCache(queryCacheId.Value, 1, sourceView);
loadedViewCasheId = AvrDbHelper.GetViewCacheId(queryCacheId.Value, 1);
Assert.IsTrue(loadedViewCasheId.HasValue);
AvrDbHelper.InvalidateViewCache(1);
loadedViewCasheId = AvrDbHelper.GetViewCacheId(queryCacheId.Value, 1);
Assert.IsFalse(loadedViewCasheId.HasValue);
}
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 Validate(ViewDTO view)
{
var exceptionList = new List <ValidationException>();
if (view.MoneyPrecision < 0 || view.MoneyPrecision > 8)
{
exceptionList.Add(new ValidationException(Resource.Resource.MoneyPrecisionValidate, HelperService.GetMemberName((ViewDTO c) => c.MoneyPrecision)));
}
if (view.PercentyPrecision < 0 || view.PercentyPrecision > 8)
{
exceptionList.Add(new ValidationException(Resource.Resource.PercentyPrecisionValidate, HelperService.GetMemberName((ViewDTO c) => c.PercentyPrecision)));
}
CheckForExceptions(exceptionList);
}
public void CreateOrUpdateView(ViewDTO view, string userId)
{
if (view == null)
{
throw new ValidationException(Resource.Resource.ViewNullReference, "");
}
if (db.Views.IsExist(view.Id))
{
UpdateView(view);
}
else
{
CreateView(view, userId);
}
}
private void LoadView(object sender, EventArgs e)
{
if (listBoxViews.SelectedItem != null)
{
ViewDTO view = (ViewDTO)listBoxViews.SelectedItem;
textBoxNameView.Text = view.Name;
if (view.ImageMap.Length != 0)
{
MemoryStream ms = new MemoryStream(Services.ViewService.GetViewImage(view.Id));
pictureBox.Image = Image.FromStream(ms);
}
}
}
public async Task GetAsync_CreateViewAsync_ProducesNewView()
{
var database = new PersistenceStore(ConnectionString);
string originalAccessKey = "abc-123";
var view = new ViewDTO(null, ValidCustomerId, originalAccessKey, new ViewCustomizationDTO("url", "logo", "title", new List <ViewCustomizationHeaderLinkDTO>(), "copyright"), new List <ViewColumnDTO>()
{
});
var result = await database.Views.CreateNewAsync(view);
Assert.AreEqual(originalAccessKey, result.AccessKey);
Assert.AreNotEqual(originalAccessKey, view.AccessKey);
Assert.AreEqual(view.CustomerId, result.CustomerId);
Assert.IsNotNull(result.Id);
}
public void CreateView(ViewDTO viewDto, string userId)
{
if (viewDto == null)
{
throw new ValidationException(Resource.Resource.ViewNullReference, "");
}
validateService.Validate(viewDto);
var view = IMapper.Map <ViewDTO, ViewForTable>(viewDto);
AddViewTemplateToView(view, view.ViewTemplateId);
var customer = customerService.GetCustomerByProfileId(userId);
view.Customer = customer;
customer.Views.Add(view);
db.Views.Create(view);
}
public void UpdateView(ViewDTO viewDto)
{
if (viewDto == null)
{
throw new ValidationException(Resource.Resource.ViewNullReference, "");
}
if (!db.Views.IsExist(viewDto.Id))
{
throw new ValidationException(Resource.Resource.ViewNotFound, "");
}
validateService.Validate(viewDto);
var view = IMapper.Map <ViewDTO, ViewForTable>(viewDto);
var viewFromDb = db.Views.Get(viewDto.Id);
view.Customer = viewFromDb.Customer;
AddViewTemplateToView(view, view.ViewTemplateId);
db.Views.Update(view);
}
public List <ViewDTO> getData()
{
List <ViewDTO> viewData = new List <ViewDTO>();
var imageData = getImages();
for (var i = 0; i < imageData.Count; i++)
{
var restaurtantData = getRestaurant(imageData[i].tags);
ViewDTO viewDTO = new ViewDTO();
viewDTO.imageURl = imageData[i].imageURl;
if (restaurtantData.Count == 3)
{
viewDTO.restaurant1 = restaurtantData[0];
viewDTO.restaurant2 = restaurtantData[1];
viewDTO.restaurant3 = restaurtantData[2];
viewData.Add(viewDTO);
}
}
return(viewData);
}
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 static long SaveViewCacheWithoutTransaction(long queryCacheId, long layoutId, ViewDTO zippedTable)
{
lock (m_DbSyncLock)
{
using (DbManagerProxy manager = DbManagerFactory.Factory[DatabaseType.Avr].Create())
{
DbManager headerCommand = manager.SetSpCommand("spAsViewCachePostHeader",
manager.Parameter("idfQueryCache", queryCacheId),
manager.Parameter("idfLayout", layoutId),
manager.Parameter("blbViewSchema", zippedTable.Header.BinaryBody.ToArray()),
manager.Parameter("blbViewHeader", zippedTable.BinaryViewHeader),
manager.Parameter("intViewColumnCount", zippedTable.Header.RowCount)
);
var viewCasheId = (long)headerCommand.ExecuteScalar();
for (int i = 0; i < zippedTable.BodyPackets.Count; i++)
{
DbManager command = manager.SetSpCommand("spAsViewCachePostPacket",
manager.Parameter("idfViewCache", viewCasheId),
manager.Parameter("intViewCachePacketNumber", i),
manager.Parameter("intPacketRowCount", zippedTable.BodyPackets[i].RowCount),
manager.Parameter("blbViewCachePacket", zippedTable.BodyPackets[i].BinaryBody.ToArray())
);
command.ExecuteNonQuery();
}
return(viewCasheId);
}
}
}
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();
}
}