void SetFilter()
{
var archiveFilter = new XArchiveFilter() { StartDate = ArchiveFirstDate < DateTime.Now.AddHours(-1) ? DateTime.Now.AddHours(-1) : ArchiveFirstDate, EndDate = DateTime.Now };
var archiveFilterViewModel = new ArchiveFilterViewModel(archiveFilter);
ArchiveFilter = archiveFilterViewModel.GetModel();
StartDate = archiveFilterViewModel.StartDateTime;
EndDate = archiveFilterViewModel.EndDateTime;
}
public ArchiveFilterViewModel(XArchiveFilter archiveFilter)
{
Title = "Настройки фильтра";
ClearCommand = new RelayCommand(OnClear);
SaveCommand = new RelayCommand(OnSave);
CancelCommand = new RelayCommand(OnCancel);
Initialize(archiveFilter);
}
void Initialize(XArchiveFilter archiveFilter)
{
StartDateTime = archiveFilter.StartDate;
EndDateTime = archiveFilter.EndDate;
InitializeJournalItemTypes(archiveFilter);
InitializeStateClasses(archiveFilter);
InitializeJournalDescriptionStates(archiveFilter);
InitializeDevices(archiveFilter);
InitializeZones(archiveFilter);
InitializeDirections(archiveFilter);
InitializeDescriptions(archiveFilter);
InitializeSubsystemTypes(archiveFilter);
InitializePumpStations(archiveFilter);
InitializePIMs(archiveFilter);
}
public void InitializeJournalDescriptionStates(XArchiveFilter archiveFilter)
{
JournalDescriptionStates = new List<JournalDescriptionStateViewModel>();
foreach (var journalDescriptionState in JournalDescriptionStateHelper.JournalDescriptionStates)
{
JournalDescriptionStates.Add(new JournalDescriptionStateViewModel(journalDescriptionState, DistinctDatabaseNames));
}
foreach (var journalDescriptionState in archiveFilter.JournalDescriptionState)
{
var eventNameViewModel = JournalDescriptionStates.FirstOrDefault(x => x.JournalDescriptionState == journalDescriptionState);
if (eventNameViewModel != null)
{
eventNameViewModel.IsChecked = true;
}
}
JournalDescriptionStates.Sort(JournalDescriptionStateViewModel.Compare);
}
void InitializeStateClasses(XArchiveFilter archiveFilter)
{
StateClasses = new List<StateClassViewModel>();
foreach (XStateClass stateClass in Enum.GetValues(typeof(XStateClass)))
{
var stateClassViewModel = new StateClassViewModel(stateClass);
StateClasses.Add(stateClassViewModel);
}
foreach (var stateClass in archiveFilter.StateClasses)
{
var stateClassViewModel = StateClasses.FirstOrDefault(x => x.StateClass == stateClass);
if (stateClassViewModel != null)
{
stateClassViewModel.IsChecked = true;
}
}
}
public void Sort(ShowXArchiveEventArgs showXArchiveEventArgs)
{
ArchiveFilter = new XArchiveFilter();
ArchiveFilter.StartDate = DateTime.Now.AddDays(-7);
if (showXArchiveEventArgs.Device != null)
ArchiveFilter.DeviceUIDs.Add(showXArchiveEventArgs.Device.UID);
if (showXArchiveEventArgs.Zone != null)
ArchiveFilter.ZoneUIDs.Add(showXArchiveEventArgs.Zone.UID);
if (showXArchiveEventArgs.Direction != null)
ArchiveFilter.DirectionUIDs.Add(showXArchiveEventArgs.Direction.UID);
if (showXArchiveEventArgs.Delay != null)
ArchiveFilter.DelayUIDs.Add(showXArchiveEventArgs.Delay.UID);
if (showXArchiveEventArgs.Pim != null)
ArchiveFilter.PimUIDs.Add(showXArchiveEventArgs.Pim.UID);
if (showXArchiveEventArgs.PumpStation != null)
ArchiveFilter.PumpStationUIDs.Add(showXArchiveEventArgs.PumpStation.UID);
IsFilterOn = true;
OnPropertyChanged("IsFilterExists");
}
void InitializeJournalItemTypes(XArchiveFilter archiveFilter)
{
JournalItemTypes = new List<JournalItemTypeViewModel>();
JournalItemTypes.Add(new JournalItemTypeViewModel(JournalItemType.Device));
JournalItemTypes.Add(new JournalItemTypeViewModel(JournalItemType.Direction));
JournalItemTypes.Add(new JournalItemTypeViewModel(JournalItemType.GK));
JournalItemTypes.Add(new JournalItemTypeViewModel(JournalItemType.System));
JournalItemTypes.Add(new JournalItemTypeViewModel(JournalItemType.Zone));
JournalItemTypes.Add(new JournalItemTypeViewModel(JournalItemType.PumpStation));
JournalItemTypes.Add(new JournalItemTypeViewModel(JournalItemType.Delay));
JournalItemTypes.Add(new JournalItemTypeViewModel(JournalItemType.Pim));
foreach (var journalItemType in archiveFilter.JournalItemTypes)
{
var JournalItemTypeViewModel = JournalItemTypes.FirstOrDefault(x => x.JournalItemType == journalItemType);
if (JournalItemTypeViewModel != null)
{
JournalItemTypeViewModel.IsChecked = true;
}
}
}
public XArchiveFilter GetModel()
{
var archiveFilter = new XArchiveFilter()
{
StartDate = StartDateTime,
EndDate = EndDateTime,
UseDeviceDateTime = UseDeviceDateTime
};
foreach (var journalItemType in JournalItemTypes)
{
if (journalItemType.IsChecked)
archiveFilter.JournalItemTypes.Add(journalItemType.JournalItemType);
}
foreach (var stateClass in StateClasses)
{
if (stateClass.IsChecked)
archiveFilter.StateClasses.Add(stateClass.StateClass);
}
foreach (var eventName in JournalDescriptionStates)
{
if (eventName.IsChecked)
archiveFilter.JournalDescriptionState.Add(eventName.JournalDescriptionState);
}
foreach (var archiveDevice in AllDevices)
{
if (archiveDevice.IsChecked)
archiveFilter.DeviceUIDs.Add(archiveDevice.Device.UID);
}
foreach (var archiveZone in ArchiveZones)
{
if (archiveZone.IsChecked)
archiveFilter.ZoneUIDs.Add(archiveZone.Zone.UID);
}
foreach (var archiveDirection in ArchiveDirections)
{
if (archiveDirection.IsChecked)
archiveFilter.DirectionUIDs.Add(archiveDirection.Direction.UID);
}
foreach (var description in ArchiveDescriptions)
{
if (description.IsChecked)
archiveFilter.Descriptions.Add(description.Description.Name);
}
foreach (var subsystemType in SubsystemTypes)
{
if (subsystemType.IsChecked)
archiveFilter.SubsystemTypes.Add(subsystemType.SubsystemType);
}
foreach (var pumpStation in PumpStations)
{
if (pumpStation.IsChecked)
archiveFilter.PumpStationUIDs.Add(pumpStation.PumpStation.UID);
}
foreach (var pim in PIMs)
{
if (pim.IsChecked)
archiveFilter.PimUIDs.Add(pim.Pim.UID);
}
return archiveFilter;
}
public void InitializeDevices(XArchiveFilter archiveFilter)
{
BuildTree();
if (RootDevice != null)
{
RootDevice.IsExpanded = true;
SelectedDevice = RootDevice;
}
foreach (var deviceUID in archiveFilter.DeviceUIDs)
{
var archiveDevice = AllDevices.FirstOrDefault(x => x.Device.UID == deviceUID);
if (archiveDevice != null)
{
archiveDevice.IsChecked = true;
archiveDevice.ExpandToThis();
}
}
OnPropertyChanged("RootDevices");
}
XArchiveFilter GerFilterFromDefaultState(ArchiveDefaultState archiveDefaultState)
{
var archiveFilter = new XArchiveFilter()
{
StartDate = ArchiveFirstDate,
EndDate = DateTime.Now
};
switch (archiveDefaultState.ArchiveDefaultStateType)
{
case ArchiveDefaultStateType.LastHours:
if (archiveDefaultState.Count.HasValue)
archiveFilter.StartDate = archiveFilter.EndDate.AddHours(-archiveDefaultState.Count.Value);
break;
case ArchiveDefaultStateType.LastDays:
if (archiveDefaultState.Count.HasValue)
archiveFilter.StartDate = archiveFilter.EndDate.AddDays(-archiveDefaultState.Count.Value);
break;
case ArchiveDefaultStateType.FromDate:
if (archiveDefaultState.StartDate.HasValue)
archiveFilter.StartDate = archiveDefaultState.StartDate.Value;
break;
case ArchiveDefaultStateType.RangeDate:
if (archiveDefaultState.StartDate.HasValue)
archiveFilter.StartDate = archiveDefaultState.StartDate.Value;
if (archiveDefaultState.EndDate.HasValue)
archiveFilter.EndDate = archiveDefaultState.EndDate.Value;
break;
}
return archiveFilter;
}
void InitializePumpStations(XArchiveFilter archiveFilter)
{
PumpStations = new List<ArchivePumpStationViewModel>();
foreach (var direction in XManager.PumpStations)
{
var archiveDirectionViewModel = new ArchivePumpStationViewModel(direction);
PumpStations.Add(archiveDirectionViewModel);
}
foreach (var uid in archiveFilter.PumpStationUIDs)
{
var pumpStation = PumpStations.FirstOrDefault(x => x.PumpStation.UID == uid);
if (pumpStation != null)
{
pumpStation.IsChecked = true;
}
}
}
void InitializeSubsystemTypes(XArchiveFilter archiveFilter)
{
SubsystemTypes = new List<SubsystemTypeViewModel>();
foreach (XSubsystemType item in Enum.GetValues(typeof(XSubsystemType)))
{
SubsystemTypes.Add(new SubsystemTypeViewModel(item));
}
foreach (var subsystemType in archiveFilter.SubsystemTypes)
{
var subsystemTypeViewModel = SubsystemTypes.FirstOrDefault(x => x.SubsystemType == subsystemType);
if (subsystemTypeViewModel != null)
{
subsystemTypeViewModel.IsChecked = true;
}
}
}
public void InitializeDescriptions(XArchiveFilter archiveFilter)
{
ArchiveDescriptions = new List<DescriptionViewModel>();
foreach (var description in DescriptionsHelper.GetAllDescriptions())
{
ArchiveDescriptions.Add(new DescriptionViewModel(description, DistinctDatabaseDescriptions));
}
foreach (var description in archiveFilter.Descriptions)
{
var descriptionViewModel = ArchiveDescriptions.FirstOrDefault(x => x.Description.Name == description);
if(descriptionViewModel != null)
{
descriptionViewModel.IsChecked = true;
}
}
ArchiveDescriptions.Sort(DescriptionViewModel.Compare);
}
public void InitializeDirections(XArchiveFilter archiveFilter)
{
ArchiveDirections = new List<ArchiveDirectionViewModel>();
foreach (var direction in XManager.Directions)
{
var archiveDirectionViewModel = new ArchiveDirectionViewModel(direction);
ArchiveDirections.Add(archiveDirectionViewModel);
}
foreach (var directionUID in archiveFilter.DirectionUIDs)
{
var archiveDirection = ArchiveDirections.FirstOrDefault(x => x.Direction.UID == directionUID);
if (archiveDirection != null)
{
archiveDirection.IsChecked = true;
}
}
}
public void InitializeZones(XArchiveFilter archiveFilter)
{
ArchiveZones = new List<ArchiveZoneViewModel>();
foreach (var zone in XManager.Zones)
{
var archiveZoneViewModel = new ArchiveZoneViewModel(zone);
ArchiveZones.Add(archiveZoneViewModel);
}
foreach (var zoneUID in archiveFilter.ZoneUIDs)
{
var archiveZone = ArchiveZones.FirstOrDefault(x => x.Zone.UID == zoneUID);
if (archiveZone != null)
{
archiveZone.IsChecked = true;
}
}
}
public static List<JournalItem> Select(XArchiveFilter archiveFilter)
{
var journalItems = new List<JournalItem>();
string dateTimeTypeString;
if (archiveFilter.UseDeviceDateTime)
dateTimeTypeString = "DeviceDateTime";
else
dateTimeTypeString = "SystemDateTime";
try
{
lock (locker)
{
if (File.Exists(AppDataFolderHelper.GetDBFile("GkJournalDatabase.sdf")))
{
using (var dataContext = new SqlCeConnection(ConnectionString))
{
var query =
"SELECT * FROM Journal WHERE " +
"\n " + dateTimeTypeString + " > '" + archiveFilter.StartDate.ToString("yyyy-MM-dd HH:mm:ss") + "'" +
"\n AND " + dateTimeTypeString + " < '" + archiveFilter.EndDate.ToString("yyyy-MM-dd HH:mm:ss") + "'";
if (archiveFilter.JournalItemTypes.Count > 0)
{
query += "\n AND (";
int index = 0;
foreach (var journalItemType in archiveFilter.JournalItemTypes)
{
if (index > 0)
query += "\n OR ";
index++;
query += "JournalItemType = '" + ((int)journalItemType).ToString() + "'";
}
query += ")";
}
if (archiveFilter.StateClasses.Count > 0)
{
query += "\n AND (";
int index = 0;
foreach (var stateClass in archiveFilter.StateClasses)
{
if (index > 0)
query += "\n OR ";
index++;
query += "StateClass = '" + ((int)stateClass).ToString() + "'";
}
query += ")";
}
if (archiveFilter.JournalDescriptionState.Count > 0)
{
query += "\n and (";
int index = 0;
foreach (var eventName in archiveFilter.JournalDescriptionState)
{
if (index > 0)
query += "\n OR ";
index++;
query += "Name = '" + eventName.Name + "'";
}
query += ")";
}
if (archiveFilter.Descriptions.Count > 0)
{
query += "\n AND (";
int index = 0;
foreach (var description in archiveFilter.Descriptions)
{
if (index > 0)
query += "\n OR ";
index++;
query += "Description = '" + description + "'";
}
query += ")";
}
if (archiveFilter.SubsystemTypes.Count > 0)
{
query += "\n AND (";
int index = 0;
foreach (var subsystem in archiveFilter.SubsystemTypes)
{
if (index > 0)
query += "\n OR ";
index++;
if(subsystem == XSubsystemType.System)
query += "Subsystem = 0";
else
query += "Subsystem = 1";
}
query += ")";
}
var objectUIDs = new List<Guid>();
objectUIDs.AddRange(archiveFilter.DeviceUIDs);
objectUIDs.AddRange(archiveFilter.ZoneUIDs);
objectUIDs.AddRange(archiveFilter.DirectionUIDs);
objectUIDs.AddRange(archiveFilter.DelayUIDs);
objectUIDs.AddRange(archiveFilter.PimUIDs);
objectUIDs.AddRange(archiveFilter.PumpStationUIDs);
if (objectUIDs.Count > 0)
{
int index = 0;
query += "\n AND (";
foreach (var objectUID in objectUIDs)
{
if (index > 0)
query += "\n OR ";
index++;
query += "ObjectUID = '" + objectUID + "'";
}
query += ")";
}
query += "\n ORDER BY " + dateTimeTypeString + " DESC ,GKJournalRecordNo DESC";
var sqlCeCommand = new SqlCeCommand(query, dataContext);
dataContext.Open();
var reader = sqlCeCommand.ExecuteReader();
while (reader.Read())
{
var journalItem = ReadOneJournalItem(reader);
journalItems.Add(journalItem);
}
}
}
}
}
catch (Exception e)
{
Logger.Error(e, "GKDBHelper.Select");
}
return journalItems;
}
void InitializePIMs(XArchiveFilter archiveFilter)
{
PIMs = new List<ArchivePimViewModel>();
foreach (var pim in XManager.Pims)
{
var archivePimViewModel = new ArchivePimViewModel(pim);
PIMs.Add(archivePimViewModel);
}
foreach (var uid in archiveFilter.PimUIDs)
{
var pim = PIMs.FirstOrDefault(x => x.Pim.UID == uid);
if (pim != null)
{
pim.IsChecked = true;
}
}
}
void OnShowFilter()
{
if (ArchiveFilter == null)
ArchiveFilter = GerFilterFromDefaultState(ArchiveDefaultState);
ArchiveFilterViewModel archiveFilterViewModel = null;
var result = WaitHelper.Execute(() =>
{
archiveFilterViewModel = new ArchiveFilterViewModel(ArchiveFilter);
});
if (result)
{
if (DialogService.ShowModalWindow(archiveFilterViewModel))
{
ArchiveFilter = archiveFilterViewModel.GetModel();
OnPropertyChanged("IsFilterExists");
IsFilterOn = true;
}
}
}
