public void FromDaysToMilliseconds_ShouldConvert1DayTo86400000Ms()
{
const int time = 1;
var actual = TimeConverters.FromDaysToMilliseconds(time);
Assert.AreEqual(86400000, actual);
}
public void FromSecondsToMilliseconds_ShouldConvert1SecondTo1000Ms()
{
const int time = 1;
var actual = TimeConverters.FromSecondsToMilliseconds(time);
Assert.AreEqual(1000, actual);
}
public void AutoFill()
{
ServiceName = ServiceTemplate.ServiceTemplateName;
ServiceAbbreviation = ServiceTemplate.ServiceTemplateAbbreviation;
int StartTime = TimeConverters.TimeToMinutes(StartTimeText);
EndTimeText = TimeConverters.MinutesToString(StartTime + ServiceTemplate.CalculatedDuration);
NotifyOfPropertyChange(() => CanSaveService);
}
public void EditService()
{
ServiceName = SelectedService.ServiceName;
ServiceAbbreviation = SelectedService.ServiceAbbreviation;
ServiceTemplate = ServiceTemplateDataAccess.GetServiceTemplateById(SelectedService.ServiceTemplateId);
ServiceId = SelectedService.Id;
StartTimeText = TimeConverters.MinutesToString(SelectedService.StartTime);
EndTimeText = TimeConverters.MinutesToString(SelectedService.EndTime);
NotifyOfPropertyChange(() => CanEditService);
NotifyOfPropertyChange(() => CanSaveService);
NotifyOfPropertyChange(() => CanRepeat);
}
private void PendTransfer()
{
if (Mathf.CeilToInt(_currentTime) == 0)
{
_done = true;
QuickLogger.Debug($"Done: {_done}");
var listOfItems = _items.ToList();
for (int i = 0; i < _items.count; i++)
{
_itemsToRemove.Add(listOfItems[i].item);
}
foreach (Pickupable pickupable in _itemsToRemove)
{
if (_target.HasRoomFor(pickupable))
{
_mono.RemoveItem(pickupable);
_target.AddItem(new InventoryItem(pickupable));
}
}
ErrorMessage.AddMessage($"[{_target.Name} Message]: Shipment has arrived!");
_itemsToRemove.Clear();
_target.Recieved = true;
_currentTime = ResetTime;
_mono.OnItemSent?.Invoke();
_target.OnItemSent?.Invoke();
_target.IsReceivingTransfer = false;
_items = null;
_target = null;
}
else
{
_currentTime -= 1 * DayNightCycle.main.deltaTime;
}
if (_target != null)
{
_target.OnTimerChanged?.Invoke(TimeConverters.SecondsToHMS(_currentTime));
}
_mono.OnTimerChanged?.Invoke(TimeConverters.SecondsToHMS(_currentTime));
}
public PlottableScatter PlotService(ScottPlotGraph model, TimeGraphUIModel graph, string serviceAbbreviation)
{
int startTime = TimeConverters.TimeToMinutes(model.StartTimeText);
int endTime = TimeConverters.TimeToMinutes(model.EndTimeText);
double[] dataX = new double[graph.DataLine.Count];
double[] dataY = new double[graph.DataLine.Count];
int j = 0;
if (graph.DataLine[0].Y >= startTime && graph.DataLine[0].Y < endTime)
{
foreach (var dataSet in graph.DataLine)
{
dataX[j] = dataSet.X;
dataY[j] = -dataSet.Y;
scatterDataX[scatterIndex] = dataSet.X;
scatterDataY[scatterIndex] = -dataSet.Y;
highlightedTimeGraphUiModels[scatterIndex] = graph;
scatterIndex++;
j++;
}
double xOffset = 0;
double yOffset = 5;
TextAlignment alignment;
if (dataX[0] < dataX.GetLength(0) / 2)
{
alignment = TextAlignment.upperLeft;
}
else
{
alignment = TextAlignment.upperRight;
}
TimetableGraph.plt.PlotText(serviceAbbreviation,
dataX[0] + xOffset, dataY[0] + yOffset, fontName: "Arial", fontSize: 10,
color: GetResourceColor("GraphText"), bold: true, alignment: alignment);
return(TimetableGraph.plt.PlotScatterHighlight(dataX, dataY, GetLineColor(graph.ServiceType)));
}
else
{
return(null);
}
}
private void Desterilize()
{
if (_isDirty)
{
return;
}
if (QPatch.Configuration.Config.GetsDirtyOverTime)
{
_unitSanitation -= DayNightCycle.main.deltaTime;
if (_unitSanitation <= 0)
{
QuickLogger.Debug("Unit is dirty");
_isDirty = true;
_unitSanitation = ThirtyDays;
}
}
_mono.DisplayManager.UpdateTimeLeft(TimeConverters.SecondsToHMS(_unitSanitation));
}
public void SaveService()
{
ServiceModel newService = new ServiceModel();
newService.ServiceName = ServiceName;
newService.ServiceAbbreviation = ServiceAbbreviation;
newService.ServiceTemplateId = ServiceTemplate.Id;
newService.StartTime = TimeConverters.TimeToMinutes(StartTimeText);
newService.EndTime = TimeConverters.TimeToMinutes(EndTimeText);
if (ServiceId <= 0)
{
ServicesDataAccess.InsertService(newService);
}
else
{
newService.Id = ServiceId;
ServicesDataAccess.UpdateService(newService);
}
ServiceList = new BindableCollection <ServiceModel>(ServicesDataAccess.GetServicesPerRoute(RouteId).OrderBy(x => x.StartTime));
ClearService();
NotifyOfPropertyChange(() => ServiceList);
}
private void PrepareDataSet()
{
TimeGraphUI = new ObservableCollection <TimeGraphUIModel>();
ServiceClassList = ServiceClassDataAccess.GetAllServiceClasses();
var serviceList = new ObservableCollection <ServiceModel>(ServicesDataAccess.GetServicesPerTimetable(TimetableId));
foreach (var service in serviceList)
{
var item = new TimeGraphUIModel();
var serviceTemplateId = service.ServiceTemplateId;
var serviceTemplate = ServiceTemplateDataAccess.GetServiceTemplateById(serviceTemplateId);
item.TimeEventList = new BindableCollection <ExtendedFullTimeEventModel>(FullTimeEventDataAccess.GetAllExtendedFullTimeEventsPerServiceTemplate(serviceTemplateId));
item.ServiceName = service.ServiceName;
item.ServiceAbbreviation = service.ServiceAbbreviation;
item.ServiceType = serviceTemplate.ServiceType;
item.StartTimeText = service.StartTimeText;
item.EndTimeText = service.EndTimeText;
int actualTime = service.StartTime;
foreach (var fullTimeEvent in item.TimeEventList)
{
actualTime += fullTimeEvent.ArrivalTime;
fullTimeEvent.ArrivalTimeText = TimeConverters.MinutesToString(actualTime);
DataPoint point = GetFirstDataPoint(fullTimeEvent, actualTime);
item.DataLine.Add(point);
if (fullTimeEvent.WaitTime > 0)
{
actualTime += fullTimeEvent.WaitTime;
DataPoint point2 = GetSecondDataPoint(actualTime, point.X);
item.DataLine.Add(point2);
}
fullTimeEvent.DepartureTimeText = TimeConverters.MinutesToString(actualTime);
}
TimeGraphUI.Add(item);
}
OnPropertyChanged("TimeGraphUI");
}
private string TimeTilRefuel()
{
var mod = _timeLeft % KDayInSeconds;
return(TimeConverters.SecondsToHMS(mod));
}
public static TimetableMatrixModel ReadTimetableMatrix(int timetableId, bool csvTarget)
{
// TODO wrap this all in a transaction, for better performance
TimetableMatrixModel matrixModel = new TimetableMatrixModel();
// Get TimetableMode to retrieve name
var timetable = TimetableDataAccess.GetTimetableById(timetableId);
matrixModel.TimetableName = timetable.TimetableName;
matrixModel.TimetableId = timetable.Id;
matrixModel.RouteId = timetable.RouteId;
var direction = ServiceDirectionDataAccess.GetServiceDirectionById(timetable.ServiceDirectionId);
matrixModel.IsDescending = direction.IsDescending;
// Now get a view, representing Services
List <ServiceModel> serviceList = ServicesDataAccess.GetServicesPerTimetable(timetable.Id);
serviceList = serviceList.OrderBy(x => x.StartTime).ToList();
var locationsList = LocationDataAccess.GetAllLocationsPerRoute(matrixModel.RouteId);
if (matrixModel.IsDescending)
{
locationsList = locationsList.OrderByDescending(x => x.Order).ToList();
}
else
{
locationsList = locationsList.OrderBy(x => x.Order).ToList();
}
var locationsCount = locationsList.Count;
matrixModel.Matrix = new string[locationsList.Count + 1][];
var columncount = serviceList.Count + 1;
string[] columnheaders = new string[columncount];
columnheaders[0] = "---";
for (int i = 0; i < columncount - 1; i++)
{
columnheaders[i + 1] = serviceList[i].ServiceAbbreviation;
}
matrixModel.Matrix[0] = columnheaders;
for (int i = 0; i < locationsCount; i++)
{
string[] row = new string[columncount];
row[0] = locationsList[i].LocationName;
matrixModel.Matrix[i + 1] = row;
}
for (int index = 0; index < serviceList.Count; index++)
{
int actualTime = serviceList[index].StartTime;
List <ServiceTimingModel> Timing;
if (matrixModel.IsDescending)
{
Timing = GetServiceTiming(serviceList[index].Id, locationsList).OrderByDescending(x => x.LocationsOrder).ToList();
}
else
{
Timing = GetServiceTiming(serviceList[index].Id, locationsList);
}
int j = 0;
for (int i = 0; i < locationsCount;)
{
if (j < Timing.Count && locationsList[i].Order == Timing[j].LocationsOrder)
{
i++;
j++;
}
else
{
var Insert = new ServiceTimingModel();
Insert.LocationId = locationsList[i].Id;
Insert.LocationName = locationsList[i].LocationName;
Insert.LocationAbbrev = locationsList[i].LocationAbbreviation;
Insert.EventType = "";
Insert.ArrivalTime = 0;
Insert.WaitTime = 0;
Insert.TimeString = "--";
Insert.LocationsOrder = locationsList[i].Order;
Insert.TimeEventId = -1; // TimeEvent is not valid!
Timing.Insert(j, Insert);
i++;
j++;
}
}
matrixModel.TimingList.Add(Timing);
}
for (int i = 0; i < columncount - 1; i++) // for each service
{
int actualTime = serviceList[i].StartTime;
var timing = matrixModel.TimingList[i];
for (int j = 0; j < locationsCount; j++) // for each location
{
if (timing[j].TimeEventId > 0)
{
actualTime += timing[j].ArrivalTime;
timing[j].TimeString = TimeConverters.TimeEventToString(actualTime, timing[j].WaitTime, csvTarget);
actualTime += timing[j].WaitTime;
}
matrixModel.Matrix[j + 1][i + 1] = timing[j].TimeString;
}
}
return(matrixModel);
}
