public void PlaceIDChanged(PlaceID place)
{
try
{
var Warehouse = (OperationContext.Current.Host as WarehouseServiceHost).Warehouse;
Warehouse.WMS.SendPlaceInfo(place);
}
catch (Exception ex)
{
Warehouse?.AddEvent(Database.Event.EnumSeverity.Error, Database.Event.EnumType.Exception, String.Format("MFCService.PlaceIDChanged() failed. Reason:{0}", ex.Message));
}
}
public LocationViewModel()
{
_place = new PlaceID();
Validator = new PropertyValidator();
}
public async Task StrategyAsync()
{
try
{
Command cmd;
DateTime timeStamp;
// todo: timestamp: delete DB alarm, Log
timeStamp = DateTime.Now;
if (timeStamp.TimeOfDay > _maintenanceTime && _timeStampOld.TimeOfDay <= _maintenanceTime)
{
// send time sync
Warehouse.SegmentList.ForEach(s => s.SetClock(0));
// move old commands to history
DateTime dt = DateTime.Now.AddDays(-30);
await Warehouse.DBService.MoveCommamdsToHist(dt);
Warehouse.AddEvent(Event.EnumSeverity.Event, Event.EnumType.Program, $"Copy Commands and SimpleCommands older than {dt.Date} to history tables.");
// check database size
if (Warehouse.DBService.GetDBSizeInGB() > _dataBaseSizeGBMax)
{
DatabaseToLarge = true;
Warehouse.AddEvent(Event.EnumSeverity.Event, Event.EnumType.Program, "Database is approaching its maximum size. Create backup and delete old records in tables MOVEMENT, ALARM, EVENT, and COMMAND.");
}
else
{
DatabaseToLarge = false;
}
// delete logs
Warehouse.AddEvent(Event.EnumSeverity.Event, Event.EnumType.Program, "Deletion of old log files started.");
DeleteOldLogs(_logPath, _logToKeepMonths);
Warehouse.AddEvent(Event.EnumSeverity.Event, Event.EnumType.Program, "Deletion of old log files completed.");
}
_timeStampOld = timeStamp;
while ((cmd = Warehouse.DBService.FindFirstNotMoveCommand(Warehouse.SteeringCommands.RemoteMode)) != null)
{
cmd.Status = Command.EnumCommandStatus.Active;
Warehouse.DBService.UpdateCommand(cmd);
switch (cmd.Task)
{
case Command.EnumCommandTask.CreateMaterial:
case Command.EnumCommandTask.DeleteMaterial:
bool move = cmd.Task == Command.EnumCommandTask.CreateMaterial && cmd.Info == "move";
if (cmd.Task == Command.EnumCommandTask.DeleteMaterial || move)
{
int m;
if (!(cmd as CommandMaterial).Material.HasValue)
{
Place p = Warehouse.DBService.FindPlace((cmd as CommandMaterial).Source);
m = p != null ? p.Material : 0;
}
else
{
m = (cmd as CommandMaterial).Material.Value;
}
Warehouse.DeleteMaterial((uint)m, (cmd as CommandMaterial).Source, cmd.ID);
}
if (move)
{
Warehouse.CreateMaterial((uint)(cmd as CommandMaterial).Material.Value, (cmd as CommandMaterial).Target, cmd.ID, true, (cmd as CommandMaterial).Source == (cmd as CommandMaterial).Target);
}
else if (cmd.Task == Command.EnumCommandTask.CreateMaterial)
{
Warehouse.CreateMaterial((uint)(cmd as CommandMaterial).Material.Value, (cmd as CommandMaterial).Source, cmd.ID, cmd.Info == "modify", cmd.Info == "modify");
}
break;
case Command.EnumCommandTask.SegmentInfo:
case Command.EnumCommandTask.SegmentOn:
case Command.EnumCommandTask.SegmentOff:
case Command.EnumCommandTask.SegmentReset:
List <string> segmentList = new List <string>();
if (Warehouse.SegmentList.FirstOrDefault(s => s.Name == (cmd as CommandSegment).Segment) != null)
{
segmentList.Add((cmd as CommandSegment).Segment);
}
else
{
segmentList = Warehouse.SegmentList.Select(s => s.Name).ToList();
}
Warehouse.DBService.GenerateSegmentSimpleCommands(cmd, segmentList);
if (cmd.Task == Command.EnumCommandTask.SegmentInfo)
{
foreach (string s in segmentList)
{
Segment seg = Warehouse.SegmentList.FirstOrDefault(ss => ss.Name == s);
if (seg is SegmentMainPanel)
{
Warehouse.WMS?.SendSegmentInfo((seg as SegmentMainPanel).SegmentInfo, false);
}
else if (seg is SegmentCrane)
{
Warehouse.WMS?.SendSegmentInfo((seg as SegmentCrane).SegmentInfo, false);
}
}
}
break;
case Command.EnumCommandTask.SegmentHome:
var cl1 = (Warehouse.CraneList.FindAll(p => p.Segment == (cmd as CommandSegment).Segment || (cmd as CommandSegment).Segment == "*")).GroupBy(p => p.Segment).Select(q => q.First()).ToList();
if (cl1 != null)
{
cl1.ForEach(pp => Warehouse.DBService.AddSimpleCommand(new SimpleCraneCommand
{
Command_ID = cmd.ID,
Task = SimpleCommand.EnumTask.Move,
Unit = pp.Name,
Source = pp.HomePosition,
Status = SimpleCommand.EnumStatus.NotActive,
Time = DateTime.Now
}));
}
break;
case Command.EnumCommandTask.InfoMaterial:
Place place = Warehouse.DBService.FindPlace((cmd as CommandMaterial).Source);
if (place == null)
{
place = new Place {
Place1 = (cmd as CommandMaterial).Source, Material = 0
}
}
;
await Warehouse.WMS.SendLocationInfo(place, null);
cmd.Status = Command.EnumCommandStatus.Finished;
Warehouse.DBService.UpdateCommand(cmd);
Warehouse.OnCommandFinish?.Invoke(cmd);
break;
case Command.EnumCommandTask.InfoSlot:
PlaceID placeid = Warehouse.DBService.FindPlaceID((cmd as CommandMaterial).Source);
if (placeid != null)
{
Warehouse.WMS.SendPlaceInfo(placeid);
}
cmd.Status = Command.EnumCommandStatus.Finished;
Warehouse.DBService.UpdateCommand(cmd);
Warehouse.OnCommandFinish?.Invoke(cmd);
break;
case Command.EnumCommandTask.InfoCommand:
Command command = Warehouse.DBService.FindCommandByWMS_ID((cmd as CommandCommand).CommandID.Value);
if (command != null)
{
Warehouse.WMS.SendCommandInfo(command);
}
cmd.Status = Command.EnumCommandStatus.Finished;
Warehouse.DBService.UpdateCommand(cmd);
Warehouse.OnCommandFinish?.Invoke(cmd);
break;
case Command.EnumCommandTask.CancelCommand:
Command c = Warehouse.DBService.ExecuteCancelCommand(cmd as CommandCommand);
if (c != null)
{
Warehouse.OnCommandFinish?.Invoke(c);
}
if (cmd.Status == Command.EnumCommandStatus.Finished)
{
Warehouse.DBService.UpdateCommand(cmd);
Warehouse.OnCommandFinish?.Invoke(cmd);
}
break;
case Command.EnumCommandTask.Move:
break;
default:
break;
}
}
}
catch (Exception e)
{
Warehouse.AddEvent(Event.EnumSeverity.Error, Event.EnumType.Exception, e.Message);
throw new StrategyCraneException(String.Format("{0} Strategy failed.", Name));
}
}
public override string ToString()
{
return(PlaceID.ToString());
}
public static void addObjectToRoom(IInteractable p_obj, PlaceID p_room)
{
m_rooms[p_room].addObject(p_obj);
}
public static void setRoomNoTransition(PlaceID p_roomName)
{
setRoomNoTransition(p_roomName, Hero.instance.getX(), Hero.instance.getY(), Hero.instance.getDirection());
}
public static void setRoomNoTransition(PlaceID p_roomName, int p_newX, int p_newY, Direction p_newDirection)
{
Hero.instance.reset();
m_currentRoomID = p_roomName;
m_currentRoom.onExit();
m_currentRoom = m_rooms[p_roomName];
m_currentRoom.onEnter();
Hero.instance.setX(p_newX);
Hero.instance.setY(p_newY);
Hero.instance.setDirection(p_newDirection);
updateCameraOffset(Hero.instance);
LocationNamePanel.instance.showNewLocation(SunsetUtils.enumToString<PlaceID>(m_currentRoomID)); //trigger header showing new location name
}
public static void removeObjectFromRoom(IInteractable p_obj, PlaceID p_room)
{
m_rooms[p_room].removeObject(p_obj);
}
public static void loadMaps(ContentManager p_content)
{
m_rooms = new Dictionary<PlaceID, Room>();
// there's probably a way to do this using loops but listing everything out is safer
Room bathroom = new Bathroom();
Room cafeteria = new Cafeteria();
Room computerLab = new ComputerLab();
Room entrance = new MainEntrance();
Room hallwayEast = new HallwayEast();
Room hallwayWest = new HallwayWest();
Room library = new Library();
Room magazineOffice = new MagazineOffice();
Room math = new MathClassroom();
Room science = new ScienceClassroom();
Room studentLounge = new StudentLounge();
Room footballField = new FootballField();
//Room questHall = new Room();
//Room questHallEnd = new Room();
bathroom.loadContent(p_content, Directories.MAPS + "map_Bathroom");
cafeteria.loadContent(p_content, Directories.MAPS + "map_Cafeteria");
computerLab.loadContent(p_content, Directories.MAPS + "map_ComputerLab");
entrance.loadContent(p_content, Directories.MAPS + "map_Entrance");
hallwayEast.loadContent(p_content, Directories.MAPS + "map_HallwayEast");
hallwayWest.loadContent(p_content, Directories.MAPS + "map_HallwayWest");
library.loadContent(p_content, Directories.MAPS + "map_Library");
magazineOffice.loadContent(p_content, Directories.MAPS + "map_MagazineOffice");
math.loadContent(p_content, Directories.MAPS + "map_Math");
science.loadContent(p_content, Directories.MAPS + "map_Science");
studentLounge.loadContent(p_content, Directories.MAPS + "map_StudentLounge");
footballField.loadContent(p_content, Directories.MAPS + "footballfielddraft");
//questHall.loadContent(p_content, "map_longhallwaymission");
//questHallEnd.loadContent(p_content, "map_longhallwayend");
m_rooms.Add(PlaceID.Bathroom, bathroom);
m_rooms.Add(PlaceID.Cafeteria, cafeteria);
m_rooms.Add(PlaceID.ComputerLab, computerLab);
m_rooms.Add(PlaceID.Entrance, entrance);
m_rooms.Add(PlaceID.HallwayEast, hallwayEast);
m_rooms.Add(PlaceID.HallwayWest, hallwayWest);
m_rooms.Add(PlaceID.Library, library);
m_rooms.Add(PlaceID.MagazineOffice, magazineOffice);
m_rooms.Add(PlaceID.Math, math);
m_rooms.Add(PlaceID.Science, science);
m_rooms.Add(PlaceID.StudentLounge, studentLounge);
m_rooms.Add(PlaceID.FootballField, footballField);
//m_rooms.Add("map_longhallwaymission", questHall);
//m_rooms.Add("map_longhallwayend", questHallEnd);
m_currentRoom = m_rooms[PlaceID.StudentLounge];
m_currentRoomID = PlaceID.HallwayWest;
}
public static Room getRoom(PlaceID p_roomName)
{
if (p_roomName != PlaceID.Nowhere)
return m_rooms[p_roomName];
return null;
}
public static void moveCharacterToRoom(PersonID person, PlaceID place)
{
moveCharacterToRoom(person, place, mCharMap[person].getX(), mCharMap[person].getY());
}
public static void moveCharacterToRoom(PersonID person, PlaceID place, int x, int y)
{
Character c1 = mCharMap[person];
if (mRoomMap[person] != PlaceID.Nowhere)
WorldManager.removeObjectFromRoom(c1, mRoomMap[person]);
if (place != PlaceID.Nowhere)
WorldManager.addObjectToRoom(c1, place);
mRoomMap[person] = place;
c1.setX(x);
c1.setY(y);
c1.reset();
}
public PlaceViewModel()
{
_place = new PlaceID();
}
public void CreateMaterial(UInt32 material, string place, int?mfcs_id, bool ignoreMaterialExsists, bool ignorePlaceExsists)
{
try
{
SimpleCommand c = null;
DBService.FindMaterialID((int)material, true);
Place pm = DBService.FindMaterial((int)material);
Place pp = DBService.FindPlace(place);
PlaceID pid = DBService.FindPlaceID(place);
//if(pm != null && pm.Place1 == "W:out")
//{
// DBService.MaterialDelete(pm.Place1, (int)material);
// pm = null;
//}
if (!ignoreMaterialExsists && pm != null) // material exists
{
if (mfcs_id.HasValue)
{
Command cmd = DBService.FindCommandByID(mfcs_id.Value);
cmd.Reason = Command.EnumCommandReason.MFCS;
cmd.Status = Command.EnumCommandStatus.Canceled;
DBService.UpdateCommand(cmd);
OnCommandFinish?.Invoke(cmd);
}
}
else if (!ignorePlaceExsists && pp != null && pid.Size != 999) // place is full
{
if (mfcs_id.HasValue)
{
Command cmd = DBService.FindCommandByID(mfcs_id.Value);
cmd.Reason = Command.EnumCommandReason.LocationFull;
cmd.Status = Command.EnumCommandStatus.Canceled;
DBService.UpdateCommand(cmd);
OnCommandFinish?.Invoke(cmd);
}
}
else
{
LPosition loc = LPosition.FromString(place);
if (!loc.IsWarehouse())
{
ConveyorBasic cb = FindConveyorBasic(place);
if (cb is Conveyor)
{
DBService.AddSimpleCommand(c = new SimpleConveyorCommand
{
Command_ID = mfcs_id,
Material = (int)material,
Source = place,
Status = SimpleCommand.EnumStatus.NotActive,
Target = place,
Task = SimpleCommand.EnumTask.Create,
Time = DateTime.Now
});
}
else if (cb is Crane)
{
DBService.AddSimpleCommand(c = new SimpleCraneCommand
{
Command_ID = mfcs_id,
Material = (int)material,
Source = place,
Status = SimpleCommand.EnumStatus.NotActive,
Task = SimpleCommand.EnumTask.Create,
Time = DateTime.Now,
Unit = cb.Name
});
}
}
else
{
DBService.MaterialCreate(place, (int)material, true);
OnMaterialMove?.Invoke(new Place {
Place1 = place, Material = (int)material
}, EnumMovementTask.Create);
if (mfcs_id.HasValue)
{
Command cmd = DBService.FindCommandByID(mfcs_id.Value);
cmd.Status = Command.EnumCommandStatus.Finished;
DBService.UpdateCommand(cmd);
OnCommandFinish?.Invoke(cmd);
}
}
}
}
catch (Exception ex)
{
AddEvent(Event.EnumSeverity.Error, Event.EnumType.Exception, String.Format("BasicWarehouse.CreateMaterial material({0}),place({1}) failed. Reason :{2}", material, place, ex.Message));
}
}
private void ExecuteCommand(DeviceCommandEnum dc, Segment s)
{
try
{
switch (dc)
{
case DeviceCommandEnum.Refresh:
(_warehouse.WCFClient as WCFUIClient).NotifyUIClient.Info(s.Name);
break;
case DeviceCommandEnum.Reset:
(_warehouse.WCFClient as WCFUIClient).NotifyUIClient.Reset(s.Name);
break;
case DeviceCommandEnum.AutoOn:
(_warehouse.WCFClient as WCFUIClient).NotifyUIClient.AutoOn(s.Name);
break;
case DeviceCommandEnum.AutoOff:
(_warehouse.WCFClient as WCFUIClient).NotifyUIClient.AutoOff(s.Name);
break;
case DeviceCommandEnum.SetTime:
(_warehouse.WCFClient as WCFUIClient).NotifyUIClient.SetClock(s.Name);
break;
case DeviceCommandEnum.LongTermBlockOn:
(_warehouse.WCFClient as WCFUIClient).NotifyUIClient.LongTermBlockOn(s.Name);
var cl1 = _warehouse.ConveyorList.FindAll(p => p.Segment == (Model as Segment).Name);
foreach (var c in cl1)
{
PlaceID p = _warehouse.DBService.FindPlaceID(c.Name);
if (p != null)
{
p.Blocked = true;
_warehouse.DBService.UpdateLocation(p);
}
}
break;
case DeviceCommandEnum.LongTermBlockOff:
(_warehouse.WCFClient as WCFUIClient).NotifyUIClient.LongTermBlockOff(s.Name);
var cl2 = _warehouse.ConveyorList.FindAll(p => p.Segment == (Model as Segment).Name);
foreach (var c in cl2)
{
PlaceID p = _warehouse.DBService.FindPlaceID(c.Name);
if (p != null)
{
p.Blocked = false;
_warehouse.DBService.UpdateLocation(p);
}
}
break;
default:
break;
}
}
catch (Exception e)
{
_warehouse.AddEvent(Database.Event.EnumSeverity.Error, Database.Event.EnumType.Exception, e.Message);
throw new Exception(string.Format("{0}.{1}: {2}", this.GetType().Name, (new StackTrace()).GetFrame(0).GetMethod().Name, e.Message));
}
}
private void ExecuteCommand(DeviceCommandEnum dc)
{
try
{
switch (dc)
{
case DeviceCommandEnum.Refresh:
(_warehouse.WCFClient as WCFUIClient).NotifyUIClient.Info(_segment.Name);
break;
case DeviceCommandEnum.Reset:
(_warehouse.WCFClient as WCFUIClient).NotifyUIClient.Reset(_segment.Name);
break;
case DeviceCommandEnum.AutoOn:
(_warehouse.WCFClient as WCFUIClient).NotifyUIClient.AutoOn(_segment.Name);
break;
case DeviceCommandEnum.AutoOff:
(_warehouse.WCFClient as WCFUIClient).NotifyUIClient.AutoOff(_segment.Name);
break;
case DeviceCommandEnum.Home:
_warehouse.DBService.AddCommand(new CommandSegment
{
Task = Database.Command.EnumCommandTask.SegmentHome,
Segment = ((Crane)Deck[0].Model).Segment,
Status = Database.Command.EnumCommandStatus.NotActive,
Time = DateTime.Now
});
break;
case DeviceCommandEnum.SetTime:
(_warehouse.WCFClient as WCFUIClient).NotifyUIClient.SetClock(_segment.Name);
break;
case DeviceCommandEnum.LongTermBlockOn:
(_warehouse.WCFClient as WCFUIClient).NotifyUIClient.LongTermBlockOn(_segment.Name);
for (int i = 0; i < Deck.Count; i++)
{
PlaceID pid = _warehouse.DBService.FindPlaceID(((Crane)Deck[i].Model).Name);
pid.Blocked = true;
_warehouse.DBService.UpdateLocation(pid);
}
break;
case DeviceCommandEnum.LongTermBlockOff:
(_warehouse.WCFClient as WCFUIClient).NotifyUIClient.LongTermBlockOff(_segment.Name);
for (int i = 0; i < Deck.Count; i++)
{
PlaceID pid = _warehouse.DBService.FindPlaceID(((Crane)Deck[i].Model).Name);
pid.Blocked = false;
_warehouse.DBService.UpdateLocation(pid);
}
break;
default:
break;
}
}
catch (Exception e)
{
_warehouse.AddEvent(Database.Event.EnumSeverity.Error, Database.Event.EnumType.Exception,
string.Format("{0}.{1}: {2}", this.GetType().Name, (new StackTrace()).GetFrame(0).GetMethod().Name, e.Message));
}
}
