public static IEnumerable<SKDCard> GetOrganisationCards(Guid organisationUID)
{
var filter = new CardFilter();
filter.EmployeeFilter = new EmployeeFilter { OrganisationUIDs = new List<Guid> { organisationUID }, IsAllPersonTypes = true };
var result = ClientManager.RubezhService.GetCards(filter);
return Common.ThrowErrorIfExists(result);
}
public static IEnumerable<SKDCard> GetStopListCards()
{
var filter = new CardFilter();
filter.DeactivationType = LogicalDeletationType.Deleted;
var result = ClientManager.RubezhService.GetCards(filter);
return Common.ThrowErrorIfExists(result);
}
public HRFilter()
{
EmployeeFilter = new EmployeeFilter();
DepartmentFilter = new DepartmentFilter();
PositionFilter = new PositionFilter();
AdditionalColumnTypeFilter = new AdditionalColumnTypeFilter();
AccessTemplateFilter = new AccessTemplateFilter();
PassCardTemplateFilter = new PassCardTemplateFilter();
CardFilter = new CardFilter();
}
protected override DataSet CreateDataSet(DataProvider dataProvider)
{
var filter = GetFilter<CardsReportFilter>();
var cardFilter = new CardFilter();
cardFilter.EmployeeFilter = dataProvider.GetCardEmployeeFilter(filter);
if ((filter.PassCardActive && filter.PassCardInactive) || (!filter.PassCardActive && !filter.PassCardInactive))
cardFilter.DeactivationType = LogicalDeletationType.All;
if (filter.PassCardActive && !filter.PassCardInactive)
cardFilter.DeactivationType = LogicalDeletationType.Active;
if (!filter.PassCardActive && filter.PassCardInactive)
cardFilter.DeactivationType = LogicalDeletationType.Deleted;
cardFilter.IsWithEndDate = filter.UseExpirationDate;
if (filter.UseExpirationDate)
switch (filter.ExpirationType)
{
case EndDateType.Day:
cardFilter.EndDate = DateTime.Today.AddDays(1);
break;
case EndDateType.Week:
cardFilter.EndDate = DateTime.Today.AddDays(7);
break;
case EndDateType.Month:
cardFilter.EndDate = DateTime.Today.AddDays(31);
break;
case EndDateType.Arbitrary:
cardFilter.EndDate = filter.ExpirationDate;
break;
}
var cardsResult = dataProvider.DbService.CardTranslator.Get(cardFilter);
var dataSet = new CardsDataSet();
if (!cardsResult.HasError)
{
dataProvider.GetEmployees(cardsResult.Result.Select(item => item.EmployeeUID.GetValueOrDefault()));
foreach (var card in cardsResult.Result)
{
var dataRow = dataSet.Data.NewDataRow();
dataRow.Type = card.IsInStopList ? "Деактивированный" : card.GKCardType.ToDescription();
dataRow.Number = card.Number.ToString();
var employee = dataProvider.GetEmployee(card.EmployeeUID.GetValueOrDefault());
if (employee != null)
{
dataRow.Employee = employee.Name;
dataRow.Organisation = employee.Organisation;
dataRow.Department = employee.Department;
dataRow.Position = employee.Position;
}
if (!card.IsInStopList)
dataRow.Period = card.EndDate;
dataSet.Data.Rows.Add(dataRow);
}
}
return dataSet;
}
public JsonResult GetOrganisations(CardFilter cardFilter)
{
var cardsViewModel = new CardsViewModel();
cardsViewModel.Initialize(new CardFilter
{
OrganisationUIDs = cardFilter.OrganisationUIDs,
LogicalDeletationType = cardFilter.LogicalDeletationType
});
dynamic result = new
{
page = 1,
total = 100,
records = 100,
rows = cardsViewModel.RootItems,
};
return Json(result, JsonRequestBehavior.AllowGet);
}
public HRViewModel(SKDTabItems skdTabItems)
{
SKDTabItems = skdTabItems;
EditFilterCommand = new RelayCommand(OnEditFilter, CanEditFilter);
ChangeIsDeletedCommand = new RelayCommand(OnChangeIsDeleted, CanChangeIsDeleted);
EmployeesViewModel = new EmployeesViewModel();
DepartmentsViewModel = new DepartmentsViewModel();
PositionsViewModel = new PositionsViewModel();
AdditionalColumnTypesViewModel = new AdditionalColumnTypesViewModel();
CardsViewModel = new CardsViewModel();
AccessTemplatesViewModel = new AccessTemplatesViewModel();
PassCardTemplatesViewModel = new PassCardTemplatesViewModel();
OrganisationsViewModel = new OrganisationsViewModel();
DepartmentFilter = new DepartmentFilter();
PositionFilter = new PositionFilter();
CardFilter = new CardFilter();
if (CanSelectEmployees)
IsEmployeesSelected = true;
else if (CanSelectDepartments)
IsDepartmentsSelected = true;
else if (CanSelectPositions)
IsPositionsSelected = true;
else if (CanSelectAdditionalColumns)
IsAdditionalColumnTypesSelected = true;
else if (CanSelectCards)
IsCardsSelected = true;
else if (CanSelectAccessTemplates)
IsAccessTemplatesSelected = true;
else if (CanSelectPassCardTemplates)
IsPassCardTemplatesSelected = true;
else if (CanSelectOrganisations)
IsOrganisationsSelected = true;
PersonTypes = new ObservableCollection<PersonType>();
if (ClientManager.CurrentUser.HasPermission(PermissionType.Oper_SKD_Employees_View))
PersonTypes.Add(PersonType.Employee);
if (ClientManager.CurrentUser.HasPermission(PermissionType.Oper_SKD_Guests_View))
PersonTypes.Add(PersonType.Guest);
_selectedPersonType = PersonTypes.FirstOrDefault();
var user = ClientManager.CurrentUser;
Filter = new HRFilter() { User = user };
Filter.EmployeeFilter.User = user;
}
public CardsViewModel()
{
_filter = new CardFilter();
RemoveCommand = new RelayCommand(OnRemove, CanRemove);
ServiceFactory.Events.GetEvent<NewCardEvent>().Unsubscribe(OnNewCard);
ServiceFactory.Events.GetEvent<NewCardEvent>().Subscribe(OnNewCard);
ServiceFactory.Events.GetEvent<BlockCardEvent>().Unsubscribe(OnBlockCard);
ServiceFactory.Events.GetEvent<BlockCardEvent>().Subscribe(OnBlockCard);
ServiceFactory.Events.GetEvent<DeleteCardEvent>().Unsubscribe(OnDeleteCard);
ServiceFactory.Events.GetEvent<DeleteCardEvent>().Subscribe(OnDeleteCard);
ServiceFactory.Events.GetEvent<EditOrganisationEvent>().Unsubscribe(OnEditOrganisation);
ServiceFactory.Events.GetEvent<EditOrganisationEvent>().Subscribe(OnEditOrganisation);
ServiceFactory.Events.GetEvent<RemoveOrganisationEvent>().Unsubscribe(OnRemoveOrganisation);
ServiceFactory.Events.GetEvent<RemoveOrganisationEvent>().Subscribe(OnRemoveOrganisation);
ServiceFactory.Events.GetEvent<OrganisationUsersChangedEvent>().Unsubscribe(OnOrganisationUsersChanged);
ServiceFactory.Events.GetEvent<OrganisationUsersChangedEvent>().Subscribe(OnOrganisationUsersChanged);
ServiceFactory.Events.GetEvent<EditEmployee2Event>().Unsubscribe(OnEditEmployee);
ServiceFactory.Events.GetEvent<EditEmployee2Event>().Subscribe(OnEditEmployee);
DbCallbackResultUID = Guid.NewGuid();
}
public void Initialize(CardFilter filter)
{
var organisations = OrganisationHelper.GetByCurrentUser();
if (organisations == null)
return;
RootItems = new List<CardViewModel>();
foreach (var organisation in organisations)
{
var cardViewModel = new CardViewModel(organisation);
RootItems.Add(cardViewModel);
}
var deactivatedRootItem = new CardViewModel(true);
deactivatedRootItem.UID = Guid.NewGuid();
RootItems.Add(deactivatedRootItem);
var cards = CardHelper.Get(filter);
if (cards == null)
return;
foreach (var card in cards)
{
var condition = card.IsInStopList ? (Func<CardViewModel, bool>)(x => x.IsDeactivatedRootItem) : x => x.IsOrganisation && x.UID == card.OrganisationUID;
var rootItem = RootItems.FirstOrDefault(condition);
if (rootItem != null)
{
rootItem.IsLeaf = false;
rootItem.IsExpanded = true;
var cardViewModel = new CardViewModel(card);
cardViewModel.ParentUID = rootItem.UID;
RootItems.Insert(RootItems.IndexOf(rootItem) + 1, cardViewModel);
}
}
var rootItemsToRemove = RootItems.Where(x => x.Level == 0 && x.IsLeaf).ToList();
foreach (var rootItem in rootItemsToRemove)
{
RootItems.Remove(rootItem);
}
}
public void Initialize(CardFilter filter)
{
var organisations = OrganisationHelper.GetByCurrentUser();
if (organisations == null)
return;
RootItems = new ObservableCollection<CardViewModel>();
foreach (var organisation in organisations)
{
RootItems.Add(new CardViewModel(organisation));
}
RootItems.Add(CardViewModel.DeactivatedRootItem);
var cards = CardHelper.Get(filter);
if (cards == null)
return;
foreach (var card in cards)
{
var condition = card.IsInStopList ? (Func<CardViewModel, bool>)(x => x.IsDeactivatedRootItem) : x => x.IsOrganisation && x.Organisation.UID == card.OrganisationUID;
var rootItem = RootItems.FirstOrDefault(condition);
if (rootItem != null)
rootItem.AddChild(new CardViewModel(card));
}
foreach (var rootItem in RootItems)
{
if (rootItem.HasChildren)
rootItem.ExpandChildren();
}
var rootItemsToRemove = RootItems.Where(x => x.GetAllChildren(false).Count == 0).ToList();
foreach (var rootItem in rootItemsToRemove)
{
RootItems.Remove(rootItem);
}
OnPropertyChanged(() => RootItems);
OnPropertyChanged(() => RootItemsArray);
}
void OnOrganisationUsersChanged(Organisation newOrganisation)
{
if (newOrganisation.UserUIDs.Any(x => x == ClientManager.CurrentUser.UID))
{
if (!RootItems.Any(x => x.IsOrganisation && x.Organisation.UID == newOrganisation.UID))
{
var organisationViewModel = new CardViewModel(newOrganisation);
var cardFilter = new CardFilter();
cardFilter.EmployeeFilter = new EmployeeFilter { OrganisationUIDs = new System.Collections.Generic.List<Guid> { newOrganisation.UID } };
var cards = CardHelper.Get(cardFilter);
if (cards == null || cards.Count() == 0)
return;
RootItems.Add(organisationViewModel);
foreach (var card in cards.Where(x => x.OrganisationUID == newOrganisation.UID))
{
organisationViewModel.AddChild(new CardViewModel(card));
}
OnPropertyChanged(() => RootItems);
OnPropertyChanged(() => RootItemsArray);
}
}
else
{
var organisationViewModel = RootItems.FirstOrDefault(x => x.IsOrganisation && x.Organisation.UID == newOrganisation.UID);
if (organisationViewModel != null)
{
RootItems.Remove(organisationViewModel);
OnPropertyChanged(() => RootItems);
OnPropertyChanged(() => RootItemsArray);
}
}
}
protected override DataSet CreateDataSet(DataProvider dataProvider)
{
var filter = GetFilter<EmployeeAccessReportFilter>();
if (!filter.PassCardActive && !filter.PassCardForcing && !filter.PassCardLocked && !filter.PassCardOnceOnly && !filter.PassCardPermanent && !filter.PassCardTemprorary)
{
filter.PassCardActive = true;
filter.PassCardForcing = true;
filter.PassCardLocked = true;
filter.PassCardOnceOnly = true;
filter.PassCardPermanent = true;
filter.PassCardTemprorary = true;
}
var cardFilter = new CardFilter();
cardFilter.EmployeeFilter = dataProvider.GetCardEmployeeFilter(filter);
cardFilter.DeactivationType = LogicalDeletationType.Active;
cardFilter.LogicalDeletationType = LogicalDeletationType.Active;
var cardsResult = dataProvider.DbService.CardTranslator.Get(cardFilter);
var dataSet = new EmployeeAccessDataSet();
if (!cardsResult.HasError)
{
dataProvider.GetEmployees(cardsResult.Result.Select(item => item.EmployeeUID.GetValueOrDefault()));
var accessTemplateFilter = new AccessTemplateFilter()
{
UIDs = cardsResult.Result.Where(item => item.AccessTemplateUID.HasValue && item.AccessTemplateUID != Guid.Empty).Select(item => item.AccessTemplateUID.Value).ToList()
};
var accessTemplates = dataProvider.DbService.AccessTemplateTranslator.Get(accessTemplateFilter);
var zoneMap = new Dictionary<Guid, Tuple<Tuple<GKSKDZone, string>, Tuple<GKSKDZone, string>>>();
GKManager.Doors.ForEach(door =>
{
if (door != null && !zoneMap.ContainsKey(door.UID))
{
GKSKDZone enterZone = null;
if (filter.Zones.IsEmpty() || filter.Zones.Contains(door.EnterZoneUID))
{
enterZone = GKManager.SKDZones.FirstOrDefault(x => x.UID == door.EnterZoneUID);
}
GKSKDZone exitZone = null;
if (filter.Zones.IsEmpty() || filter.Zones.Contains(door.ExitZoneUID))
{
exitZone = GKManager.SKDZones.FirstOrDefault(x => x.UID == door.ExitZoneUID);
}
Tuple<GKSKDZone, string> enterZoneTuple = null;
if (enterZone != null)
{
enterZoneTuple = new Tuple<GKSKDZone, string>(enterZone, enterZone.PresentationName);
}
Tuple<GKSKDZone, string> exitZoneTuple = null;
if (exitZone != null)
{
exitZoneTuple = new Tuple<GKSKDZone, string>(exitZone, exitZone.PresentationName);
}
var value = new Tuple<Tuple<GKSKDZone, string>, Tuple<GKSKDZone, string>>(enterZoneTuple, exitZoneTuple);
zoneMap.Add(door.UID, value);
}
});
foreach (var card in cardsResult.Result)
{
var employee = dataProvider.GetEmployee(card.EmployeeUID.GetValueOrDefault());
var addedZones = new List<Guid>();
foreach (var door in card.CardDoors)
AddRow(dataSet, employee, card, door, null, zoneMap, addedZones);
if (!accessTemplates.HasError && card.AccessTemplateUID.HasValue)
{
var cardDoorUIDs = card.CardDoors.Select(item => item.DoorUID);
var accessTemplate = accessTemplates.Result.FirstOrDefault(item => item.UID == card.AccessTemplateUID.Value);
if (accessTemplates != null)
foreach (var door in accessTemplate.CardDoors.Where(item => !cardDoorUIDs.Contains(item.DoorUID)))
AddRow(dataSet, employee, card, door, accessTemplate, zoneMap, addedZones);
}
}
}
return dataSet;
}
protected override DataSet CreateDataSet(DataProvider dataProvider)
{
var filter = GetFilter<EmployeeDoorsReportFilter>();
if (!filter.PassCardActive && !filter.PassCardForcing && !filter.PassCardLocked && !filter.PassCardOnceOnly && !filter.PassCardPermanent && !filter.PassCardTemprorary)
{
filter.PassCardActive = true;
filter.PassCardForcing = true;
filter.PassCardLocked = true;
filter.PassCardOnceOnly = true;
filter.PassCardPermanent = true;
filter.PassCardTemprorary = true;
}
if (!filter.ZoneIn && !filter.ZoneOut)
{
filter.ZoneIn = true;
filter.ZoneOut = true;
}
if (!filter.ScheduleEnter && !filter.ScheduleExit)
{
filter.ScheduleEnter = true;
filter.ScheduleExit = true;
}
var cardFilter = new CardFilter();
cardFilter.EmployeeFilter = dataProvider.GetCardEmployeeFilter(filter);
cardFilter.DeactivationType = LogicalDeletationType.Active;
cardFilter.LogicalDeletationType = LogicalDeletationType.Active;
var cardsResult = dataProvider.DbService.CardTranslator.Get(cardFilter);
var dataSet = new EmployeeDoorsDataSet();
if (!cardsResult.HasError)
{
dataProvider.GetEmployees(cardsResult.Result.Select(item => item.EmployeeUID.GetValueOrDefault()));
var accessTemplateFilter = new AccessTemplateFilter()
{
UIDs = cardsResult.Result.Where(item => item.AccessTemplateUID.HasValue && item.AccessTemplateUID != Guid.Empty).Select(item => item.AccessTemplateUID.Value).ToList()
};
var accessTemplates = dataProvider.DbService.AccessTemplateTranslator.Get(accessTemplateFilter);
var doorMap = new Dictionary<Guid, CommonDoor>();
foreach (var door in GKManager.Doors)
{
var commonDoor = new CommonDoor(door);
if (!filter.Zones.IsEmpty())
{
if ((filter.ZoneIn && filter.Zones.Contains(door.EnterZoneUID)) || (filter.ZoneOut && filter.Zones.Contains(door.ExitZoneUID)))
doorMap.Add(door.UID, commonDoor);
}
else
{
doorMap.Add(door.UID, commonDoor);
}
}
Dictionary<int, string> intervalMap = new Dictionary<int, string>();
var schedulesResult = dataProvider.DbService.GKScheduleTranslator.Get();
if (!schedulesResult.HasError)
{
foreach (var interval in schedulesResult.Result)
{
intervalMap.Add(interval.No, interval.Name);
}
}
foreach (var card in cardsResult.Result)
{
IEnumerable<CardDoor> cardDoors = card.CardDoors;
if (!accessTemplates.HasError && card.AccessTemplateUID.HasValue && card.AccessTemplateUID.Value != Guid.Empty)
{
var accessTemplate = accessTemplates.Result.FirstOrDefault(item => item.UID == card.AccessTemplateUID.Value);
var cardDoorUIDs = card.CardDoors.Select(item => item.DoorUID);
if (accessTemplate != null)
cardDoors = cardDoors.Union(accessTemplate.CardDoors.Where(item => !cardDoorUIDs.Contains(item.DoorUID)));
}
var employee = dataProvider.GetEmployee(card.EmployeeUID.GetValueOrDefault());
if (!filter.Schedules.IsEmpty())
cardDoors = cardDoors.Where(item =>
(filter.ScheduleEnter && filter.Schedules.Contains(item.EnterScheduleNo)) ||
(filter.ScheduleExit && filter.Schedules.Contains(item.ExitScheduleNo)));
foreach (var cardDoor in cardDoors)
if (doorMap.ContainsKey(cardDoor.DoorUID))
{
var door = doorMap[cardDoor.DoorUID];
var dataRow = dataSet.Data.NewDataRow();
dataRow.Type = card.GKCardType.ToDescription();
dataRow.Number = card.Number.ToString();
if (employee != null)
{
dataRow.Employee = employee.Name;
dataRow.Organisation = employee.Organisation;
dataRow.Department = employee.Department;
dataRow.Position = employee.Position;
}
dataRow.ZoneIn = door.EnterZoneName;
dataRow.ZoneOut = door.ExitZoneName;
dataRow.NoEnterZone = door.NoEnterZone;
dataRow.NoExitZone = door.NoExitZone;
if (intervalMap.ContainsKey(cardDoor.EnterScheduleNo))
dataRow.Enter = intervalMap[cardDoor.EnterScheduleNo];
if (door.Type != GKDoorType.OneWay && intervalMap.ContainsKey(cardDoor.ExitScheduleNo))
dataRow.Exit = intervalMap[cardDoor.ExitScheduleNo];
dataRow.AccessPoint = door.Name;
dataRow.NoDoor = door.NoDoor;
dataSet.Data.Rows.Add(dataRow);
}
}
}
return dataSet;
}
public static IEnumerable<SKDCard> Get(CardFilter filter, bool isShowError = true)
{
var result = ClientManager.RubezhService.GetCards(filter);
return Common.ShowErrorIfExists(result, isShowError);
}
public OperationResult<List<SKDCard>> GetCards(Guid clientUID, CardFilter filter)
{
return SafeOperationCall(clientUID, () => RubezhService.GetCards(clientUID, filter), "GetCards");
}
public OperationResult<List<SKDCard>> GetCards(CardFilter filter)
{
return SafeOperationCall(() =>
{
var rubezhService = RubezhServiceFactory.Create(TimeSpan.FromMinutes(10));
using (rubezhService as IDisposable)
return rubezhService.GetCards(RubezhServiceFactory.UID, filter);
}, "GetCards");
}
public static IEnumerable<SKDCard> Get(CardFilter filter)
{
var result = ClientManager.RubezhService.GetCards(filter);
return Common.ThrowErrorIfExists(result);
}
public void Initialize()
{
DepartmentFilter = new DepartmentFilter()
{
OrganisationUIDs = Filter.OrganisationUIDs,
LogicalDeletationType = Filter.LogicalDeletationType
};
PositionFilter = new PositionFilter()
{
OrganisationUIDs = Filter.OrganisationUIDs,
LogicalDeletationType = Filter.LogicalDeletationType
};
AdditionalColumnTypeFilter = new AdditionalColumnTypeFilter()
{
OrganisationUIDs = Filter.OrganisationUIDs,
LogicalDeletationType = Filter.LogicalDeletationType
};
CardFilter = new CardFilter()
{
OrganisationUIDs = Filter.OrganisationUIDs,
EmployeeFilter = Filter.EmployeeFilter,
};
AccessTemplateFilter = new AccessTemplateFilter()
{
OrganisationUIDs = Filter.OrganisationUIDs,
LogicalDeletationType = Filter.LogicalDeletationType
};
PassCardTemplateFilter = new PassCardTemplateFilter()
{
OrganisationUIDs = Filter.OrganisationUIDs,
LogicalDeletationType = Filter.LogicalDeletationType
};
InitializeEmployeeFilter();
DepartmentsViewModel.Initialize(DepartmentFilter);
PositionsViewModel.Initialize(PositionFilter);
AdditionalColumnTypesViewModel.Initialize(AdditionalColumnTypeFilter);
CardsViewModel.Initialize(CardFilter);
AccessTemplatesViewModel.Initialize(AccessTemplateFilter);
PassCardTemplatesViewModel.Initialize(PassCardTemplateFilter);
OrganisationsViewModel.Initialize(Filter.LogicalDeletationType);
EmployeesViewModel.Initialize(EmployeeFilter);
}
public OperationResult<List<SKDCard>> GetCards(Guid clientUID, CardFilter filter)
{
var result = new OperationResult<List<SKDCard>>();
using (var databaseService = new RubezhDAL.DataClasses.DbService())
{
result = databaseService.CardTranslator.Get(filter);
}
return result;
}
