public static ValidationConfigurationBuilderMember <TEntity, TMember> AddRangeValidator <TEntity, TMember>(
this ValidationConfigurationBuilderMember <TEntity, TMember> memberBuilder,
RangeData <TMember> rangeData) where TMember : IComparable
{
memberBuilder.AddValidator(rangeData.CreateValidator());
return(memberBuilder);
}
protected override void Run()
{
if (IsPlugged)
return;
trace = CreateTraceLog();
CollectStackObjects();
stackLocalRangeData = new RangeData[stack.Count];
registerRangeData = new RangeData[Architecture.RegisterSet.Length];
for (int i = 0; i < registerRangeData.Length; i++)
{
var range = new RangeData();
range.Register = Architecture.RegisterSet[i];
registerRangeData[i] = range;
}
foreach (var local in stack)
{
var range = new RangeData();
range.StackLocal = local.Key;
stackLocalRangeData[local.Value] = range;
}
CollectObjectAssignmentsAndUses();
}
/// <summary>
/// fm_copy_ranges
/// </summary>
/// <param name="range"></param>
private void RangeConvert(RangeData gatewayRange, RangeData runtimeRange, GatewayAdapterCursor gatewayAdapterCursor)
{
DBField field = gatewayAdapterCursor.Definition.FieldsDefinition[gatewayRange.FieldIndex];
ConvertBoundaryToGateway(gatewayRange.Min, runtimeRange.Min, field);
ConvertBoundaryToGateway(gatewayRange.Max, runtimeRange.Max, field);
}
public JsonResult UploadRange(String UserName, String RangeName, String Description, String Address, String Data)
{
using (var context = new xlsnippingtoolEntities())
{
var qryUser = context.Users.Where(x => x.Name.Equals(UserName));
User userEntity = qryUser.FirstOrDefault();
if (userEntity == null)
{
userEntity = new User()
{
Name = UserName
};
context.Users.Add(userEntity);
context.SaveChanges();
}
var qryUserRange = context.UserRanges.Where(x => x.RangeName.Equals(RangeName) && x.UserId.Equals(userEntity.Id));
UserRange UserRangeEntity = qryUserRange.FirstOrDefault();
if (UserRangeEntity == null)
{
UserRange range = new UserRange();
range.Description = Description;
range.RangeName = RangeName;
range.UserId = userEntity.Id;
context.UserRanges.Add(range);
context.SaveChanges();
RangeData data = new RangeData();
data.Address = Address;
data.Data = Data;
data.RangeId = range.Id;
context.RangeDatas.Add(data);
context.SaveChanges();
}
else
{
//update
UserRangeEntity.RangeName = RangeName;
UserRangeEntity.Description = Description;
context.SaveChanges();
var qryRangeData = context.RangeDatas.Where(x => x.RangeId.Equals(UserRangeEntity.Id));
RangeData rData = qryRangeData.FirstOrDefault();
if (rData == null)
{
rData = new RangeData();
rData.Address = Address;
rData.Data = Data;
rData.RangeId = userEntity.Id;
context.RangeDatas.Add(rData);
}
else
{
rData.Data = Data;
rData.Address = Address;
}
context.SaveChanges();
}
}
return(Json("Success", JsonRequestBehavior.AllowGet));
}
protected virtual void grid_MouseDown(GridVirtual sender, MouseEventArgs e)
{
if (sender.Selection.BorderRange.IsEmpty() == false)
{
Position mousePos = sender.PositionAtPoint(new System.Drawing.Point(e.X, e.Y));
if (mousePos.IsEmpty() == false)
{
int distance;
DevAge.Drawing.RectanglePartType partType = sender.Selection.Border.PointToPartType(sender.Selection.GetDrawingRectangle(),
new System.Drawing.Point(e.X, e.Y), out distance);
if (partType == DevAge.Drawing.RectanglePartType.BottomBorder ||
partType == DevAge.Drawing.RectanglePartType.TopBorder ||
partType == DevAge.Drawing.RectanglePartType.RightBorder ||
partType == DevAge.Drawing.RectanglePartType.LeftBorder)
{
RangeData data = new RangeData();
data.LoadData(sender, sender.Selection.BorderRange, mousePos, mCutMode);
if (mCutMode == CutMode.None)
{
sender.DoDragDrop(data, DragDropEffects.Copy);
}
else
{
sender.DoDragDrop(data, DragDropEffects.Move);
}
}
}
}
}
//---------------------------------------
// Update tile list
//---------------------------------------
// Get tiles 'range' away from the org tiles
public static List <Tile> UpdateTileListOutOfRange(List <Tile> oldList, List <Tile> orgs, int range)
{
if (orgs.Count <= 0)
{
return(oldList);
}
Tile org = orgs[orgs.Count - 1];
// Make a rangeData for tiles out of range
RangeData rangeData = new RangeData();
rangeData.range = range;
rangeData.outOfRange = true;
rangeData.targetTiles = oldList;
List <Tile> newList = GetRangeTiles(org, rangeData);
List <Tile> newOrgs = new List <Tile>();
foreach (Tile tile in orgs)
{
if (tile != org)
{
newOrgs.Add(tile);
}
}
// Recursively go over all the org and update the list
newList = UpdateTileListOutOfRange(newList, newOrgs, range);
return(newList);
}
internal override GatewayResult Execute()
{
Record();
GatewayResult result = new GatewayResult();
GatewayAdapterCursor gatewayAdapterCursor = GatewayAdapter.GetCursor(RuntimeCursor);
Debug.Assert(gatewayAdapterCursor != null);
// clear old ranges - might contain old locates.
gatewayAdapterCursor.Ranges.Clear();
// TODO 1:
// fm_crsr_cache_open ???
// Copy ranges from runtime to gateway
if (RuntimeCursor.RuntimeCursorData.Ranges != null)
{
foreach (RangeData runtimeRange in RuntimeCursor.RuntimeCursorData.Ranges)
{
RangeData gatewayRange = new RangeData(runtimeRange);
RangeConvert(gatewayRange, runtimeRange, gatewayAdapterCursor);
gatewayAdapterCursor.Ranges.Add(gatewayRange);
}
}
// TODO 2:
// fm_copy_sql_ranges
result.ErrorCode = GatewayAdapter.Gateway.CrsrOpen(gatewayAdapterCursor);
SetErrorDetails(result);
return(result);
}
public void ShouldPaseIntoColumnsWith_VisibleFalse()
{
Grid grid1 = new Grid();
grid1.Redim(6, 4);
grid1[0, 0] = new SourceGrid.Cells.Cell("a");
grid1[0, 1] = new SourceGrid.Cells.Cell("b");
grid1[0, 2] = new SourceGrid.Cells.Cell("c");
grid1[0, 3] = new SourceGrid.Cells.Cell("d");
RangeData data = RangeData.LoadData(grid1, new Range(0, 0, 0, 3), CutMode.None);
grid1.Columns[1].Visible = false;
grid1[1, 0] = new SourceGrid.Cells.Cell("x", typeof(string));
grid1[1, 1] = new SourceGrid.Cells.Cell("x", typeof(string));
grid1[1, 2] = new SourceGrid.Cells.Cell("x", typeof(string));
grid1[1, 3] = new SourceGrid.Cells.Cell("x", typeof(string));
data.WriteData(grid1, new Position(1, 0));
Assert.AreEqual("a", grid1[1, 0].Value);
Assert.AreEqual("b", grid1[1, 1].Value);
Assert.AreEqual("c", grid1[1, 2].Value);
Assert.AreEqual("d", grid1[1, 3].Value);
}
protected override void Run()
{
if (IsPlugged)
{
return;
}
trace = CreateTraceLog();
CollectStackObjects();
stackLocalRangeData = new RangeData[stack.Count];
registerRangeData = new RangeData[Architecture.RegisterSet.Length];
for (int i = 0; i < registerRangeData.Length; i++)
{
var range = new RangeData();
range.Register = Architecture.RegisterSet[i];
registerRangeData[i] = range;
}
foreach (var local in stack)
{
var range = new RangeData();
range.StackLocal = local.Key;
stackLocalRangeData[local.Value] = range;
}
CollectObjectAssignmentsAndUses();
}
bool FindTextPointersI(LineBreak lb, ref RangeData rd)
{
if (rd.Pointer1 == null)
{
if (rd.Remaining1 <= 0)
{
rd.Pointer1 = lb.ContentStart;
}
else
{
rd.Remaining1 -= EolLength;
}
}
if (rd.Pointer2 == null)
{
if (rd.Remaining2 <= 0)
{
rd.Pointer2 = lb.ContentStart;
}
else
{
rd.Remaining2 -= EolLength;
}
}
return(rd.Done);
}
public void AddRangeTest()
{
RangeData rangeData = new RangeData();
rangeData.AddRange(100, 100);
rangeData.Count.Is(1);
rangeData.Range.Take(1).Is(new(int, int)[] { (100, 100) });
public ActionResult SaveRange(RangeData range)
{
if (string.IsNullOrWhiteSpace(range.ManifestId) ||
string.IsNullOrWhiteSpace(range.StartCanvas) ||
string.IsNullOrWhiteSpace(range.EndCanvas))
{
throw new ApplicationException("Missing range data");
}
var di = GetDirectoryForRanges(range.ManifestId);
int index = 1;
if (di.Exists)
{
var existingFileNames = di.GetFiles().Select(fi => fi.Name.Replace(".json", "")).OrderBy(s => s);
var max = existingFileNames.LastOrDefault();
if (max != null)
{
index = int.Parse(max) + 1;
}
}
else
{
di.Create();
}
var rangeFilename = index.ToString("D4");
range.Id = string.Format("{0}/{1}", di.Name, rangeFilename);
range.RangeManifestId = Request.Url.GetLeftPart(UriPartial.Authority) + "/manifest/" + range.Id;
var json = JsonConvert.SerializeObject(range, Formatting.Indented);
var target = Path.Combine(di.FullName, rangeFilename + ".json");
System.IO.File.WriteAllText(target, json, Encoding.UTF8);
return(Content(json, "application/json"));
}
public void ClearTest()
{
RangeData rangeData = new RangeData();
rangeData.AddRange(0, 1920);
rangeData.Clear();
rangeData.Count.Is(0);
}
static public int ByHeading(RangeData first, RangeData second)
{
// we compare both values based on how far they are from "straight ahead" course
double dFirst = Math.Abs(first.Heading);
double dSecond = Math.Abs(second.Heading);
return(dFirst.CompareTo(dSecond));
}
public static IEnumerable <T> Interpolate <T>(this RangeData <T> rangeData, Func <T, T> next) where T : IComparable
{
var current = rangeData.Min;
while (current.CompareTo(rangeData.Max) <= 0)
{
yield return(current = next(current));
}
}
// Get tiles using Range Data
public static List <Tile> GetRangeTiles(Tile org, RangeData rangeData)
{
List <Tile> newList = new List <Tile>();
int startIndex = rangeData.range * -1;
// If outOfRange is true, only check targetTiles condition
if (rangeData.outOfRange)
{
List <Tile> targetTileList;
if ((rangeData.targetTiles != null) && (rangeData.targetTiles.Count > 0))
{
targetTileList = rangeData.targetTiles;
}
else
{
targetTileList = GetMazeTileList();
}
foreach (Tile t in targetTileList)
{
if (CheckTargetOutOfRange(org, t, rangeData.range))
{
newList.Add(t);
}
}
}
// Find all the tiles within 'square' range of org and do the range condition check
else
{
for (int i = startIndex; i <= rangeData.range; i++)
{
for (int j = startIndex; j <= rangeData.range; j++)
{
if (CoordinatesOutOfMazeSize(org.X + i, org.Z + j))
{
continue;
}
Tile tile = GetMazeTile()[org.X + i, org.Z + j];
if (!RangeData.CheckRangeDataCondition(org, tile, rangeData))
{
continue;
}
newList.Add(tile);
}
}
}
return(newList);
}
/// <summary>
/// convert a UserRange object to A RangeData object
/// </summary>
/// <param name="userRange"></param>
/// <param name="field"></param>
/// <returns></returns>
internal RangeData UserRangeToDataRange(UserRange userRange, IFieldView fieldView)
{
RangeData rangedata = new RangeData();
rangedata.FieldIndex = TaskViews.ViewMain.GetFieldIndexInViewByIndexInRecord(fieldView.Id);
InitBoundary(rangedata.Min, fieldView.StorageAttribute, userRange.discardMin, userRange.min, fieldView.Length, Char.MinValue);
InitBoundary(rangedata.Max, fieldView.StorageAttribute, userRange.discardMax, userRange.max, fieldView.Length, Char.MaxValue);
return(rangedata);
}
private void grid_KeyDown(GridVirtual sender, KeyEventArgs e)
{
if (e.Handled)
{
return;
}
Range rng = sender.Selection.BorderRange;
if (rng.IsEmpty())
{
return;
}
//Paste
if (e.Control && e.KeyCode == Keys.V)
{
RangeData rngData = RangeData.ClipboardGetData();
if (rngData != null)
{
Range destinationRange = rngData.FindDestinationRange(sender, rng.Start);
if (ExpandSelection == false)
{
destinationRange = destinationRange.Intersect(rng);
}
rngData.WriteData(sender, destinationRange);
e.Handled = true;
sender.Selection.Clear();
sender.Selection.Add(destinationRange);
}
}
//Copy
else if (e.Control && e.KeyCode == Keys.C)
{
RangeData data = new RangeData();
data.LoadData(sender, rng, rng.Start, CutMode.None);
RangeData.ClipboardSetData(data);
e.Handled = true;
}
//Cut
else if (e.Control && e.KeyCode == Keys.X && EnableCutData)
{
RangeData data = new RangeData();
data.LoadData(sender, rng, rng.Start, CutMode.CutImmediately);
RangeData.ClipboardSetData(data);
e.Handled = true;
}
}
private void ResetTempData()
{
mRangeData = null;
#warning da fare
//if (mHighlightedRange != null)
//{
// mHighlightedRange.Range = Range.Empty;
// if (mHighlightedRange.Grid.HighlightedRanges.Contains(mHighlightedRange))
// mHighlightedRange.Grid.HighlightedRanges.Remove(mHighlightedRange);
// mHighlightedRange = null;
//}
}
bool FindTextPointersI(Span span, ref RangeData rd)
{
foreach (var inline in span.Inlines)
{
var r = FindTextPointersI((dynamic)inline, ref rd);
if (r)
{
return(true);
}
}
return(false);
}
private void ResetTempData()
{
mRangeData = null;
#warning da fare
//if (mHighlightedRange != null)
//{
// mHighlightedRange.Range = Range.Empty;
// if (mHighlightedRange.Grid.HighlightedRanges.Contains(mHighlightedRange))
// mHighlightedRange.Grid.HighlightedRanges.Remove(mHighlightedRange);
// mHighlightedRange = null;
//}
}
bool FindTextPointersB(Section section, ref RangeData rd)
{
foreach (var block in section.Blocks)
{
var r = FindTextPointersB((dynamic)block, ref rd);
if (r)
{
return(true);
}
}
return(false);
}
bool FindTextPointersB(Paragraph paragraph, ref RangeData rd)
{
if (rd.Pointer1 == null && rd.Remaining1 <= 0)
{
rd.Pointer1 = paragraph.ContentStart;
}
if (rd.Pointer2 == null && rd.Remaining2 <= 0)
{
rd.Pointer2 = paragraph.ContentStart;
}
if (rd.Done)
{
return(true);
}
foreach (var inline in paragraph.Inlines)
{
var r = FindTextPointersI((dynamic)inline, ref rd);
if (r)
{
return(true);
}
}
if (rd.Pointer1 == null)
{
if (rd.Remaining1 <= 0)
{
rd.Pointer1 = paragraph.ContentEnd;
}
else
{
rd.Remaining1 -= EolLength;
}
}
if (rd.Pointer2 == null)
{
if (rd.Remaining2 <= 0)
{
rd.Pointer2 = paragraph.ContentEnd;
}
else
{
rd.Remaining2 -= EolLength;
}
}
return(rd.Done);
}
public bool LoadData(sCustFontData custFontData)
{
RangeData rangeData = custFontData.pRangeDetails.pRangeData;
byte[] WidthArray = custFontData.pWidthArray;
byte[] DWidthArray = custFontData.pDWidthArray;
UInt32[] OffsetArray = custFontData.pOffsetArray;
UInt16[] OffsetArrayC = custFontData.pOffsetArrayC;
byte[] DataArray = custFontData.pDataArray;
int index = 0;
m_width = custFontData.nWidth;
m_height = custFontData.nHeight;
if (DWidthArray == null)
{
DWidthArray = WidthArray;
}
if (custFontData.nEquiDistant == 0)
{
m_header = "STARTFONT 2.1\r\n" +
"FONTBOUNDINGBOX " + custFontData.nWidth + " " + custFontData.nHeight + " " + "0" + " " + "0" + "\r\n" +
"STARTPROPERTIES " + "2" + "\r\n" +
"FONT_ASCENT " + custFontData.nAscent + "\r\n" +
"FONT_DESCENT " + custFontData.nDescent + "\r\n" +
"ENDPROPERTIES" + "\r\n"; // +
//"CHARS " + m_rangeData.m_chars + "\r\n";
for (int i = 0; i < rangeData.m_rangeData.Length; i++)
{
for (UInt16 j = rangeData.m_rangeData[i].nMin; j < rangeData.m_rangeData[i].nMax + 1; j++)
{
if (custFontData.nEquiDistant == 0)
{
FontBitmap fbmp = new FontBitmap(j, WidthArray[index], DWidthArray[index], custFontData.nHeight, index, DataArray, (UInt32)(OffsetArrayC[index]));
m_FontArray[fbmp.m_ch] = fbmp;
}
else
{
FontBitmap fbmp = new FontBitmap(j, custFontData.nWidth, custFontData.nWidth, custFontData.nHeight, index, DataArray, (UInt32)index * custFontData.nCharBytes);
m_FontArray[fbmp.m_ch] = fbmp;
}
index++;
}
}
return(true);
}
return(false);
//temp += "ENDFONT" + "\r\n";
}
private void ResetTempData()
{
mRangeData = null;
if (mHighlightedRange != null)
{
mHighlightedRange.Range = Range.Empty;
if (mHighlightedRange.Grid.HighlightedRanges.Contains(mHighlightedRange))
{
mHighlightedRange.Grid.HighlightedRanges.Remove(mHighlightedRange);
}
mHighlightedRange = null;
}
}
public void ShouldNotCopyColumnsWith_VisibleFalse()
{
Grid grid1 = new Grid();
grid1.Redim(6, 2);
grid1[0, 0] = new SourceGrid.Cells.Cell("a");
grid1[0, 1] = new SourceGrid.Cells.Cell("b");
grid1.Columns[1].Visible = false;
RangeData data = RangeData.LoadData(grid1, new Range(0, 0, 0, 1), CutMode.None);
Assert.AreEqual(1, data.SourceValues.Length);
Assert.AreEqual("a", data.SourceValues[0, 0]);
}
public static void Analyze(String stock, string startDate, string endDate, string filter)
{
//IApplicationContext ctx = ContextRegistry.GetContext();
StockLog.Log.Info("start to create stock data");
StockData data1 = new StockData(stock, startDate, endDate, true);//(StockData)ctx.GetObject("StockData");
StockLog.Log.Info("start to create normal data");
NormalData gd = new NormalData(data1);//(NormalData)ctx.GetObject("NormalData");
StockLog.Log.Info("start to create big deal data");
BigDealData bdd = new BigDealData(data1, filter);
//(BigDealData)ctx.GetObject("BigDealData");
//RangeData bigdeal = new RangeData(bdd, type); //(RangeData)ctx.GetObject("BigRangeData");
// RangeData alldeal = new RangeData(gd, type);//(RangeData)ctx.GetObject("AllRangeData");
if (!Directory.Exists(Constant.ANALYZE_FOLDER + stock))
{
// Directory.Delete(Constant.ANALYZE_FOLDER + stock, true);
Directory.CreateDirectory(Constant.ANALYZE_FOLDER + stock);
}
else
{
if (Constant.CLEAN)
{
Directory.Delete(Constant.ANALYZE_FOLDER + stock, true);
Directory.CreateDirectory(Constant.ANALYZE_FOLDER + stock);
}
}
foreach (int type in Enum.GetValues(typeof(RangeType)))
{
//String filePath = string.Format(@"{0}{1}\{1}_{2}_{3}_{4}_{5}.csv", Constant.ANALYZE_FOLDER, stock, startDate, endDate, filter, (RangeType)type);
String filePath = string.Format(@"{0}{1}\{1}_{3}_{2}.csv", Constant.ANALYZE_FOLDER, stock, (RangeType)type, filter);
StockLog.Log.Info("start to analyze " + (RangeType)type);
if (!File.Exists(filePath))
{
RangeData bigdeal = new RangeData(bdd, type); //(RangeData)ctx.GetObject("BigRangeData");
RangeData alldeal = new RangeData(gd, type); //(RangeData)ctx.GetObject("AllRangeData");
Dictionary <string, FilterData> big = bigdeal.DataList;
Dictionary <string, FilterData> all = alldeal.DataList;
FileUtil.WriteFile(filePath, DataUtil.Compare(all, big));
}
StockLog.Log.Info("End to analyze " + (RangeType)type);
}
}
/// <summary>
/// compute range values of the fields
/// </summary>
/// <returns></returns>
internal RangeData ComputeRangeData()
{
//tsk_vee_rng
RangeData rangeData = new RangeData()
{
FieldIndex = IndexInView
};
Range.compute(false);
//check this :
char maxChar = UtilStrByteMode.isLocaleDefLangJPN() ? (char)0xFFEE : (char)0x7FFF;
rangeData.Min = BuildBoundaryValue(Range.hasMinExp(), Range.MaxEqualsMin, Range.MinExpVal, Char.MinValue, Range.DiscardMin);
rangeData.Max = BuildBoundaryValue(Range.hasMaxExp(), Range.MaxEqualsMin, Range.MaxExpVal, maxChar, Range.DiscardMax);
return(rangeData);
}
/// <summary>
/// build the RangeData object from the min and max strings
/// </summary>
/// <param name="minVal"></param>
/// <param name="maxVal"></param>
/// <returns></returns>
private RangeData BuildRangeData(string minVal)
{
int indexInView = ((RuntimeReadOnlyView)viewBoundaries.RuntimeViewBase).GetFieldIndexInViewByIndexInRecord(fieldView.Id);
RangeData rangeData = new RangeData()
{
FieldIndex = indexInView
};
object mgMinVal = StringToMgVal(fieldView.StorageAttribute, minVal, fieldView.Length, fieldView.Picture);
object minValue;
if (fieldView.StorageAttribute == StorageAttribute.ALPHA || fieldView.StorageAttribute == StorageAttribute.UNICODE)
{
minValue = StrUtil.SearchAndReplaceWildChars((String)mgMinVal, fieldView.Length, Char.MinValue);
}
else
{
minValue = mgMinVal;
}
rangeData.Min.Value = new FieldValue()
{
Value = minValue, IsNull = false
};
rangeData.Min.Type = RangeType.RangeParam;
object maxValue;
//if looking for a string, we need to padd it with max chars, to allow locating strings which begin with the requested value
if (fieldView.StorageAttribute == StorageAttribute.ALPHA || fieldView.StorageAttribute == StorageAttribute.UNICODE)
{
maxValue = ((String)mgMinVal).Replace('\0', Char.MaxValue);
maxValue = StrUtil.SearchAndReplaceWildChars((String)maxValue, fieldView.Length, Char.MaxValue);
}
else
{
maxValue = mgMinVal;
}
rangeData.Max.Value = new FieldValue()
{
Value = maxValue, IsNull = false
};
rangeData.Max.Type = RangeType.RangeParam;
return(rangeData);
}
/// <summary>
/// compute locate values of the fields
/// </summary>
/// <returns></returns>
internal RangeData ComputeLocateData()
{
RangeData locateData = new RangeData()
{
FieldIndex = IndexInView
};
// Compute of locate should search for the range of data only if it done on the main datasource and not for link.
// Locate on link is actually a range.
Locate.compute(!IsLink);
//check this :
char maxChar = UtilStrByteMode.isLocaleDefLangJPN() ? (char)0xFFEE : (char)0x7FFF;
locateData.Min = BuildBoundaryValue(Locate.hasMinExp(), Locate.MaxEqualsMin, Locate.MinExpVal, Char.MinValue, Locate.DiscardMin);
locateData.Max = BuildBoundaryValue(Locate.hasMaxExp(), Locate.MaxEqualsMin, Locate.MaxExpVal, maxChar, Locate.DiscardMax);
return(locateData);
}
public JsonResult DownloadRange(int RangeId)
{
RangeDataModel rDataModel = new RangeDataModel();
using (var context = new xlsnippingtoolEntities())
{
var qry = context.RangeDatas.ToList().Where(x => x.RangeId.Equals(RangeId));
RangeData data = qry.FirstOrDefault();
if (data == null)
{
return(null);
}
String[][] rData = JsonConvert.DeserializeObject <String[][]>(data.Data);
rDataModel.Address = data.Address;
rDataModel.Data = rData;
}
return(Json(rDataModel, JsonRequestBehavior.AllowGet));
}
/// <summary>
/// LogRngSlct()
/// </summary>
/// <param name="pSlct"></param>
public static void LogRngSlct(RangeData range)
{
Logger.Instance.WriteDevToLog("RangeData");
switch (range.Min.Type)
{
case RangeType.RangeNoVal:
Logger.Instance.WriteDevToLog("min_typ - DB_RNG_NO_VAL");
break;
case RangeType.RangeParam:
Logger.Instance.WriteDevToLog("min_typ - DB_RNG_PARAM");
break;
case RangeType.RangeMinMax:
Logger.Instance.WriteDevToLog("min_typ - DB_RNG_MIN_MAX");
break;
default:
Logger.Instance.WriteDevToLog("min_typ - UNDEFINED");
break;
}
switch (range.Max.Type)
{
case RangeType.RangeNoVal:
Logger.Instance.WriteDevToLog("max_typ - DB_RNG_NO_VAL");
break;
case RangeType.RangeParam:
Logger.Instance.WriteDevToLog("max_typ - DB_RNG_PARAM");
break;
case RangeType.RangeMinMax:
Logger.Instance.WriteDevToLog("max_typ - DB_RNG_MIN_MAX");
break;
default:
Logger.Instance.WriteDevToLog("max_typ - UNDEFINED");
break;
}
return;
}
public JsonResult UploadRange(String UserName , String RangeName ,String Description , String Address,String Data )
{
using (var context = new xlsnippingtoolEntities())
{
var qryUser = context.Users.Where(x => x.Name.Equals(UserName));
User userEntity= qryUser.FirstOrDefault();
if (userEntity == null)
{
userEntity = new User() { Name = UserName };
context.Users.Add(userEntity);
context.SaveChanges();
}
var qryUserRange = context.UserRanges.Where(x => x.RangeName.Equals(RangeName) && x.UserId.Equals(userEntity.Id));
UserRange UserRangeEntity = qryUserRange.FirstOrDefault();
if (UserRangeEntity == null)
{
UserRange range = new UserRange();
range.Description = Description;
range.RangeName = RangeName;
range.UserId = userEntity.Id;
context.UserRanges.Add(range);
context.SaveChanges();
RangeData data = new RangeData();
data.Address = Address;
data.Data = Data;
data.RangeId = range.Id;
context.RangeDatas.Add(data);
context.SaveChanges();
}
else
{
//update
UserRangeEntity.RangeName = RangeName;
UserRangeEntity.Description = Description;
context.SaveChanges();
var qryRangeData = context.RangeDatas.Where(x => x.RangeId.Equals(UserRangeEntity.Id));
RangeData rData = qryRangeData.FirstOrDefault();
if (rData == null)
{
rData = new RangeData();
rData.Address = Address;
rData.Data = Data;
rData.RangeId = userEntity.Id;
context.RangeDatas.Add(rData);
}
else
{
rData.Data = Data;
rData.Address = Address;
}
context.SaveChanges();
}
}
return Json("Success", JsonRequestBehavior.AllowGet) ;
}
private static void RangeValidation(RangeData rangeData, RouteValueDictionary htmlAttributes) {
//Because JQuery client-side validation will not work for Date fields
if (rangeData.IsValid && !rangeData.IsDateRange) {
htmlAttributes["data-val"] = "true";
htmlAttributes["data-val-number"] = MvcUi.InvalidEntry;
htmlAttributes["data-val-range-min"] = rangeData.Min;
htmlAttributes["data-val-range-max"] = rangeData.Max;
htmlAttributes["data-val-range"] = String.Format(MvcUi.RangeMismatch, rangeData.Min, rangeData.Max);
}
}
///<exclude/>
public bool Equals(RangeData other)
{
if (ReferenceEquals(null, other)) return false;
if (ReferenceEquals(this, other)) return true;
return other._Tm.Equals(_Tm) && other._Ranges.SequenceEqual(_Ranges) && other._Geometry.Equals(_Geometry) && other._Config.Equals(_Config);
}
/// <summary>
/// Comparer to sort instances by distance.
/// </summary>
/// <param name="first">first reading</param>
/// <param name="second">second reading</param>
/// <returns>a value les than 0 if <paramref name="first"/> is closer than <paramref name="second"/>, 0 if both have the same distance, a value greater 0 otherwise</returns>
public static int ByDistance(RangeData first, RangeData second)
{
return first._distance.CompareTo(second._distance);
}
public static int ByHeading(RangeData first, RangeData second)
{
// we compare both values based on how far they are from "straight ahead" course
double dFirst = Math.Abs(first.Heading);
double dSecond = Math.Abs(second.Heading);
return dFirst.CompareTo(dSecond);
}
public static int ByWeight(RangeData first, RangeData second)
{
return first.Weight.CompareTo(second.Weight);
}
