private DimensionItem AddTotalDimension(Page page, double locationX, bool indent_left, bool indent_right)
{
double x1 = _origin.X;
double x2 = locationX;
if (indent_left)
{
x1 -= 240;
}
if (indent_right)
{
x2 += 240;
}
DimensionItem item = Util.eplan.AddDimension(
page,
null,
_totalWidth,
x1,
_origin.Y - _dimOffset[2],
x2,
_origin.Y - _dimOffset[2],
20);
item.ExtensionLineFirst = !indent_left;
item.ExtensionLineSecond = !indent_right;
item.DimensionCalculated = false;
item.DimensionLineTermination = DimensionItem.Enums.DimensionLineTermination.Without;
item.DimensionText = _totalWidth.ToString("F0");
return(item);
}
public ListDimensionBuilder(ObjectConfiguration configuration, DimensionItem newDimension)
{
this._configuration = configuration;
this._newDimension = newDimension;
_lookupRefinement = ListDimensionCache.Get(_configuration.repositoryId, _newDimension.DIdx, _configuration.query);
//Try to get the Count objects from the cache
//If not found it will be calculated below
this.IsCachehit = (_lookupRefinement != null);
}
private void AddTotalDimension(Page page, double width, double startX, double endX)
{
DimensionItem item = Util.eplan.AddDimension(page, null, width, startX, _dimOffset[0], endX, _dimOffset[0], 20);
if (item != null)
{
item.DimensionCalculated = false;
item.DimensionText = string.Format("{0:F0}", width);
item.DimensionLineTermination = DimensionItem.Enums.DimensionLineTermination.Without;
}
}
/// <summary />
public DimensionItem Where(string name)
{
var retval = this.FirstOrDefault(x => x.Name == name);
if (retval == null)
{
retval = new DimensionItem
{
Name = name,
};
}
return(retval);
}
public static List <MyItem> GetItems()
{
var _headers = new List <DimensionItem>();
var _dimensions = new List <DimensionItem>();
const string FILE = @"C:\Users\DB-Server\AppData\Local\Temp\c6827c93-db6a-465c-a3f9-a1112971487c";
using (var reader = XmlReader.Create(FILE))
{
var inHeaders = false;
while (reader.Read())
{
if (inHeaders && reader.Name == "h")
{
_headers.Add(new DimensionItem
{
DIdx = Convert.ToInt64("0" + reader.GetAttribute("didx")),
Name = reader.ReadInnerXml(),
});
}
if (reader.Name == "headers")
{
inHeaders = true;
}
if (reader.Name == "dimensions")
{
break;
}
}
DimensionItem currentD = null;
while (reader.Read())
{
if (reader.Name == "d")
{
currentD = new DimensionItem {
Name = reader.GetAttribute("name"), DIdx = Convert.ToInt64(reader.GetAttribute("didx"))
};
_dimensions.Add(currentD);
}
else if (reader.Name == "r")
{
currentD.RefinementList.Add(new RefinementItem
{
DIdx = currentD.DIdx,
DVIdx = Convert.ToInt64(reader.GetAttribute("dvidx")),
FieldValue = reader.ReadElementContentAsString(),
});
}
if (reader.Name == "items")
{
break;
}
}
_dimensions.RemoveAll(x => x.DIdx == 0);
}
try
{
var retval = new List <MyItem>();
var ordinalPosition = 0;
using (var reader = XmlReader.Create(FILE))
{
while (reader.Read())
{
var isNewItem = false;
var newItem = new MyItem();
if (reader.Name == "i")
{
isNewItem = true;
long.TryParse(reader.GetAttribute("ri"), out long ri);
int.TryParse(reader.GetAttribute("ts"), out int ts);
//Setup static values
newItem.__RecordIndex = ri;
newItem.__Timestamp = ts;
newItem.__OrdinalPosition = ordinalPosition++;
//Loop through all properties for this new item
var elementXml = reader.ReadOuterXml();
var doc = XDocument.Parse(elementXml);
var fieldIndex = 0;
foreach (var n in doc.Descendants().Where(x => x.Name == "v"))
{
var prop = newItem.GetType().GetProperty(_headers[fieldIndex].Name);
var isNull = n.Value == "~■!N";
if (isNull)
{
prop.SetValue(newItem, null, null);
}
else if (prop.PropertyType == typeof(int?) || prop.PropertyType == typeof(int))
{
prop.SetValue(newItem, int.Parse(n.Value), null);
}
else if (prop.PropertyType == typeof(DateTime?) || prop.PropertyType == typeof(DateTime))
{
var dt = new DateTime(Convert.ToInt64(n.Value));
prop.SetValue(newItem, dt, null);
}
else if (prop.PropertyType == typeof(bool?) || prop.PropertyType == typeof(bool))
{
prop.SetValue(newItem, n.Value == "1", null);
}
else if (prop.PropertyType == typeof(Single?) || prop.PropertyType == typeof(Single))
{
prop.SetValue(newItem, Convert.ToSingle(n.Value), null);
}
else if (prop.PropertyType == typeof(GeoCode))
{
var geoArr = n.Value.Split('|');
var geo = new GeoCode {
Latitude = Convert.ToDouble(geoArr[0]), Longitude = Convert.ToDouble(geoArr[1])
};
prop.SetValue(newItem, geo, null);
}
else if (prop.PropertyType == typeof(string))
{
prop.SetValue(newItem, n.Value, null);
}
else if (prop.PropertyType == typeof(string[]))
{
//Get real values
var d = _dimensions.FirstOrDefault(x => x.DIdx == _headers[fieldIndex].DIdx);
if (d != null)
{
var varr = n.Value.Split('|').Select(x => Convert.ToInt64(x)).ToList();
var v = d.RefinementList.Where(x => varr.Contains(x.DVIdx)).Select(x => x.FieldValue).ToArray();
prop.SetValue(newItem, v, null);
}
}
else
{
//TODO
}
fieldIndex++;
}
}
if (isNewItem)
{
retval.Add(newItem);
}
}
}
return(retval);
}
catch (Exception ex)
{
throw;
}
}
private CacheResults GetCache(DatastoreEntities context, int id, RepositorySchema schema)
{
try
{
var dimensionValueTableName = SqlHelper.GetDimensionValueTableName(schema.ID);
var dimensionValueTableNameParent = string.Empty;
lock (_cache)
{
var dimensionStamp = RepositoryManager.GetDimensionChanged(context, id);
var retval = _cache.FirstOrDefault(x => x.RepositoryId == id);
//Check repository DimensionStamp and if changed the reload dimensions
if (retval != null && retval.DimensionStamp != dimensionStamp)
{
Clear(id);
retval = null;
}
if (retval == null)
{
#region Parent table stuff
if (schema.ParentID != null)
{
if (!_parentSchemaCache.ContainsKey(schema.ID))
{
var parentSchema = RepositoryManager.GetSchema(schema.ParentID.Value);
_parentSchemaCache.Add(schema.ID, schema.Subtract(parentSchema));
}
dimensionValueTableNameParent = SqlHelper.GetDimensionValueTableName(schema.ParentID.Value);
}
#endregion
retval = new CacheResults()
{
RepositoryId = id, ParentId = RepositoryManager.GetSchemaParentId(id)
};
_cache.Add(retval);
var sb = new StringBuilder();
sb.AppendLine($"select v.DIdx, v.DVIdx, v.Value from [{dimensionValueTableName}] v");
//If there is a parent schema then UNION its dimension tables
if (schema.ParentID != null)
{
sb.AppendLine($"union select v.DIdx, v.DVIdx, v.Value from [{dimensionValueTableNameParent}] v");
}
sb.AppendLine("order by DIdx, DVIdx");
var ds = SqlHelper.GetDataset(ConfigHelper.ConnectionString, sb.ToString(), null);
retval.Results = new List <DimensionItem>();
//Load all dimensions
foreach (var dimension in schema.DimensionList)
{
retval.Results.Add(new DimensionItem
{
DIdx = dimension.DIdx,
Name = dimension.Name,
});
}
foreach (DataRow dr in ds.Tables[0].Rows)
{
var didx = (long)dr["DIdx"];
long dvidx = 0;
string v = null;
if (dr["DVIdx"] != System.DBNull.Value)
{
dvidx = (long)dr["DVIdx"];
v = (string)dr["Value"];
}
var d = retval.Results.FirstOrDefault(x => x.DIdx == didx);
if (d == null)
{
d = new DimensionItem {
DIdx = (int)didx, Name = schema.DimensionList.Where(x => x.DIdx == didx).Select(x => x.Name).FirstOrDefault()
};
retval.Results.Add(d);
}
if (dvidx != 0)
{
d.RefinementList.Add(new RefinementItem {
DVIdx = dvidx, FieldValue = v, DIdx = didx
});
}
//Rearrange all refinements alpha (for debugging and such)
//retval.Results.ForEach(ditem => ditem.RefinementList = ditem.RefinementList.OrderBy(x => x.FieldValue).ToList());
}
}
retval.DimensionStamp = dimensionStamp;
retval.Timestamp = DateTime.Now; //Accessed
return(retval);
}
}
catch (Exception ex)
{
throw;
}
}
/// <summary />
public void WaitUntilReady(long timeout = 0)
{
if (timeout < 0)
{
timeout = 0;
}
try
{
if (this.IsComplete)
{
return;
}
#region Wait for file to be ready
var startTime = DateTime.Now;
while (!_dsService.QueryAsyncReady(_hookId))
{
//If there is a timeout and it is exceeded then throw exception
if (timeout > 0 && DateTime.Now.Subtract(startTime).TotalMilliseconds > timeout)
{
throw new TimeoutException($"Time exceeded {timeout}ms");
}
System.Threading.Thread.Sleep(5000);
}
#endregion
#region Get chunks and append to file
var chunk = 0;
byte[] chunkData = null;
var tempFile = Path.Combine(this.GetTempPath(), Guid.NewGuid().ToString());
do
{
chunkData = _dsService.QueryAsyncDownload(_hookId, chunk);
if (chunkData != null)
{
using (var stream = new FileStream(tempFile, FileMode.Append))
{
stream.Write(chunkData, 0, chunkData.Length);
}
chunk++;
}
} while (chunkData != null);
#endregion
#region Unzip the file in temp folder
_dataFile = Path.Combine(this.GetTempPath(), Guid.NewGuid().ToString());
Extensions.UnzipFile(tempFile, _dataFile);
if (File.Exists(tempFile))
{
File.Delete(tempFile);
}
#endregion
#region Load file headers and dimensions
//This will dispose in the dispose event
_reader = XmlReader.Create(_dataFile);
var inHeaders = false;
while (_reader.Read())
{
if (inHeaders && _reader.Name == "h" && _reader.NodeType == XmlNodeType.Element)
{
string tt = null;
var didx = Convert.ToInt64("0" + _reader.GetAttribute("didx"));
_reader.Read();
if (_reader.NodeType == XmlNodeType.Text)
{
tt = _reader.Value;
}
_headers.Add(new DimensionItem
{
DIdx = didx,
Name = tt,
});
}
if (_reader.Name == "headers")
{
inHeaders = true;
}
if (_reader.Name == "dimensions")
{
break;
}
}
DimensionItem currentD = null;
while (_reader.Read())
{
if (_reader.Name == "d" && _reader.NodeType == XmlNodeType.Element)
{
var didx = Convert.ToInt64("0" + _reader.GetAttribute("didx"));
var tt = _reader.GetAttribute("name");
currentD = new DimensionItem
{
Name = tt,
DIdx = didx,
};
_dimensions.Add(currentD);
}
else if (_reader.Name == "r" && _reader.NodeType == XmlNodeType.Element)
{
string tt = null;
var dvidx = Convert.ToInt64("0" + _reader.GetAttribute("dvidx"));
_reader.Read();
if (_reader.NodeType == XmlNodeType.Text)
{
tt = _reader.Value;
}
//Never happens but needed to avoid false positive in security scans
if (currentD != null)
{
currentD.RefinementList.Add(new RefinementItem
{
DIdx = currentD.DIdx,
DVIdx = dvidx,
FieldValue = tt,
});
}
}
if (_reader.Name == "items")
{
break;
}
}
_dimensions.RemoveAll(x => x.DIdx == 0);
#endregion
this.IsComplete = true;
}
catch (Exception ex)
{
this.IsComplete = true;
_dataFile = null;
throw;
}
}
