public OperationResult<List<Holiday>> GetHolidays(Guid clientUID, HolidayFilter filter)
		{
			using (var databaseService = new RubezhDAL.DataClasses.DbService())
			{
				return databaseService.HolidayTranslator.Get(filter);
			}
		}

		protected override DataSet CreateDataSet(DataProvider dataProvider)
		{
			var filter = GetFilter<DepartmentsReportFilter>();
			var databaseService = new RubezhDAL.DataClasses.DbService();
			dataProvider.LoadCache();
			var departments = GetDepartments(dataProvider, filter);
			var uids = departments.Select(item => item.UID).ToList();
			var employees = dataProvider.GetEmployees(departments.Where(item => item.Item.ChiefUID != Guid.Empty).Select(item => item.Item.ChiefUID));
			var ds = new DepartmentsDataSet();
			departments.ForEach(department =>
			{
				var row = ds.Data.NewDataRow();
				row.Organisation = department.Organisation;
				row.Department = department.Name;
				row.Phone = department.Item.Phone;
				row.Chief = employees.Where(item => item.UID == department.Item.ChiefUID).Select(item => item.Name).FirstOrDefault();
				row.ParentDepartment = dataProvider.Departments.ContainsKey(department.Item.ParentDepartmentUID) ?
					dataProvider.Departments[department.Item.ParentDepartmentUID].Name : string.Empty;
				row.Description = department.Item.Description;
				row.IsArchive = department.IsDeleted;
				var parents = GetParents(dataProvider, department);
				row.Level = parents.Count;
				row.Tag = string.Join("/", parents.Select(item => item.UID));
				ds.Data.AddDataRow(row);
			});
			return ds;
		}

		public OperationResult<List<DayInterval>> GetDayIntervals(Guid clientUID, DayIntervalFilter filter)
		{
			using (var databaseService = new RubezhDAL.DataClasses.DbService())
			{
				return databaseService.DayIntervalTranslator.Get(filter);
			}
		}

		public OperationResult<Employee> GetEmployeeDetails(Guid clientUID, Guid uid)
		{
			using (var databaseService = new RubezhDAL.DataClasses.DbService())
			{
				return databaseService.EmployeeTranslator.GetSingle(uid);
			}
		}

		/// <summary>
		/// Перезаписать вае графики конкретного ГК
		/// </summary>
		/// <param name="device"></param>
		/// <returns></returns>
		public static OperationResult<bool> RewriteAllSchedules(GKDevice device, Guid clientUID)
		{
			var progressCallback = GKProcessorManager.StartProgress("Перезапись графиков в " + device.PresentationName, "Стирание графиков", 1, false, GKProgressClientType.Administrator, clientUID);
			var removeResult = RemoveAllSchedules(device);
			if (removeResult.HasError)
				return OperationResult<bool>.FromError(removeResult.Errors);

			var schedules = new List<GKSchedule>();
			using (var databaseService = new RubezhDAL.DataClasses.DbService())
			{
				var schedulesResult = databaseService.GKScheduleTranslator.Get();
				if (schedulesResult.HasError)
					return OperationResult<bool>.FromError(schedulesResult.Errors);
				schedules = schedulesResult.Result;
			}

			progressCallback = GKProcessorManager.StartProgress("Запись графиков в " + device.PresentationName, "", schedules.Count + 1, false, GKProgressClientType.Administrator, clientUID);
			var emptySchedule = new GKSchedule();
			emptySchedule.Name = "Никогда";
			var setResult = GKSetSchedule(device, emptySchedule);
			if (setResult.HasError)
				return OperationResult<bool>.FromError(setResult.Errors);
			GKProcessorManager.DoProgress("Запись пустого графика ", progressCallback, clientUID);
			int i = 1;
			foreach (var schedule in schedules)
			{
				setResult = GKSetSchedule(device, schedule);
				if (setResult.HasError)
					return OperationResult<bool>.FromError(setResult.Errors);
				GKProcessorManager.DoProgress("Запись графика " + i, progressCallback, clientUID);
				i++;
			}
			GKProcessorManager.StopProgress(progressCallback, clientUID);
			return new OperationResult<bool>(true);
		}

		public OperationResult<bool> RestoreDayInterval(Guid clientUID, Guid uid, string name)
		{
			AddJournalMessage(JournalEventNameType.Редактирование_дневного_графика, name, uid, clientUID, JournalEventDescriptionType.Восстановление_дневной_график, JournalObjectType.DayInterval);
			using (var databaseService = new RubezhDAL.DataClasses.DbService())
			{
				return databaseService.DayIntervalTranslator.Restore(uid);
			}
		}

		public OperationResult<List<ScheduleScheme>> GetScheduleSchemes(Guid clientUID, ScheduleSchemeFilter filter)
		{
			using (var databaseService = new RubezhDAL.DataClasses.DbService())
			{
				var result = databaseService.ScheduleSchemeTranslator.Get(filter);
				return result;
			}
		}

		public OperationResult<bool> RestoreHoliday(Guid clientUID, Guid uid, string name)
		{
			AddJournalMessage(JournalEventNameType.Редактирование_праздничного_дня, name, uid, clientUID, JournalEventDescriptionType.Восстановление_праздничный_день, JournalObjectType.Holiday);
			using (var databaseService = new RubezhDAL.DataClasses.DbService())
			{
				return databaseService.HolidayTranslator.Restore(uid);
			}
		}

		public bool ReadMissingJournalItems()
		{
			var gkIpAddress = GKManager.GetIpAddress(GkDatabase.RootDevice);
			var localLastDBNo = -1;
			using (var skdDatabaseService = new RubezhDAL.DataClasses.DbService())
			{
				localLastDBNo = skdDatabaseService.GKMetadataTranslator.GetLastJournalNo(gkIpAddress);
			}
			if (localLastDBNo == -1)
			{
				return true;
			}
			var remoteLastId = GetLastId();
			if (remoteLastId == -1)
			{
				return false;
			}
			using (var skdDatabaseService = new RubezhDAL.DataClasses.DbService())
			{
				skdDatabaseService.GKMetadataTranslator.SetLastJournalNo(gkIpAddress, remoteLastId);
			}
			if (remoteLastId > localLastDBNo)
			{
				if (remoteLastId - localLastDBNo > 1000)
					localLastDBNo = remoteLastId - 1000;

				var progressCallback = GKProcessorManager.StartProgress("Синхронизация журнала ГК " + gkIpAddress, "", remoteLastId - localLastDBNo, true, GKProgressClientType.Monitor);

				using (var gkLifecycleManager = new GKLifecycleManager(GkDatabase.RootDevice, "Синхронизация журнала"))
				{
					for (int index = localLastDBNo; index <= remoteLastId; index++)
					{
						gkLifecycleManager.Progress(index - localLastDBNo + 1, remoteLastId - localLastDBNo);

						LastUpdateTime = DateTime.Now;
						if (progressCallback.IsCanceled)
							break;

						WaitIfSuspending();
						if (IsStopping)
						{
							break;
						}

						var journaParser = ReadJournal(index);
						if (journaParser != null)
						{
							GKProcessorManager.DoProgress((index - localLastDBNo).ToString() + " из " + (remoteLastId - localLastDBNo).ToString(), progressCallback);
							AddJournalItem(journaParser.JournalItem);
						}
					}
				}

				GKProcessorManager.StopProgress(progressCallback);
				LastId = remoteLastId;
			}
			return true;
		}

		public OperationResult<List<ShortEmployee>> GetEmployeeList(Guid clientUID, EmployeeFilter filter)
		{
			OperationResult<List<ShortEmployee>> result;
			using (var databaseService = new RubezhDAL.DataClasses.DbService())
			{
				result = databaseService.EmployeeTranslator.ShortTranslator.Get(filter);
			}
			return result;
		}

		void CheckKAUMeasure()
		{
			foreach (var device in GkDatabase.RootDevice.Children.Where(x => x.DriverType == GKDriverType.RSR2_KAU))
			{
				using (var skdDatabaseService = new RubezhDAL.DataClasses.DbService())
				{
					skdDatabaseService.CurrentConsumptionTranslator.SaveMany(GetKAUMeasure(device));
				}
			}
		}

		public OperationResult<bool> SaveHoliday(Guid clientUID, Holiday item, bool isNew)
		{
			if (isNew)
				AddJournalMessage(JournalEventNameType.Редактирование_праздничного_дня, item.Name, item.UID, clientUID, JournalEventDescriptionType.Добавление_праздничный_день, JournalObjectType.Holiday);
			else
				AddJournalMessage(JournalEventNameType.Редактирование_праздничного_дня, item.Name, item.UID, clientUID, JournalEventDescriptionType.Редактирование_праздничный_день, JournalObjectType.Holiday);
			using (var databaseService = new RubezhDAL.DataClasses.DbService())
			{
				return databaseService.HolidayTranslator.Save(item);
			}
		}

		public OperationResult<bool> SaveDayInterval(Guid clientUID, DayInterval item, bool isNew)
		{
			if (isNew)
				AddJournalMessage(JournalEventNameType.Редактирование_дневного_графика, item.Name, item.UID, clientUID, JournalEventDescriptionType.Добавление_дневной_график, JournalObjectType.DayInterval);
			else
				AddJournalMessage(JournalEventNameType.Редактирование_дневного_графика, item.Name, item.UID, clientUID, JournalEventDescriptionType.Редактирование_дневной_график, JournalObjectType.DayInterval);
			using (var databaseService = new RubezhDAL.DataClasses.DbService())
			{
				return databaseService.DayIntervalTranslator.Save(item);
			}
		}

		void PingJournal()
		{
			JournalParser journalParser;
			if (IsFirstTimeReadJournal && !String.IsNullOrEmpty(GkDatabase.RootDevice.GetReservedIpAddress())) // Находим последнее событие на КАУ первый раз (при запуске сервера)
			{
				journalParser = GetKauJournalById(-1);
				if (journalParser != null)
					LastKauId = journalParser.KauJournalRecordNo;
				IsFirstTimeReadJournal = false;
			}
			using (var gkLifecycleManager = new GKLifecycleManager(GkDatabase.RootDevice, "Проверка журнала"))
			{
				if (IpAddress != GkDatabase.RootDevice.GetGKIpAddress())
				{
					if (!String.IsNullOrEmpty(IpAddress))
					{
						var lastKauJournal = GetKauJournalById(LastKauId);
						if (lastKauJournal != null)
							LastId = lastKauJournal.GKJournalRecordNo;
					}
					IpAddress = GkDatabase.RootDevice.GetGKIpAddress();
				}
				var newLastId = GetLastId();
				if (newLastId == -1)
					return;
				if (LastId == -1)
					LastId = newLastId;
				if (newLastId > LastId)
				{
					for (int index = LastId + 1; index <= newLastId; index++)
					{
						gkLifecycleManager.Progress(index - LastId, newLastId - LastId);
						journalParser = ReadAndPublish(index);
						if (journalParser != null && journalParser.KauJournalRecordNo != 0)
							LastKauId = journalParser.KauJournalRecordNo;
					}
					LastId = newLastId;

					gkLifecycleManager.AddItem("Изменение индекса в БД");
					using (var skdDatabaseService = new RubezhDAL.DataClasses.DbService())
					{
						var gkIpAddress = GKManager.GetIpAddress(GkDatabase.RootDevice);
						skdDatabaseService.GKMetadataTranslator.SetLastJournalNo(gkIpAddress, LastId);
					}
				}
			}
		}

		public OperationResult<bool> SaveEmployee(Guid clientUID, Employee item, bool isNew)
		{
			if (isNew)
			{
				if (item.Type == PersonType.Employee)
					AddJournalMessage(JournalEventNameType.Редактирование_сотрудника, item.Name, item.UID, clientUID, JournalEventDescriptionType.Добавление_сотрудник, JournalObjectType.Employee);
				else if (item.Type == PersonType.Guest)
					AddJournalMessage(JournalEventNameType.Редактирование_посетителя, item.Name, item.UID, clientUID, JournalEventDescriptionType.Добавление_посетитель, JournalObjectType.Employee);
			}
			else
			{
				if (item.Type == PersonType.Employee)
					AddJournalMessage(JournalEventNameType.Редактирование_сотрудника, item.Name, item.UID, clientUID, JournalEventDescriptionType.Редактирование_сотрудник, JournalObjectType.Employee);
				else if (item.Type == PersonType.Guest)
					AddJournalMessage(JournalEventNameType.Редактирование_посетителя, item.Name, item.UID, clientUID, JournalEventDescriptionType.Редактирование_посетитель, JournalObjectType.Employee);
			}
			using (var databaseService = new RubezhDAL.DataClasses.DbService())
			{
				return databaseService.EmployeeTranslator.Save(item);
			}
		}

		protected override DataSet CreateDataSet(DataProvider dataProvider)
		{
			var filter = GetFilter<PositionsReportFilter>();
            var databaseService = new RubezhDAL.DataClasses.DbService();
			dataProvider.LoadCache();
			Guid organisationUID = Guid.Empty;
			var organisations = dataProvider.Organisations.Where(org => filter.User == null || filter.User.IsAdm || org.Value.Item.UserUIDs.Any(y => y == filter.User.UID));
			if (!filter.UseArchive)
				organisations = organisations.Where(org => !org.Value.IsDeleted);
			if (filter.Organisations.IsEmpty())
			{
				if (filter.IsDefault)
					organisationUID = organisations.FirstOrDefault().Key;
			}
			else
			{
				organisationUID = organisations.FirstOrDefault(org => org.Key == filter.Organisations.FirstOrDefault()).Key;
			}
			filter.Organisations = new List<Guid>() { organisationUID };

			var positionFilter = new PositionFilter()
			{
				OrganisationUIDs = filter.Organisations ?? new List<Guid>(),
				UIDs = filter.Positions ?? new List<Guid>(),
				LogicalDeletationType = filter.UseArchive ? LogicalDeletationType.All : LogicalDeletationType.Active,

			};
			var positions = GetPosition(dataProvider, filter);
			var ds = new PositionsDataSet();
			if (positions != null)
				positions.ForEach(position =>
				{
					var row = ds.Data.NewDataRow();
					row.Organisation = position.Organisation;
					row.Position = position.Item.Name;
					row.Description = position.Item.Description;
					ds.Data.AddDataRow(row);
				});
			return ds;
		}

		public static OperationResult<bool> AddOrEditCard(GKControllerCardSchedule controllerCardSchedule,
			SKDCard card, string employeeName, int gkCardNo = 0, bool isNew = true, RubezhDAL.DataClasses.DbService dbService = null)
		{
			if (gkCardNo == 0)
			{
				if (dbService == null)
				{
					using (var skdDatabaseService = new RubezhDAL.DataClasses.DbService())
					{
						gkCardNo = skdDatabaseService.GKCardTranslator.GetFreeGKNo(controllerCardSchedule.ControllerDevice.GetGKIpAddress(), card.Number, out isNew);
					}
				}
				else
					gkCardNo = dbService.GKCardTranslator.GetFreeGKNo(controllerCardSchedule.ControllerDevice.GetGKIpAddress(), card.Number, out isNew);
			}

			var user = new GKUser
			{
				GkNo = (ushort)gkCardNo,
				ExpirationDate = card.EndDate,
				Fio = employeeName,
				GkLevel = (byte)card.GKLevel,
				GkLevelSchedule = (byte)card.GKLevelSchedule,
				Password = card.Number,
				UserType = card.GKCardType
			};

			var result = AddOrEditUser(user, controllerCardSchedule.ControllerDevice, isNew, controllerCardSchedule.CardSchedules);
			if (result.HasError)
				return result;

			using (var skdDatabaseService = new RubezhDAL.DataClasses.DbService())
			{
				skdDatabaseService.GKCardTranslator.AddOrEdit(controllerCardSchedule.ControllerDevice.GetGKIpAddress(), gkCardNo, card.Number, employeeName);
			}

			return new OperationResult<bool>(true);
		}

		public OperationResult<bool> MarkDeletedEmployee(Guid clientUID, Guid uid, string name, bool isEmployee)
		{
			if (isEmployee)
				AddJournalMessage(JournalEventNameType.Редактирование_сотрудника, name, uid, clientUID, JournalEventDescriptionType.Удаление_сотрудник, JournalObjectType.Employee);
			else
				AddJournalMessage(JournalEventNameType.Редактирование_посетителя, name, uid, clientUID, JournalEventDescriptionType.Удаление_посетитель, JournalObjectType.Employee);
			var errors = new List<string>();
			using (var databaseService = new RubezhDAL.DataClasses.DbService())
			{
				var getEmployeeOperationResult = databaseService.CardTranslator.GetEmployeeCards(uid);

				if (!getEmployeeOperationResult.HasError)
				{
					foreach (var card in getEmployeeOperationResult.Result)
					{
						var operationResult = DeleteCardFromEmployee(clientUID, card, name, "Сотрудник удален");
						if (operationResult.HasError)
						{
							foreach (var item in operationResult.Errors)
							{
								errors.Add("Ошибка БД: " + item);
							}
						}
					}
				}

				var markdDletedOperationResult = databaseService.EmployeeTranslator.MarkDeleted(uid);
				if (markdDletedOperationResult.HasError)
				{
					errors.Add("Ошибка БД: " + markdDletedOperationResult.Error);
				}
			}

			if (errors.Count > 0)
				return OperationResult<bool>.FromError(errors);
			else
				return new OperationResult<bool>(true);
		}

		public OperationResult<List<TimeTrackDocumentType>> GetTimeTrackDocumentTypes(Guid clientUID, Guid organisationUID)
		{
			using (var databaseService = new RubezhDAL.DataClasses.DbService())
			{
				return databaseService.TimeTrackDocumentTypeTranslator.Get(organisationUID);
			}
		}

		public OperationResult<bool> EditPassJournal(Guid clientUID, Guid uid, Guid zoneUID, DateTime enterTime, DateTime exitTime)
		{
			using (var databaseService = new RubezhDAL.DataClasses.DbService())
			{
				return databaseService.PassJournalTranslator.EditPassJournal(uid, zoneUID, enterTime, exitTime);
			}
		}