using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Data.Entity;
using Tango.BL;
using Tango.MachineStudio.Common;
using Tango.MachineStudio.MachineManager.Models;
using Tango.BL.Entities;
using Tango.Core.Commands;
using Tango.MachineStudio.Common.Notifications;
using Z.EntityFramework.Plus;
using System.ComponentModel;
using Tango.BL.Enumerations;
namespace Tango.MachineStudio.MachineManager.ViewModels
{
public class MainViewVM : StudioViewModel
{
private INotificationProvider _notification;
private bool _preventChange;
private List<MachineModel> _machines;
public List<MachineModel> Machines
{
get { return _machines; }
set { _machines = value; RaisePropertyChangedAuto(); }
}
private String _filter;
public String Filter
{
get { return _filter; }
set
{
if (_filter != value)
{
_filter = value;
OnFilterChanged();
}
}
}
private List<HardwareVersion> _hardwareVersions;
public List<HardwareVersion> HardwareVersions
{
get { return _hardwareVersions; }
set { _hardwareVersions = value; RaisePropertyChangedAuto(); }
}
private HardwareVersion _selectedHardwareVersion;
public HardwareVersion SelectedHardwareVersion
{
get { return _selectedHardwareVersion; }
set { _selectedHardwareVersion = value; RaisePropertyChangedAuto(); InvalidateRelayCommands(); }
}
private bool? _enableSoftwareUpdate;
public bool? EnableSoftwareUpdate
{
get { return _enableSoftwareUpdate; }
set { _enableSoftwareUpdate = value; RaisePropertyChangedAuto(); InvalidateRelayCommands(); }
}
private bool? _enableFirmwareUpgrade;
public bool? EnableFirmwareUpgrade
{
get { return _enableFirmwareUpgrade; }
set { _enableFirmwareUpgrade = value; RaisePropertyChangedAuto(); InvalidateRelayCommands(); }
}
private bool? _selectAll;
public bool? SelectAll
{
get { return _selectAll; }
set { _selectAll = value; RaisePropertyChangedAuto(); OnSelectAllChanged(); InvalidateRelayCommands(); }
}
public RelayCommand ApplyCommand { get; set; }
public MainViewVM(INotificationProvider notificationProvider)
{
Machines = new List<MachineModel>();
_notification = notificationProvider;
ApplyCommand = new RelayCommand(Apply, CanApply);
}
public override void OnApplicationReady()
{
}
private async void OnFilterChanged()
{
await LoadMachines();
}
private void OnSelectAllChanged()
{
if (Machines != null && SelectAll != null)
{
_preventChange = true;
Machines.ForEach(x => x.IsSelected = SelectAll.Value);
_preventChange = false;
}
}
private async Task LoadMachines()
{
try
{
using (_notification.PushTaskItem("Loading machines..."))
{
SelectAll = null;
foreach (var machine in Machines.ToList())
{
machine.PropertyChanged -= Machine_PropertyChanged;
}
using (ObservablesContext db = ObservablesContext.CreateDefault())
{
var sites = await db.Sites.ToListAsync();
var machines = await db.Machines
.Include(x => x.Organization.Name)
.Include(x => x.Configuration.HardwareVersion.Name)
.Include(x => x.Configuration.HardwareVersion.Version)
.Include(x => x.Configuration.HardwareVersion.Guid)
.Select(x => new
{
x.Guid,
x.SerialNumber,
x.Name,
x.SuspendVersionUpdate,
x.SetupFirmware,
x.SetupFpga,
x.ConfigurationGuid,
HardwareVersionGuid = x.Configuration.HardwareVersion.Guid,
HardwareVersionName = x.Configuration.HardwareVersion.Name,
HardwareVersionVersion = x.Configuration.HardwareVersion.Version,
OrganizationName = x.Organization.Name,
x.SiteGuid,
x.VersionTag
}).ToListAsync();
var models = new List<MachineModel>();
foreach (var machine in machines)
{
MachineModel model = new MachineModel();
model.Guid = machine.Guid;
model.SerialNumber = machine.SerialNumber;
model.Name = machine.Name;
model.EnableFirmwareUpgrade = machine.SetupFirmware;
model.EnableSoftwareUpdate = !machine.SuspendVersionUpdate;
model.ConfigurationGuid = machine.ConfigurationGuid;
model.HardwareVersionGuid = machine.HardwareVersionGuid;
model.HardwareVersionName = machine.HardwareVersionName;
model.HardwareVersionVersion = machine.HardwareVersionVersion;
model.OrganizationName = machine.OrganizationName;
model.VersionTag = machine.VersionTag;
model.Site = sites.FirstOrDefault(x => x.Guid == machine.SiteGuid)?.Name;
models.Add(model);
}
if (Filter.IsNotNullOrEmpty())
{
var filter = Filter.ToLower();
models = models.Where(x =>
x.SerialNumber.ToLower().StartsWith(filter) ||
x.Name.ToLower().StartsWith(filter) ||
x.OrganizationName.ToLower().StartsWith(filter) ||
x.Site.ToStringOrEmpty().ToLower().StartsWith(filter) ||
x.VersionTag.ToStringOrEmpty().ToLower().StartsWith(filter)
).ToList();
}
foreach (var model in models)
{
var lastUpdate = await db.TangoUpdates.Where(
x => x.MachineGuid == model.Guid &&
(x.Status == (int)TangoUpdateStatuses.SetupCompleted ||
x.Status == (int)TangoUpdateStatuses.UpdateCompleted ||
x.Status == (int)TangoUpdateStatuses.OfflineUpdateCompleted ||
x.Status == (int)TangoUpdateStatuses.OfflineFirmwareUpgradeCompleted))
.OrderByDescending(x => x.LastUpdated)
.Select(x => new
{
x.ApplicationVersion,
x.FirmwareVersion
})
.FirstOrDefaultAsync();
if (lastUpdate != null)
{
model.ApplicationVersion = lastUpdate.ApplicationVersion;
model.FirmwareVersion = lastUpdate.FirmwareVersion;
}
}
HardwareVersions = (await db.HardwareVersions.ToListAsync()).OrderByDescending(x => x.Version).ToList();
SelectedHardwareVersion = null;
EnableSoftwareUpdate = null;
EnableFirmwareUpgrade = null;
Machines = models;
foreach (var machine in Machines.ToList())
{
machine.PropertyChanged += Machine_PropertyChanged;
}
}
}
}
catch (Exception ex)
{
LogManager.Log(ex, "Error loading machines.");
_notification.ShowError($"Error loading machines.\n{ex.FlattenMessage()}");
}
}
private void Machine_PropertyChanged(object sender, PropertyChangedEventArgs e)
{
if (_preventChange) return;
if (e.PropertyName == nameof(MachineModel.IsSelected))
{
if (Machines.TrueForAll(x => x.IsSelected))
{
_selectAll = true;
}
else if (Machines.TrueForAll(x => !x.IsSelected))
{
_selectAll = false;
}
else
{
_selectAll = null;
}
RaisePropertyChanged(nameof(SelectAll));
var selectedMachines = Machines.Where(x => x.IsSelected).ToList();
if (selectedMachines.Count > 0)
{
if (selectedMachines.TrueForAll(x => x.EnableSoftwareUpdate))
{
EnableSoftwareUpdate = true;
}
else if (selectedMachines.TrueForAll(x => !x.EnableSoftwareUpdate))
{
EnableSoftwareUpdate = false;
}
else
{
EnableSoftwareUpdate = null;
}
if (selectedMachines.TrueForAll(x => x.EnableFirmwareUpgrade))
{
EnableFirmwareUpgrade = true;
}
else if (selectedMachines.TrueForAll(x => !x.EnableFirmwareUpgrade))
{
EnableFirmwareUpgrade = false;
}
else
{
EnableFirmwareUpgrade = null;
}
if (selectedMachines.TrueForAll(x => x.HardwareVersionGuid == selectedMachines.First().HardwareVersionGuid))
{
SelectedHardwareVersion = HardwareVersions.FirstOrDefault(x => x.Guid == selectedMachines.First().HardwareVersionGuid);
}
else
{
SelectedHardwareVersion = null;
}
}
InvalidateRelayCommands();
}
}
private bool CanApply()
{
var selectedMachines = Machines.Where(x => x.IsSelected).ToList();
if (selectedMachines.Count == 0) return false;
if (EnableSoftwareUpdate != null && selectedMachines.Any(x => x.EnableSoftwareUpdate != EnableSoftwareUpdate)) return true;
if (EnableFirmwareUpgrade != null && selectedMachines.Any(x => x.EnableFirmwareUpgrade != EnableFirmwareUpgrade)) return true;
if (SelectedHardwareVersion != null && selectedMachines.Any(x => x.HardwareVersionGuid != SelectedHardwareVersion.Guid)) return true;
return false;
}
private async void Apply()
{
if (!_notification.ShowQuestion($"You are about to modify {Machines.Count(x => x.IsSelected)} machines. Are you sure?")) return;
try
{
IsFree = false;
using (_notification.PushTaskItem("Applying changes..."))
{
if (Machines == null || Machines.Count(x => x.IsSelected) == 0)
{
_notification.ShowInfo("No machines selected");
return;
}
using (ObservablesContext db = ObservablesContext.CreateDefault())
{
var machines = Machines.Where(x => x.IsSelected).ToList();
var guids = machines.Select(x => x.Guid).ToArray();
if (EnableSoftwareUpdate != null)
{
await db.Machines.Where(x => guids.Contains(x.Guid)).UpdateAsync(x =>
new Machine()
{
SuspendVersionUpdate = !EnableSoftwareUpdate.Value
});
}
if (EnableFirmwareUpgrade != null)
{
await db.Machines.Where(x => guids.Contains(x.Guid)).UpdateAsync(x =>
new Machine()
{
SetupFirmware = EnableFirmwareUpgrade.Value,
SetupFpga = EnableFirmwareUpgrade.Value,
});
}
if (SelectedHardwareVersion != null)
{
guids = machines.Select(x => x.ConfigurationGuid).ToArray();
await db.Configurations.Where(x => guids.Contains(x.Guid)).UpdateAsync(x =>
new Configuration()
{
HardwareVersionGuid = SelectedHardwareVersion.Guid
});
}
}
await LoadMachines();
}
}
catch (Exception ex)
{
LogManager.Log(ex, "Error applying changes.");
_notification.ShowError($"Error applying changes.\n{ex.FlattenMessage()}");
}
finally
{
IsFree = true;
}
}
}
}
