protected override FloorPositionDto GetFloorPositionInternal(int userID)
{
ModuleProc PROC = new ModuleProc(this.DYN_MODULE_NAME, "GetFloorPositionInternal");
FloorPositionDto result = null;
try
{
result = DataHelper.GetFloorPosition(userID);
}
catch (Exception ex)
{
Log.Exception(PROC, ex);
}
return(result);
}
protected override void SaveFloorPositionInternal(FloorPositionDto request)
{
ModuleProc PROC = new ModuleProc(this.DYN_MODULE_NAME, "SaveFloorPositionInternal");
try
{
if (request != null)
{
foreach (var pair in request)
{
DataHelper.SaveFloorPosition(pair.Key.BarPosition, pair.Key.UserID, pair.Value.Top, pair.Value.Left);
Thread.Sleep(10);
}
}
}
catch (Exception ex)
{
Log.Exception(PROC, ex);
}
}
public static FloorPositionDto GetFloorPosition(int userID)
{
LogManager.WriteLog("GetFloorPosition called.", LogManager.enumLogLevel.Info);
FloorPositionDto result = new FloorPositionDto();
try
{
using (BMC.CoreLib.Data.Database db = BMC.CoreLib.Data.DbFactory.OpenDB(GetConnectionString()))
{
DbParameter[] parameters = db.CreateParameters(1);
parameters[0] = db.CreateParameter("@UserID", DbType.Int32, userID);
DataSet ds = db.ExecuteDataset("dbo.rsp_GetFloorPosition", parameters);
if (ds != null && ds.Tables.Count > 0)
{
DataTable dt = ds.Tables[0];
foreach (DataRow dr in dt.Rows)
{
result.Modify(userID, dr.Field<int>("Bar_Pos_No"),
dr.Field<int>("FloorLeft"),
dr.Field<int>("FloorTop"),
dr.Field<int>("RowNo"));
}
}
}
}
catch (Exception ex)
{
ExceptionManager.Publish(ex);
}
return result;
}
internal void NotifyFloorPosition(FloorPositionDto positions)
{
_clientSubcriber.NotifyFloorPosition(positions);
}
private void SetFloorPosition(FloorPositionDto positions)
{
_floorPosition.Copy(positions);
}
/// <summary>
/// Refreshes the data.
/// </summary>
/// <param name="barPositions">The bar positions.</param>
public void RefreshData(List<FloorStatusData> barPositions)
{
const string PROC = "[RefreshData]";
double widthmargin = 10;
double heightmargin = 20;
var curPos = 1;
bool clearMachines = false;
bool groupby = false;
_dispatcher.Invoke(new Action(
delegate()
{
groupby = _floorView.GroupByMachines;
}));
bool hasPositionSaved = false;
_floorView._teFloorPositions.Wait(TimeSpan.FromSeconds(30)); // wait for worst case seconds to retrive floor position from exchange server
int userId = CDOSettings.Current.LoggedInUser.SecurityUserID;
FloorPositionDto savedPositions = null;
try
{
// clear all the slot machine groupings
if (_floorView.DisplayGroupMachines)
{
foreach (var slotMachineGroupItem in _slotMachineGroups.Values)
{
slotMachineGroupItem.SlotMachineKeys.Clear();
if (!groupby)
_dispatcher.Invoke(new Action(
delegate()
{
this.RemoveSlotMachineGroupFromUI(slotMachineGroupItem);
}));
}
}
// add or update the slot machines
int rowIndex = 1;
foreach (FloorStatusData position in barPositions)
{
string key = position.Bar_Pos_Name;
_dispatcher.Invoke(new Action(
delegate()
{
SlotMachine newMachine = null;
SlotMachinePair pair = null;
if (_slotMachines.ContainsKey(key))
{
pair = _slotMachines[key];
newMachine = pair.Machine;
}
else
{
newMachine = new SlotMachine()
{
SlotNumber = Convert.ToInt32(position.Bar_Pos_Name).ToString(),
SlotNumberString = position.Bar_Pos_Name.ToString(),
SlotID = position.Bar_Pos_No,
AssetNumber = position.Asset_No
};
pair = new SlotMachinePair
{
Key = key,
PositionName = position.Bar_Pos_Name,
AssetNo = position.Asset_No,
Machine = newMachine
};
_slotMachines.Add(key, pair);
}
// slot status grouping
newMachine.SlotStatusString = position.Slot_Status;
SlotMachineGroupPair groupPair = null;
IList<string> groupItems = null;
if (_floorView.DisplayGroupMachines)
{
if (!_slotMachineGroups.ContainsKey(position.Slot_Status))
{
groupPair = new SlotMachineGroupPair()
{
Status = _floorView.GetSlotStatus(position.Slot_Status),
MachineGroup = new SlotMachineGroup()
{
Width = _canvas.Width - 10,
Height = 30,
},
DisplayText = _floorView.GetSlotStatusDecription(position.Slot_Status),
};
_slotMachineGroups.Add(position.Slot_Status, groupPair);
}
else
{
groupPair = _slotMachineGroups[position.Slot_Status];
}
groupItems = groupPair.SlotMachineKeys;
groupItems.Add(key);
}
// display game name instead of asset no
string assetNo = position.Asset_No;
if (Settings.DisplayGameNameInFloorView)
{
assetNo = position.Game_Name;
}
// Fix for Asset Number not displayed after finishing the Enrollment
pair.AssetNo = assetNo;
newMachine.AssetNumber = assetNo;
pair.RowIndex = rowIndex++;
newMachine.Top = Convert.ToDouble(position.FLOORTOP);
newMachine.Left = Convert.ToDouble(position.FLOORLEFT);
_floorView.SetSlotMouseUpEvent(newMachine);
if (position.Install_No != 0)
{
newMachine.InstallationNo = position.Install_No;
newMachine.IsEventUnCleared = !(newMachine.IsEventUnCleared);
newMachine.IsEventUnCleared = (bool)position.UnClearedEvent;
newMachine.Status = (SlotMachineStatus)Enum.Parse(typeof(SlotMachineStatus), position.Slot_Status);
newMachine.StackerEventReceived = position.StackerEventReceived.HasValue ? position.StackerEventReceived.Value : false;
newMachine.IsCollectable = position.IsCollectable < 1;
if (newMachine.StackerEventReceived)
{
newMachine.OuterRoundColor = Brushes.Goldenrod;
newMachine.InnerRoundColor = Brushes.IndianRed;
}
}
else
{
newMachine.Status = SlotMachineStatus.EmptyPosition;
newMachine.InstallationNo = 0;
}
if (_floorView.DisplayGroupMachines &&
groupPair.MachineGroup.OuterColor == null)
{
groupPair.MachineGroup.OuterColor = _floorView._slotMachineGroupBgBrush;// newMachine.OuterRoundColor;
groupPair.MachineGroup.OuterForeColor = _floorView._slotMachineGroupFgBrush;// newMachine.ForeColorBrush;
}
}));
}
// remove the slot machine
List<SlotMachinePair> removedMachines = (from a in _slotMachines
join b in barPositions
on a.Key equals b.Bar_Pos_Name
into matched
from c in matched.DefaultIfEmpty()
where c == null
select new SlotMachinePair
{
Key = a.Key,
Machine = a.Value.Machine
}).ToList();
if (removedMachines != null)
{
foreach (SlotMachinePair removedMachine in removedMachines)
{
_dispatcher.Invoke(new Action(
delegate()
{
this.ClearMachine(removedMachine.Machine);
}));
_slotMachines.Remove(removedMachine.Key);
}
}
// finally add the slot machines to the UI
_dispatcher.Invoke(new Action(
delegate()
{
#if DEBUG
Stopwatch watch = new Stopwatch();
watch.Start();
#endif
try
{
if (groupby)
{
// draw the headers
int slotPerWidth = Convert.ToInt32((_floorView.Width - SlotMachine.SlotMachineGap) / SlotMachine.SlotMachineWidthGap);
int gap = SlotMachine.SlotMachineGap;
double y = gap;
foreach (var group in _slotMachineGroups)
{
string title = group.Key;
SlotMachineGroupPair groupPair = group.Value;
SlotMachineGroup machineGroup = groupPair.MachineGroup;
int slots = groupPair.SlotMachineKeys.Count;
if (slots <= 0)
{
this.RemoveSlotMachineGroupFromUI(groupPair);
continue;
}
this.AddSlotMachineGroupToUI(groupPair);
groupPair.Left = 0;
groupPair.Top = y;
machineGroup.DisplayText = groupPair.DisplayText + " (" + slots.ToString() + ")";
Canvas.SetLeft(machineGroup, groupPair.Left);
Canvas.SetTop(machineGroup, groupPair.Top);
_floorView.CalculateGroupedSlotMachines(groupPair, slotPerWidth);
int row = 0;
int column = 0;
double sx = groupPair.Left + gap;
double sy = groupPair.Top + machineGroup.Height + gap;
foreach (var slotKey in groupPair.SlotMachineKeys)
{
SlotMachinePair slotPair = _slotMachines[slotKey];
SlotMachine newMachine = slotPair.Machine;
if (column >= slotPerWidth)
{
column = 0;
row++;
sx = groupPair.Left + gap;
sy += SlotMachine.SlotMachineHeightGap;
}
Canvas.SetLeft(newMachine, sx);
Canvas.SetTop(newMachine, sy);
this.AddSlotMachineToUI(slotPair, newMachine);
sx += SlotMachine.SlotMachineWidthGap;
column++;
}
y += machineGroup.Height + groupPair.SlotsHeight + 5;
}
_canvas.Height = y + SlotMachine.SlotMachineGap;
_floorView.Border_Bottom.Margin = new Thickness(-50, 0, 0, 0);
}
else
{
List<string> orderedData = (from o in _slotMachines
orderby o.Value.RowIndex
select o.Key).ToList();
if (orderedData.Count > 72)
{
_canvas.Height = (barPositions.Count / 12) * 110;
_floorView.Border_Bottom.Width = 780;
_floorView.Border_Bottom.Margin = new Thickness(-50, 0, 0, 0);
}
foreach (string slotKey in orderedData)
{
SlotMachinePair slotPair = _slotMachines[slotKey];
SlotMachine newMachine = slotPair.Machine;
FloorPositionDataDto floorPosition = null;
if (_floorView._floorViewUserLocations)
{
floorPosition = _floorView.GetFloorPosition(newMachine.SlotID);
if (floorPosition != null)
{
newMachine.PositionData = floorPosition;
}
}
UIElement dragging = _canvas.ElementBeingDragged;
bool isDragging = false;
if (dragging != null && dragging == newMachine)
{
isDragging = true;
}
if (!isDragging && _floorView._floorViewUserLocations)
{
if (floorPosition != null)
{
newMachine.Left = floorPosition.Left;
newMachine.Top = floorPosition.Top;
DragCanvas.SetZIndex(newMachine, floorPosition.RowNo);
}
}
if (newMachine != null && !isDragging)
{
if (newMachine.Left > 0 || newMachine.Top > 0)
{
if ((_floorView.chkSortPos.IsChecked.Value) ||
(_floorView.chkSortAsset.IsChecked.Value))
{
newMachine.Top = 0;
newMachine.Left = 0;
// Don't uncomment these lines, we should not reposition the slot machines during loading.
// Slot machines position should be saved only during dragging.
//if (newMachine.Status != SlotMachineStatus.EmptyPosition)
//{
// _floorView.SaveFloorPosition(newMachine, true, ref hasPositionSaved);
//}
_floorView.CalculatePositionAndPaint(ref widthmargin, ref heightmargin, ref curPos, newMachine);
}
else
{
Canvas.SetLeft(newMachine, Convert.ToDouble(newMachine.Left));
Canvas.SetTop(newMachine, Convert.ToDouble(newMachine.Top));
}
}
else
{
_floorView.CalculatePositionAndPaint(ref widthmargin, ref heightmargin, ref curPos, newMachine);
if (_floorView._floorViewUserLocations)
{
if (!(_floorView.chkSortPos.IsChecked.Value &&
_floorView.chkSortAsset.IsChecked.Value))
{
if (savedPositions == null) savedPositions = new FloorPositionDto();
savedPositions.Modify(userId, newMachine.SlotID, TypeSystem.GetValueInt(newMachine.Left), TypeSystem.GetValueInt(newMachine.Top), 0);
}
}
}
//// save the initial positions
//if (CFloorView._FirstDragPosition)
//{
// if (savedPositions == null) savedPositions = new FloorPositionDto();
// savedPositions.Modify(userId, newMachine.SlotID, TypeSystem.GetValueInt(newMachine.Left), TypeSystem.GetValueInt(newMachine.Top), 0);
//}
this.AddSlotMachineToUI(slotPair, newMachine);
}
}
}
}
catch (ThreadAbortException)
{
LogManager.WriteLog(PROC + " => Thread was instructed to close.", LogManager.enumLogLevel.Error);
}
catch (Exception ex)
{
ExceptionManager.Publish(ex);
}
finally
{
#if DEBUG
watch.Stop();
LogManager.WriteLog(PROC + string.Format(" => Total time taken [{0}] to load the slot machines into UI.", watch.Elapsed.ToString()), LogManager.enumLogLevel.Info);
#endif
if (hasPositionSaved)
{
CDOSettings.Current.Save();
}
// notify the initial positions to all the clients logged in with the current user id
if (savedPositions != null && savedPositions.Count > 0)
{
_floorView.NotifyFloorPosition(savedPositions);
}
//if (CFloorView._FirstDragPosition)
//{
// CFloorView._FirstDragPosition = false;
//}
}
}));
if (clearMachines)
{
LogManager.WriteLog(PROC + " => Unable to refresh. Clear machines called instead.", LogManager.enumLogLevel.Error);
}
}
catch (ThreadAbortException)
{
LogManager.WriteLog(PROC + " => Thread was instructed to close.", LogManager.enumLogLevel.Error);
}
catch (Exception ex)
{
LogManager.WriteLog(PROC + " => Exception occured in function.", LogManager.enumLogLevel.Error);
ExceptionManager.Publish(ex);
}
finally
{
#if DEBUG
LogManager.WriteLog(PROC + " => Finished.", LogManager.enumLogLevel.Error);
#endif
}
}
internal void SaveFloorPosition(SlotMachine slotMachinePosition, bool isDefault, ref bool isSaved)
{
if (!isDefault || chkRePosition.IsChecked.Value)
{
int userID = CDOSettings.Current.LoggedInUser.SecurityUserID;
int left = TypeSystem.GetValueInt(Canvas.GetLeft(slotMachinePosition));
int top = TypeSystem.GetValueInt(Canvas.GetTop(slotMachinePosition));
//if (CFloorView._FirstDragPosition)
//{
// _analysisBusinessObject.SaveUserBasedFloorPosition(SlotMachineCollectionFactory.ToXml(this), userID);
// CFloorView._FirstDragPosition = false;
//}
_analysisBusinessObject.SaveFloorPosition(slotMachinePosition.SlotID, userID,
top,
left);
int currentZIndex = Canvas.GetZIndex(slotMachinePosition);
if (_floorViewUserLocations)
{
FloorPositionDataDto positionData = slotMachinePosition.PositionData;
FloorPositionDto position = new FloorPositionDto()
{
{
new FloorPositionKeyDto(userID, slotMachinePosition.SlotID),
new FloorPositionDataDto(slotMachinePosition.SlotID, left, top, currentZIndex)
},
};
_clientSubcriber.NotifyFloorPosition(position);
}
}
}
protected override void SaveFloorPositionInternal(FloorPositionDto request)
{
ModuleProc PROC = new ModuleProc(this.DYN_MODULE_NAME, "SaveFloorPositionInternal");
try
{
if (request != null)
{
foreach (var pair in request)
{
DataHelper.SaveFloorPosition(pair.Key.BarPosition, pair.Key.UserID, pair.Value.Top, pair.Value.Left);
Thread.Sleep(10);
}
}
}
catch (Exception ex)
{
Log.Exception(PROC, ex);
}
}