public void ChangeSelectedMap(object dataContext)
{
var map = ((MeterViewModel)dataContext).Map;
if (map != null)
{
SelectedMap = m_Maps.Single(m => m.Model == map);
}
}
private void AlterCatalogCollection(object sender, NotifyCollectionChangedEventArgs e)
{
switch (e.Action)
{
case NotifyCollectionChangedAction.Add:
foreach (var newItem in e.NewItems.OfType <Catalog>())
{
CreateCatalogViewModel(newItem);
}
break;
case NotifyCollectionChangedAction.Remove:
foreach (var catalogViewModel in e.OldItems.OfType <Catalog>()
.Select(oldItem => m_Catalogs.Single(r => r.Model == oldItem)))
{
m_Catalogs.Remove(catalogViewModel);
foreach (var mvm in m_Measures.Where(mvm => catalogViewModel.Measures.Contains(mvm.Model))
.ToArray())
{
m_Measures.Remove(mvm);
}
}
break;
}
NotifyOfPropertyChange(() => Catalogs);
}
private void AlterBuildingsCollection(object sender, NotifyCollectionChangedEventArgs e)
{
switch (e.Action)
{
case NotifyCollectionChangedAction.Add:
foreach (var newItem in e.NewItems.OfType <DomainModelService.Building>())
{
CreateBuildingViewModel(newItem);
}
break;
case NotifyCollectionChangedAction.Remove:
foreach (var buildingViewModel in e.OldItems.OfType <DomainModelService.Building>()
.Select(oldItem => m_Buildings.Single(r => r.Model == oldItem)))
{
m_Buildings.Remove(buildingViewModel);
foreach (var rvm in m_Rooms.Where(rvm => buildingViewModel.Rooms.Contains(rvm.Model))
.ToArray())
{
m_Rooms.Remove(rvm);
}
}
break;
}
NotifyOfPropertyChange(() => Buildings);
}
private void OnCardRemoved(object sender, ZoneChangedEventArgs e)
{
var viewModel = _cards.Single(x => x.Card == e.Card);
_cards.Remove(viewModel);
viewModel.Close();
ViewModels.SelectableCard.Destroy(viewModel);
}
public void MoveMeter(MapMouseEventArgs e)
{
if (PositionSettingActivated)
{
var selectedMeter = (MeterEditViewModel)m_EditItem;
selectedMeter.X = e.Coordinates.X;
selectedMeter.Y = e.Coordinates.Y;
if (SelectedMap != null &&
selectedMeter.Map != SelectedMap.Model)
{
selectedMeter.Map = SelectedMap.Model;
SelectedMeter = m_Meters.Single(m => m.Model == selectedMeter.Model);
}
else
{
NotifyOfPropertyChange(() => MeterPositionsOnSelectedMap);
}
}
}
protected override async Task OnInitialize()
{
MarketTypes = await _orderManagerService.GetMarketTypesAsync().ConfigureAwait(false);
SelectedOrder = Orders.FirstOrDefault();
FocusedOrder = Orders.FirstOrDefault();
Regions = new BindableCollection <MapRegion>(await _orderManagerService.GetRegions().ConfigureAwait(false));
SelectedRegion = Regions.Single(f => f.RegionId == Properties.Settings.Default.DefaultRegionId);
SelectedStation = SelectedRegion.StaStations.Single(f => f.StationId == Properties.Settings.Default.DefaultStationId);
}
private async void InitAsync()
{
Regions = new BindableCollection <MapRegion>(await _settingsService.GetRegions().ConfigureAwait(false));
DefaultRegion = Regions.Single(r => r.RegionId == Properties.Settings.Default.DefaultRegionId);
Stations = new BindableCollection <StaStation>(DefaultRegion.StaStations);
DefaultStation = Stations.SingleOrDefault(s => s.StationId == Properties.Settings.Default.DefaultStationId);
MarketHistorySources = new BindableCollection <string> {
"Crest", "EveMarketData"
};
MarketHistorySource = Properties.Settings.Default.MarketHistorySource;
}
private void AlterPlantCollection(object sender, NotifyCollectionChangedEventArgs e)
{
if (e.Action == NotifyCollectionChangedAction.Add)
{
foreach (var newItem in e.NewItems.OfType <Plant>())
{
m_PlantManagementViewModelFactory.CreatePlantViewModel(newItem);
}
NotifyOfPropertyChange(() => FilteredPlantViewModels);
}
else if (e.Action == NotifyCollectionChangedAction.Remove)
{
foreach (var oldItem in e.OldItems.OfType <Plant>())
{
var plantViewModel = m_PlantViewModels.Single(r => r.Model == oldItem);
m_PlantViewModels.Remove(plantViewModel);
}
NotifyOfPropertyChange(() => FilteredPlantViewModels);
}
}
private void AlterCompanyCollection(object sender, NotifyCollectionChangedEventArgs e)
{
if (e.Action == NotifyCollectionChangedAction.Add)
{
foreach (var newItem in e.NewItems.OfType <Company>())
{
CreateCompanyViewModel(newItem);
}
}
else if (e.Action == NotifyCollectionChangedAction.Remove)
{
foreach (var oldItem in e.OldItems.OfType <Company>())
{
m_CompanyViewModels.Remove(m_CompanyViewModels.Single(m => m.Model == oldItem));
}
}
}
private void AlterCustomerCollection(object sender, NotifyCollectionChangedEventArgs e)
{
if (e.Action == NotifyCollectionChangedAction.Add)
{
foreach (var newItem in e.NewItems.OfType <Customer>())
{
CreateCustomerViewModel(newItem);
}
NotifyOfPropertyChange(() => FilteredCustomers);
}
else if (e.Action == NotifyCollectionChangedAction.Remove)
{
foreach (var oldItem in e.OldItems.OfType <Customer>())
{
m_CustomerViewModels.Remove(m_CustomerViewModels.Single(r => r.Model == oldItem));
}
NotifyOfPropertyChange(() => FilteredCustomers);
}
}
private void AlterConsumerCollection(object sender, NotifyCollectionChangedEventArgs eventArgs)
{
switch (eventArgs.Action)
{
case NotifyCollectionChangedAction.Add:
foreach (var consumer in eventArgs.NewItems.OfType <Consumer>())
{
m_Consumers.Add(CreateConsumerViewModel(consumer));
}
break;
case NotifyCollectionChangedAction.Remove:
foreach (var oldConsumer in
eventArgs.OldItems.OfType <Consumer>()
.Select(oldConsumer => m_Consumers.Single(c => c.Model == oldConsumer)))
{
m_Consumers.Remove(oldConsumer);
}
break;
}
}
private void AlterInspectionCollection(object sender, NotifyCollectionChangedEventArgs e)
{
if (e.Action == NotifyCollectionChangedAction.Add)
{
foreach (var newItem in e.NewItems.OfType <Inspection>())
{
CreateInspectionViewModel(newItem);
}
NotifyOfPropertyChange(() => FilteredInspections);
}
else if (e.Action == NotifyCollectionChangedAction.Remove)
{
foreach (var oldItem in e.OldItems.OfType <Inspection>())
{
var inspectionViewModel = m_InspectionViewModels.Single(r => r.Model == oldItem);
m_InspectionViewModels.Remove(inspectionViewModel);
}
NotifyOfPropertyChange(() => FilteredInspections);
}
}
private void AlterConsumerGroupCollection(object sender, NotifyCollectionChangedEventArgs e)
{
switch (e.Action)
{
case NotifyCollectionChangedAction.Add:
foreach (var newItem in e.NewItems.OfType <ConsumerGroup>())
{
m_ConsumerGroups.Add(CreateConsumerGroupViewModel(newItem));
}
break;
case NotifyCollectionChangedAction.Remove:
foreach (var consumerGroupViewModel in e.OldItems.OfType <ConsumerGroup>()
.Select(oldItem => m_ConsumerGroups.Single(r => r.Model == oldItem)))
{
m_ConsumerGroups.Remove(consumerGroupViewModel);
}
break;
}
NotifyOfPropertyChange(() => ConsumerGroups);
}
private void AlterInspectionCollection(object sender, NotifyCollectionChangedEventArgs e)
{
if (e.Action == NotifyCollectionChangedAction.Add)
{
foreach (var newItem in e.NewItems.OfType <Approval_Inspection>())
{
m_InspectionViewModels.Add(CreateInspectionViewModel(newItem));
}
}
else
{
foreach (var oldItem in e.OldItems.OfType <Approval_Inspection>())
{
var inspectionViewModel = m_InspectionViewModels.Single(i => i.Inspection == oldItem);
m_InspectionViewModels.Remove(inspectionViewModel);
}
}
NotifyOfPropertyChange(() => FilterInspectionViewModels);
NotifyOfPropertyChange(() => CalendarEntries);
}
private void AlterDistributorCollection(object sender, NotifyCollectionChangedEventArgs eventArgs)
{
switch (eventArgs.Action)
{
case NotifyCollectionChangedAction.Add:
foreach (var distributor in eventArgs.NewItems.OfType <Distributor>())
{
m_Distributors.Add(CreateDistributorViewModel(distributor));
}
break;
case NotifyCollectionChangedAction.Remove:
foreach (var oldDistributor in
eventArgs.OldItems.OfType <Distributor>()
.Select(oldDistributor => m_Distributors.Single(c => c.Model == oldDistributor)))
{
m_Distributors.Remove(oldDistributor);
}
break;
}
}
private void LoadConditionInspectionViewModels()
{
if (m_Repository.ConditionInspections != null)
{
var conditionInspections = new ObservableCollection <ConditionInspection>();
foreach (var conditionInspection in from conditionInspection in m_Repository.ConditionInspections from mInspectionViewModel in m_InspectionViewModels.Where(mInspectionViewModel => conditionInspection.InspectionId == mInspectionViewModel.Inspection.Id) select conditionInspection)
{
conditionInspections.Add(conditionInspection);
}
foreach (var conditionInspection in conditionInspections)
{
var inspection = m_InspectionViewModels.Single(ivm => ivm.Inspection.Id == conditionInspection.InspectionId);
var auxillaryCondition = m_AuxillaryConditionViewModels.Single(acvm => acvm.Model.Id == conditionInspection.AuxillaryConditionId);
m_ConditionInspectionViewModels.Add(m_PlantManagementViewModelFactory.CreateConditionInspectionViewModel(conditionInspection, inspection, auxillaryCondition));
}
}
}
private void AlterConsumerGroupCollection(object sender, NotifyCollectionChangedEventArgs eventArgs)
{
switch (eventArgs.Action)
{
case NotifyCollectionChangedAction.Add:
foreach (var newConsumerGroup in eventArgs.NewItems.OfType <ConsumerGroup>())
{
m_ConsumerGroups.Add(CreateConsumerGroupViewModel(newConsumerGroup));
}
break;
case NotifyCollectionChangedAction.Remove:
foreach (var oldConsumerGroup in
eventArgs.OldItems.OfType <ConsumerGroup>()
.Select(oldConsumerGroup => m_ConsumerGroups.Single(cg => cg.Model == oldConsumerGroup)))
{
m_ConsumerGroups.Remove(oldConsumerGroup);
}
break;
}
}
private void AlterInvestmentPlanCollection(object sender, NotifyCollectionChangedEventArgs e)
{
switch (e.Action)
{
case NotifyCollectionChangedAction.Add:
foreach (var newItem in e.NewItems.OfType <InvestmentPlan>())
{
CreateInvestmentPlanViewModel(newItem);
}
break;
case NotifyCollectionChangedAction.Remove:
foreach (var investmentPlanViewModel in e.OldItems.OfType <InvestmentPlan>()
.Select(oldItem => m_InvestmentPlanViewModels.Single(r => r.Model == oldItem)))
{
m_InvestmentPlanViewModels.Remove(investmentPlanViewModel);
}
break;
}
NotifyOfPropertyChange(() => FilteredInvestmentPlans);
}
private void AlterMeterReadingCollection(object sender, NotifyCollectionChangedEventArgs e)
{
if (e.Action == NotifyCollectionChangedAction.Add)
{
foreach (var newItem in e.NewItems.OfType <MeterReading>())
{
m_MeterReadings.Add(CreateReadingViewModel(newItem));
}
}
else
{
foreach (var oldItem in e.OldItems.OfType <MeterReading>())
{
var readingViewModel = m_MeterReadings.Single(r => r.Model == oldItem);
m_MeterReadings.Remove(readingViewModel);
}
}
NotifyOfPropertyChange(() => FilteredReadings);
NotifyOfPropertyChange(() => CalendarEntries);
}
/* Handlers -----------------------------------------------------------------------------------------------*/
public void Handle(refreshRoomsEvent message)
{
if (!message.joined)
{
foreach (SelectableRoom sR in _availableRooms)
{
sR.resetColor();
sR.menuVisibility = "Collapsed";
}
int selectedRoomIndex = _availableRooms.IndexOf(_availableRooms.Single(i => i.id == message.selectedRoomId));
_availableRooms[selectedRoomIndex].changeColor("Black");
_availableRooms[selectedRoomIndex].menuVisibility = "Visible";
_availableRooms.Refresh();
_selectedAvailableRoom = message.selectedRoomId;
NotifyOfPropertyChange(null);
}
else
{
foreach (SelectableRoom sR in _joinedRooms)
{
sR.resetColor();
sR.menuVisibility = "Collapsed";
}
int selectedRoomIndex = 0;
try
{
selectedRoomIndex = _joinedRooms.IndexOf(_joinedRooms.Single(i => i.id == message.selectedRoomId));
} catch {
selectedRoomIndex = _joinedRooms.IndexOf(_joinedRooms.Where(x => x.id == message.selectedRoomId).ToList()[0]);
}
_joinedRooms[selectedRoomIndex].changeColor("Black");
_joinedRooms[selectedRoomIndex].menuVisibility = "Visible";
_selectedJoinedRoom = message.selectedRoomId;
_joinedRooms.Refresh();
NotifyOfPropertyChange(null);
}
}
private void AlterProductionItemCollection(object sender, NotifyCollectionChangedEventArgs e)
{
if (e.Action == NotifyCollectionChangedAction.Add)
{
foreach (var newItem in e.NewItems.OfType <ProductionItem>())
{
CreateProductionItemViewModel(newItem);
}
NotifyOfPropertyChange(() => FilteredProductionItems);
}
else if (e.Action == NotifyCollectionChangedAction.Remove)
{
foreach (var oldItem in e.OldItems.OfType <ProductionItem>())
{
var productionItemViewModel = m_ProductionItemViewModels.Single(r => r.Model == oldItem);
m_ProductionItemViewModels.Remove(productionItemViewModel);
}
NotifyOfPropertyChange(() => FilteredProductionItems);
NotifyOfPropertyChange(() => FilteredCustomers);
}
}
private async Task InitializeAsync()
{
IEnumerable <ApiKeyEntity> entities = await _shellService.GetAllActiveEntities();
Entities = new BindableCollection <ApiKeyEntity>(entities);
int activeEntityId = Settings.Default.ActiveEntity;
if (activeEntityId != 0)
{
ApiKeyEntity entity = Entities.Single(e => e.Id == activeEntityId);
if (entity != null)
{
ApplicationHelper.ActiveEntity = entity;
}
}
StatusMessage = "Initializing data...";
await IoC.Get <EveStaticDataRepository>().Initialize;
StatusMessage = "Initializing modules...";
await _moduleService.InitialiseAsync();
StatusMessage = "Ready";
}
private void initializePivotRunTimeCalculatorViewModel()
{
Hours = new BindableCollection<TimeViewModel>().CreateHours();
Minutes = new BindableCollection<TimeViewModel>().CreateMinutes();
Seconds = new BindableCollection<TimeViewModel>().CreateSeconds();
Kilometers = new BindableCollection<DistanceViewModel>().CreateKilometers();
Meters = new BindableCollection<DistanceViewModel>().CreateMeters();
Centimeters = new BindableCollection<DistanceViewModel>().CreateCentimeters();
SelectedKilometer = Kilometers.Single(s => s.Title == 0);
SelectedMeter = Meters.Single(s => s.Title == 0);
SelectedCentimeter = Centimeters.Single(s => s.Title == 0);
SelectedHour = Hours.Single(s => s.Title == 0);
SelectedMinute = Minutes.Single(s => s.Title == 0);
SelectedSecond = Seconds.Single(s => s.Title == 0);
}
public string getAvatarSource(string avatarType)
{
return(_avatars.Single(i => i.name == avatarType).source);
}
public string getAvatarSource(string avatarName)
{
try { return(_avatars.Single(i => i.name == avatarName).source); }
catch { return("/Resources/apple.png"); }
}
private void LoadDayScheduleInternal()
{
DaySchedule = new BindableCollection<ScheduleViewModel>();
for (var i = 0; i < 24; i++)
{
if (i < 10)
{
var hourFormat = string.Format("0{0}", i);
this.DaySchedule.Add(new ScheduleViewModel { Hour = hourFormat });
}
else
this.DaySchedule.Add(new ScheduleViewModel { Hour = i.ToString(CultureInfo.InvariantCulture) });
}
foreach (var appointment in appointmentService.GetAllByStartDate(this.StartTimeViewModel.DateTime))
DaySchedule.Single(c => Convert.ToInt32(c.Hour) == appointment.StartDate.Hour).Appointment = appointment;
Dispatcher.CurrentDispatcher.Invoke(new Action(() => IsDayScheduleLoading = false));
}
