public void Filter() { JournalRecords.Clear(); using (var repo = new Repository()) { var records = repo.GetAllWhere <StudentStatusOnLesson>(s => s.Date >= SelectedDate && s.Date <= SelectedDate.AddDays(6) && s.Student.Group.GroupName == SelectedGroup.GroupName && s.ScheduleRecord.Subject.SubjectName == SelectedSubject.SubjectName); foreach (var r in records) { JournalRecord journalRecord = JournalRecords.FirstOrDefault(j => j.Student.StudentId == r.StudentId); if (journalRecord == null) { journalRecord = new JournalRecord(); journalRecord.Student = r.Student; //Заполнить статусы пустыми занчениями journalRecord.Statuses = new List <StudentStatusOnLesson> (Enumerable.Repeat <StudentStatusOnLesson>(null, 6)); } //Добавить статус в нужную ячейку journalRecord.Statuses.Insert(r.ScheduleRecord.DayOfWeek - 1, r); JournalRecords.Add(journalRecord); } } }
private void journalRecordsButton_Click(object sender, EventArgs e) { JournalRecord journal = new JournalRecord(user, status); journal.Show(); this.Hide(); }
public BORecordJournalEntry(Accountant accountant, JournalRecord data, BOContext context) : base(accountant, context) { mObjectID = BOType.BORecordJournalEntry; mDataProxy = data.Clone() as JournalRecord; mDataSource = data; }
private IEnumerable <JournalRecord> GetJournalRecords() { var journalRecords = new List <JournalRecord>(); using (var connection = new NpgsqlConnection(_provider.Settings.ConnectionString)) using (var command = connection.CreateCommand()) { connection.Open(); command.CommandText = string.Format( "SELECT id, written FROM {0} ORDER BY id ASC;", _provider.Settings.Table); using (var reader = command.ExecuteReader()) { while (reader.Read()) { var journalRecord = new JournalRecord((long)reader[0], (DateTime)reader[1], null); journalRecords.Add(journalRecord); } } } return(journalRecords); }
public IEnumerable <JournalRecord> GetRecords(long fromRecord = 0) { var endStreamCut = GetEndStreamCut(); _lastEventReadHandler.Invoke(endStreamCut); var request = new ReadEventsRequest { Scope = _scope, Stream = _stream, ToStreamCut = endStreamCut }; var recordNumber = 0; using var call = _client.ReadEvents(request, cancellationToken: _cancellationToken); var responseStream = call.ResponseStream; while (responseStream.MoveNext(_cancellationToken).GetAwaiter().GetResult()) { if (recordNumber <= fromRecord) { continue; } var @event = responseStream.Current; var bytes = @event.Event.ToByteArray(); var savedRecord = (JournalRecord)_serializer.Deserialize(bytes); var record = new JournalRecord(recordNumber++, savedRecord.Written, savedRecord.Command); yield return(record); } }
public static void SetDeviceCatogoryAndDevieUID(JournalRecord journalRecord) { Guid deviceDatabaseUID = Guid.Empty; Guid.TryParse(journalRecord.DeviceDatabaseId, out deviceDatabaseUID); journalRecord.DeviceDatabaseUID = deviceDatabaseUID; Guid panelDatabaseUID = Guid.Empty; Guid.TryParse(journalRecord.PanelDatabaseId, out panelDatabaseUID); journalRecord.PanelDatabaseUID = panelDatabaseUID; Device device = null; if (ConfigurationCash.DeviceConfiguration.Devices != null) { if (journalRecord.DeviceDatabaseUID != Guid.Empty) { device = ConfigurationCash.DeviceConfiguration.Devices.FirstOrDefault(x => x.UID == journalRecord.DeviceDatabaseUID); } else { device = ConfigurationCash.DeviceConfiguration.Devices.FirstOrDefault(x => x.UID == journalRecord.PanelDatabaseUID); } } if (device != null) { journalRecord.DeviceCategory = (int)device.Driver.Category; } else { journalRecord.DeviceCategory = (int)DeviceCategoryType.None; } }
public IJournalSubscription Subscribe(long @from, Action <JournalRecord> handler) { async Task MessageReceived(IStreamSubscription subscription, StreamMessage message, CancellationToken cancellationToken) { var command = (Command)_serializer.FromString(await message.GetJsonData()); var journalRecord = new JournalRecord(message.StreamVersion, message.CreatedUtc, command); handler.Invoke(journalRecord); } // pass null to subscribe from the beginning //or the version of the previous record int?version = null; if (from > 0) { version = (int)from - 1; } bool caughtUp = false; var sub = _streamStore.SubscribeToStream( _streamId, version, MessageReceived, SubscriptionDropped, hasCaughtUp => caughtUp = hasCaughtUp); sub.MaxCountPerRead = 100; return(new SqlStreamStoreSubscription(sub, () => caughtUp)); }
bool FilterRecord(JournalRecord journalRecord) { if (JournalFilter.Categories.IsNotNullOrEmpty()) { Device device = null; if (string.IsNullOrWhiteSpace(journalRecord.DeviceDatabaseId) == false) { device = FiresecManager.Devices.FirstOrDefault(x => x.DatabaseId == journalRecord.DeviceDatabaseId); } else { device = FiresecManager.Devices.FirstOrDefault(x => x.DatabaseId == journalRecord.PanelDatabaseId); } if (device != null) { if (JournalFilter.Categories.Any(daviceCategory => daviceCategory == device.Driver.Category) == false) return false; } } if (JournalFilter.StateTypes.IsNotNullOrEmpty()) { if (JournalFilter.StateTypes.Any(x => x == journalRecord.StateType) == false) return false; } return true; }
public JournalRecord CreateRecord(DateTime entryDate, int memberId, int commissionId, int roleId) { var journalRecordRepository = RepositoryFactory.GetJournalRecordRepository(); var record = new JournalRecord { EntryDate = entryDate, MemberId = memberId, CommissionId = commissionId, RoleCommissionId = roleId }; journalRecordRepository.Create(record); try { UnitOfWork.PreSave(); } catch (Exception ex) { throw new JournalServiceException(ex); } return(record); }
public static bool AddJournalRecord(JournalRecord journalRecord) { try { using (var dataContext = ConnectionManager.CreateFiresecDataContext()) { var query = "SELECT * FROM Journal WHERE " + "\n SystemTime = '" + journalRecord.SystemTime.ToString("yyyy-MM-dd HH:mm:ss") + "'" + "\n AND OldId = " + journalRecord.OldId.ToString(); var result = dataContext.ExecuteQuery<JournalRecord>(query); if (result.Count() == 0) { dataContext.JournalRecords.InsertOnSubmit(journalRecord); dataContext.SubmitChanges(); return true; } } } catch (Exception e) { Logger.Error(e, "Исключение при вызове DatabaseHelper.AddJournalRecord"); } return false; }
public void HappyPath() { _typeMap["MyCommand"] = typeof(MyCommand); var command = new MyCommand("the data"); var now = DateTimeOffset.Now; var journalRecord = new JournalRecord(32, now, command); var stream = new MemoryStream(); _target.WriteObject(stream, journalRecord); stream.Position = 0; var line = new StreamReader(stream).ReadLine(); Console.WriteLine(line); Assert.AreEqual("32 " + now.ToString("o") + " " + command.Id + " MyCommand the data", line); stream.Position = 0; var clone = (JournalRecord)_target.ReadObject(stream); Assert.AreEqual(32, clone.RecordNumber); Assert.AreEqual(now, clone.Written); Assert.AreEqual(command.Id, clone.Command.Id); var clonedCommand = (MyCommand)clone.Command; Assert.AreEqual(command.Id, clonedCommand.Id); Assert.AreEqual(command.MyParameter, clonedCommand.MyParameter); }
static void SetDeviceCatogory(JournalRecord journalRecord) { Device device = null; if (ConfigurationCash.DeviceConfiguration.Devices != null) { if (string.IsNullOrWhiteSpace(journalRecord.DeviceDatabaseId) == false) { device = ConfigurationCash.DeviceConfiguration.Devices.FirstOrDefault( x => x.DatabaseId == journalRecord.DeviceDatabaseId); } else { device = ConfigurationCash.DeviceConfiguration.Devices.FirstOrDefault( x => x.DatabaseId == journalRecord.PanelDatabaseId); } } if (device != null) { journalRecord.DeviceCategory = (int)device.Driver.Category; } else { journalRecord.DeviceCategory = (int)DeviceCategoryType.None; } }
public void Execute(object parameter) { JournalRecord newRecord = new JournalRecord() { Date = StoredDate, Shift = StoredShift, WorkArea = StoredWorkArea }; _uncheckedRecord.Model = newRecord; _uncheckedRecord.IsNewRecord = true; }
void OnNewJournalItemEvent(JournalRecord journalRecord) { if (journalRecord.DeviceDatabaseId != null) { SendEvent(journalRecord, journalRecord.DeviceDatabaseId); } if (journalRecord.PanelDatabaseId != null) { SendEvent(journalRecord, journalRecord.PanelDatabaseId); } }
private void SendMatchingEvents(JournalRecord journalRecord, bool isLocal, IEnumerable <Event> events) { var matchingEvents = events .Where(e => _subscriptions.Values.Any(matcher => matcher.IsMatch(e))) .ToArray(); if (matchingEvents.Length > 0) { _logger.LogTrace("Sending {0} events", matchingEvents.Length); OnMessage.Invoke(new EventsRaised(matchingEvents)); } }
void SendEvent(JournalRecord journalRecord, string dataBaseId) { var device = FiresecManager.Devices.FirstOrDefault(x => x.DatabaseId == dataBaseId); if (device != null) { var assadDevice = Configuration.Devices.FirstOrDefault(x => x.Id == device.PathId); if (assadDevice != null) { string eventName = journalRecord.StateType.ToDescription(); assadDevice.FireEvent(eventName); } } }
public void UpdateRecord(JournalRecord record) { var journalRecordRepository = RepositoryFactory.GetJournalRecordRepository(); try { journalRecordRepository.Update(record); } catch (RepositoryException ex) { throw new JournalServiceException(ex); } }
public JournalRecordViewModel(JournalRecord journalRecord) { ShowPlanCommand = new RelayCommand(OnShowPlan, CanShowPlan); ShowTreeCommand = new RelayCommand(OnShowTree, CanShowTree); ShowZoneCommand = new RelayCommand(OnShowZone, CanShowZone); JournalRecord = journalRecord; if (string.IsNullOrWhiteSpace(journalRecord.DeviceDatabaseId) == false) _device = FiresecManager.Devices.FirstOrDefault(x => x.DatabaseId == journalRecord.DeviceDatabaseId); else _device = FiresecManager.Devices.FirstOrDefault(x => x.DatabaseId == journalRecord.PanelDatabaseId); }
private async Task Run() { var recordNumber = 0; while (await _reader.MoveNext(_cts.Token)) { var eventsResponse = _reader.Current; var bytes = eventsResponse.Event.ToByteArray(); var savedRecord = (JournalRecord)_serializer.Deserialize(bytes); var record = new JournalRecord(recordNumber++, savedRecord.Written, savedRecord.Command); _handler.Invoke(record); } }
public async Task AddAsync_Success() { var journalRecord = new JournalRecord { AppliedAt = DateTime.Now, ScriptName = "Test", Version = 3 }; await _journalRepository.AddAsync(journalRecord); var lastVersion = await _journalRepository.GetLastScriptAsync(); Assert.Equal(journalRecord.Version, lastVersion.Version); }
public IEnumerable <JournalRecord> GetRecords(long fromRecord = 0) { using (var queue = new BlockingCollection <JournalRecord>()) { async Task MessageReceived(IStreamSubscription subscription, StreamMessage message, CancellationToken cancellationToken) { var json = await message.GetJsonData(cancellationToken); var command = (Command)_serializer.FromString(json); var journalRecord = new JournalRecord(message.StreamVersion, message.CreatedUtc, command); queue.Add(journalRecord); } // pass null to subscribe from the beginning //or the version of the previous record int?version = null; if (fromRecord > 0) { version = (int)fromRecord - 1; } var caughtUp = false; using ( var sub = _streamStore.SubscribeToStream( _streamId, version, MessageReceived, SubscriptionDropped, hasCaughtUp => caughtUp = hasCaughtUp)) { sub.MaxCountPerRead = 100; while (!caughtUp || queue.Any()) { if (queue.TryTake(out var journalRecord)) { yield return(journalRecord); } else if (!caughtUp) { Thread.Sleep(100); } } } } }
public void Save(JournalRecord oldRecord, JournalRecord newRecord) { var entity = _ctx.JournalRecords.Single(jr => jr.Id == oldRecord.Id); entity.Date = newRecord.Date; entity.DefectoscopeName = newRecord.DefectoscopeName; entity.Description = newRecord.Description; entity.Employee = newRecord.Employee; entity.End = newRecord.End; entity.OperationName = newRecord.OperationName; entity.ShiftValue = newRecord.ShiftValue; entity.Start = newRecord.Start; entity.WorkArea = newRecord.WorkArea; _ctx.SaveChanges(); }
public void CompareTest3() { var comparer = new JournalRecordsBeginTimeComparer(); var today = new DateTime().AddDays(1); var journalRecordForTodayStartedShift = new JournalRecord { Date = today, Start = TimeSpan.FromHours(9) }; var journalRecordForTodayStartedShiftToo = new JournalRecord { Date = today, Start = TimeSpan.FromHours(7) }; var actual = comparer.Compare(journalRecordForTodayStartedShift, journalRecordForTodayStartedShiftToo); Assert.IsTrue(actual < 0); actual = comparer.Compare(journalRecordForTodayStartedShiftToo, journalRecordForTodayStartedShift); Assert.IsTrue(actual > 0); }
public async Task PostTest() { // Arrange await using (ApplicationContext context = _contextFactory.CreateDbContext()) { await context.Lecturers.AddAsync(new Lecturer { FullName = "Test Lecturer" }); await context.SaveChangesAsync(); await context.Courses.AddRangeAsync( new Course { Name = "Test Course 1", LecturerId = 1 }, new Course { Name = "Test Course 2", LecturerId = 1 }); await context.SaveChangesAsync(); await context.Lectures.AddRangeAsync( new Lecture { Name = "Test Lecture 1 1", CourseId = 1 }, new Lecture { Name = "Test Lecture 2 1", CourseId = 1 }, new Lecture { Name = "Test Lecture 3 1", CourseId = 1 }, new Lecture { Name = "Test Lecture 1 2", CourseId = 2 }, new Lecture { Name = "Test Lecture 2 2", CourseId = 2 }, new Lecture { Name = "Test Lecture 3 2", CourseId = 2 }); await context.SaveChangesAsync(); await context.Students.AddRangeAsync( new Student { FullName = "Test Student 1" }, new Student { FullName = "Test Student 2" }); await context.SaveChangesAsync(); } // Act var model = new JournalRecordModel(true, 5, 1, 1); var response = await _client.PostAsJsonAsync("/Journal", model); // Assert response.EnsureSuccessStatusCode(); await using (ApplicationContext context = _contextFactory.CreateDbContext()) { JournalRecord record = await context.JournalRecords.FirstAsync(); Assert.That(record, Is.EqualTo(new JournalRecord { Id = 1, Attendance = true, Score = 5, StudentId = 1, LectureId = 1 })); } }
private async Task <IncomingRequests> PrepareIncoming() { bool isManager = await _userManager.IsInRoleAsync(User, "manager"); bool isDirector = await _userManager.IsInRoleAsync(User, "director"); IncomingRequests model = new IncomingRequests(); List <Request> Requests = null; using (RequestManager rm = new RequestManager()) { model.IncomingCount = rm.GetIncomingRequestsCount(); if (isDirector || isManager) { Requests = rm.GetRequests(); } else { var user = await _userManager.GetUserAsync(User); Requests = rm.GetUserRequests(user.Id); } } // foreach (var request in Requests) { var record = new JournalRecord(); if (!string.IsNullOrEmpty(request.UserId)) { record.UserName = _userManager.FindById(request.UserId).UserName; } record.Id = request.Id; record.IncomingIdentifier = request.IncomingIdentifier; record.LastState = request.State; record.RegisterTime = request.JournalRecords.First(jr => jr.State == RequestState.Registered).StateChanged; record.StartTime = request.JournalRecords.FirstOrDefault(jr => jr.State == RequestState.Assigned)?.StateChanged; record.EndTime = request.JournalRecords.OrderBy(jr => jr.Id).FirstOrDefault(jr => jr.State == RequestState.Aborted || jr.State == RequestState.Error || jr.State == RequestState.Finalized)?.StateChanged; // model.Records.Add(record); } return(model); }
public void Seed(DumaContext context) { //TODO: First variables. var member = new Member { Name = "Lesha", Surname = "Yurchak", Patronymic = "Vladimirovich", PassportData = "MP" }; context.Members.Add(member); context.SaveChanges(); var commission = new Commission { Name = "Hello", President = member }; context.Commissions.Add(commission); var roleCom = new RoleCommission { Value = "Commandor" }; context.RoleCommissions.Add(roleCom); context.SaveChanges(); commission.Consist.Add(member); var record = new JournalRecord { EntryDate = DateTime.Now, ExitDate = DateTime.Now.AddDays(3), Member = member, Commission = commission, Role = roleCom }; commission.JournalRecords.Add(record); context.SaveChanges(); }
public static void AddInfoMessage(string userName, string mesage) { var journalRecord = new JournalRecord() { DeviceTime = DateTime.Now, SystemTime = DateTime.Now, StateType = StateType.Info, Description = mesage, User = userName, DeviceDatabaseId = "", DeviceName = "", PanelDatabaseId = "", PanelName = "", ZoneName = "" }; AddJournalRecord(journalRecord); ClientsCash.OnNewJournalRecord(journalRecord); }
public async Task <JournalRecord> StoreAsync(OperationDescription op, AccountWithAmount rec) { var jr = new JournalRecord { Amount = rec.Amount, Currency = rec.Account.Currency, Id = ObjectId.GenerateNewId().ToString(), Period = op.Period, UserId = rec.Account.UserId, OperationId = op.Id, CreatedOn = DateTime.Now }; await _ms.Journal.InsertOneAsync(jr); _logger.LogInformation( "New Journal Record for {Operation} on {Period} for {Account} with {Amount} of {Currency}", op.Id, op.Period, rec.Account.UserId, rec.Amount, rec.Account.Currency); return(jr); }
protected override void OnCommandBatch(IEnumerable <Command> commands) { foreach (var command in commands) { var record = new JournalRecord(0, DateTimeOffset.Now, command); var bytes = _serializer.Serialize(record); var request = new WriteEventsRequest { Event = ByteString.CopyFrom(bytes), Stream = _stream, Scope = _scope }; _writer.RequestStream.WriteAsync(request).GetAwaiter().GetResult(); } _writer.RequestStream.CompleteAsync().GetAwaiter().GetResult(); }
protected override OpResult _Store(JournalRecord _obj) { if (_obj == null) { return(OpResult.NotifyStoreAction(OpResult.ResultStatus.ObjectIsNull, _obj, "JournalRecord object cannot be created as it is null")); } if (Exists(_obj)) { ExecuteNonQuery(GetQuery_UpdateQuery(_obj)); return(OpResult.NotifyStoreAction(OpResult.ResultStatus.Updated, _obj)); } ExecuteNonQuery(GetQuery_InsertQuery(_obj)); if (_obj.JournalRecordID == null) { _obj.JournalRecordID = DbMgr.GetLastInsertID(); } _obj.FromDb = true; return(OpResult.NotifyStoreAction(OpResult.ResultStatus.Created, _obj)); }
public static JournalRecord Convert(journalType innerJournalRecord) { var journalRecord = new JournalRecord() { OldId = int.Parse(innerJournalRecord.IDEvents), DeviceTime = ConvertTime(innerJournalRecord.Dt), SystemTime = ConvertTime(innerJournalRecord.SysDt), ZoneName = innerJournalRecord.ZoneName, Description = innerJournalRecord.EventDesc, DeviceName = innerJournalRecord.CLC_Device, PanelName = innerJournalRecord.CLC_DeviceSource, DeviceDatabaseId = innerJournalRecord.IDDevices, PanelDatabaseId = innerJournalRecord.IDDevicesSource, User = innerJournalRecord.UserInfo, Detalization = innerJournalRecord.CLC_Detalization, SubsystemType = EnumsConverter.StringToSubsystemType(innerJournalRecord.IDSubSystem), StateType = (StateType)int.Parse(innerJournalRecord.IDTypeEvents), }; SetDeviceCatogory(journalRecord); return journalRecord; }
void OnNewJournalRecord(JournalRecord journalRecord) { if (IsAutoActivation) { if ((App.Current.MainWindow != null) && (App.Current.MainWindow.IsActive == false)) { App.Current.MainWindow.WindowState = System.Windows.WindowState.Maximized; App.Current.MainWindow.Activate(); } } if (IsPlansAutoActivation) { if (string.IsNullOrWhiteSpace(journalRecord.DeviceDatabaseId) == false) { var globalStateType = StateType.No; foreach (var deviceState in FiresecManager.DeviceStates.DeviceStates) { if (deviceState.StateType < globalStateType) globalStateType = deviceState.StateType; } var device = FiresecManager.Devices.FirstOrDefault(x => x.DatabaseId == journalRecord.DeviceDatabaseId); if (device != null) { var deviceState = FiresecManager.DeviceStates.DeviceStates.FirstOrDefault(x => x.UID == device.UID); //if (deviceState.StateType <= globalStateType) { var existsOnPlan = FiresecManager.PlansConfiguration.AllPlans.Any(x => { return x.ElementDevices.Any(y => y.DeviceUID == device.UID); }); if (existsOnPlan) { ServiceFactory.Events.GetEvent<ShowDeviceOnPlanEvent>().Publish(device.UID); } } } } } }
private void HandleNotification(object sender, NpgsqlNotificationEventArgs arguments) { var serializer = _memstateSettings.CreateSerializer(); try { var row = JsonConvert.DeserializeObject <Row>(arguments.AdditionalInformation); var command = (Command)serializer.Deserialize(row.Command); var record = new JournalRecord(row.Id, row.Written, command); if (_ready) { _handler(record); } else { lock (Lock) { if (_ready) { _handler(record); } else { _buffer.Enqueue(record); } } } } catch (Exception exception) { _log.LogError(exception, $"Exception occured in {GetType().Name}.HandleNotification"); } }
public JournalRecordViewModel(JournalRecord journalRecord) { ShowOnPlanCommand = new RelayCommand(OnShowOnPlan, CanShowOnPlan); ShowTreeCommand = new RelayCommand(OnShowTree, CanShowTree); ShowZoneCommand = new RelayCommand(OnShowZone, CanShowZone); DeviceTime = journalRecord.DeviceTime; SystemTime = journalRecord.SystemTime; ZoneName = journalRecord.ZoneName; Description = journalRecord.Description; DeviceName = journalRecord.DeviceName; PanelName = journalRecord.PanelName; User = journalRecord.User; SubsystemType = journalRecord.SubsystemType; StateType = journalRecord.StateType; Detalization = GetDetalization(journalRecord.Detalization); if (journalRecord.DeviceDatabaseUID != Guid.Empty) Device = ConfigurationCash.DeviceConfiguration.Devices.FirstOrDefault(x => x.UID == journalRecord.DeviceDatabaseUID); else Device = ConfigurationCash.DeviceConfiguration.Devices.FirstOrDefault(x => x.UID == journalRecord.PanelDatabaseUID); Zone = FiresecManager.Zones.FirstOrDefault(x => x.FullPresentationName == journalRecord.ZoneName); }
void AddJournalItem(JournalRecord journalRecord) { var value = count.ToString() + "\t" + DateTime.Now.TimeOfDay.ToString() + "\t" + journalRecord.SystemTime.ToString() + "\t" + journalRecord.Description; JournalItems.Insert(0, value); count++; }
public IResult Show(JournalRecord record) { return(new SelectResult(record.Filename)); }
public IResult Open(JournalRecord record) { return(new OpenResult(record.Filename)); }
//void OnNewFS2JournalItemsEvent(List<FS2JournalItem> journalItems) //{ // Dispatcher.BeginInvoke(new Action(() => // { // foreach (var journalItem in journalItems) // { // if (FilterFS2JournalItem(journalItem) == false) // return; // if (JournalRecords.Count > 0) // JournalRecords.Insert(0, new JournalRecordViewModel(journalItem)); // else // JournalRecords.Add(new JournalRecordViewModel(journalItem)); // if (JournalRecords.Count > JournalFilter.LastRecordsCount) // JournalRecords.RemoveAt(JournalFilter.LastRecordsCount); // } // })); //} bool FilterJournalRecord(JournalRecord journalRecord) { if (JournalFilter.Categories.IsNotNullOrEmpty()) { Device device = null; if (journalRecord.DeviceDatabaseUID != Guid.Empty) { device = FiresecManager.Devices.FirstOrDefault(x => x.UID == journalRecord.DeviceDatabaseUID); } else { device = FiresecManager.Devices.FirstOrDefault(x => x.UID == journalRecord.PanelDatabaseUID); } if (device != null) { if (JournalFilter.Categories.Any(daviceCategory => daviceCategory == device.Driver.Category) == false) return false; } } if (JournalFilter.StateTypes.IsNotNullOrEmpty()) { if (JournalFilter.StateTypes.Any(x => x == journalRecord.StateType) == false) return false; } return true; }
public ConfirmationViewModel(JournalRecord journalRecord) { Title = "Подтверждение критических событий"; ConfirmCommand = new RelayCommand(OnConfirm); JournalRecord = new JournalRecordViewModel(journalRecord); }
void OnNewJournalRecord(JournalRecord journalItem) { if (_journalItem == null || !_journalItem.IsSelected) ++UnreadJournalCount; }
void OnNewJournalRecord(JournalRecord journalRecord) { Dispatcher.CurrentDispatcher.Invoke(new Action(() => { JournalRecords.Add(journalRecord); })); OnPropertyChanged("JournalRecords"); }
public void Remove(JournalRecord model) { _ctx.JournalRecords.Remove(model); _ctx.SaveChanges(); }
public JournalRecordViewModel(JournalRecord jr) { this._jr = jr; }
void OnNewJournalRecord(JournalRecord journalRecord) { journalRecord.Time3 = DateTime.Now.TimeOfDay; if (FilterRecord(journalRecord) == false) return; if (JournalRecords.Count > 0) JournalRecords.Insert(0, new JournalRecordViewModel(journalRecord)); else JournalRecords.Add(new JournalRecordViewModel(journalRecord)); if (JournalRecords.Count > JournalFilter.LastRecordsCount) JournalRecords.RemoveAt(JournalFilter.LastRecordsCount); }
partial void DeleteJournal(JournalRecord instance);
partial void UpdateJournal(JournalRecord instance);
partial void InsertJournal(JournalRecord instance);
static void OnNewJournalRecordEvent(JournalRecord journalRecord) { ServiceFactory.Events.GetEvent<NewJournalRecordEvent>().Publish(journalRecord); }
public void AddJournalRecord(JournalRecord journalRecord) { SafeOperationCall(() => { FiresecService.AddJournalRecord(journalRecord); }); }
static JournalRecord ReadOneJournalRecord(SqlCeDataReader reader) { var journalRecord = new JournalRecord(); if (!reader.IsDBNull(reader.GetOrdinal("Description"))) journalRecord.Description = reader.GetString(reader.GetOrdinal("Description")); if (!reader.IsDBNull(reader.GetOrdinal("Detalization"))) journalRecord.Detalization = reader.GetString(reader.GetOrdinal("Detalization")); if (!reader.IsDBNull(reader.GetOrdinal("DeviceCategory"))) journalRecord.DeviceCategory = reader.GetInt32(reader.GetOrdinal("DeviceCategory")); if (!reader.IsDBNull(reader.GetOrdinal("DeviceDatabaseId"))) journalRecord.DeviceDatabaseId = reader.GetString(reader.GetOrdinal("DeviceDatabaseId")); if (!reader.IsDBNull(reader.GetOrdinal("DeviceName"))) journalRecord.DeviceName = reader.GetString(reader.GetOrdinal("DeviceName")); if (!reader.IsDBNull(reader.GetOrdinal("DeviceTime"))) journalRecord.DeviceTime = reader.GetDateTime(reader.GetOrdinal("DeviceTime")); if (!reader.IsDBNull(reader.GetOrdinal("OldId"))) journalRecord.OldId = reader.GetInt32(reader.GetOrdinal("OldId")); if (!reader.IsDBNull(reader.GetOrdinal("PanelDatabaseId"))) journalRecord.PanelDatabaseId = reader.GetString(reader.GetOrdinal("PanelDatabaseId")); if (!reader.IsDBNull(reader.GetOrdinal("PanelName"))) journalRecord.PanelName = reader.GetString(reader.GetOrdinal("PanelName")); if (!reader.IsDBNull(reader.GetOrdinal("StateType"))) journalRecord.StateType = (StateType)reader.GetInt32(reader.GetOrdinal("StateType")); if (!reader.IsDBNull(reader.GetOrdinal("SubsystemType"))) journalRecord.SubsystemType = (SubsystemType)reader.GetInt32(reader.GetOrdinal("SubsystemType")); if (!reader.IsDBNull(reader.GetOrdinal("SystemTime"))) journalRecord.SystemTime = reader.GetDateTime(reader.GetOrdinal("SystemTime")); if (!reader.IsDBNull(reader.GetOrdinal("UserName"))) journalRecord.User = reader.GetString(reader.GetOrdinal("UserName")); if (!reader.IsDBNull(reader.GetOrdinal("ZoneName"))) journalRecord.ZoneName = reader.GetString(reader.GetOrdinal("ZoneName")); if (!reader.IsDBNull(reader.GetOrdinal("Id"))) journalRecord.No = reader.GetInt32(reader.GetOrdinal("Id")); return journalRecord; }
void OnNewJournalRecord(JournalRecord journalRecord) { JournalRecords.Add(journalRecord); }
public void Add(JournalRecord newRecord) { _ctx.JournalRecords.Add(newRecord); _ctx.SaveChanges(); }
private DbInsertStatement GetQuery_InsertQuery(JournalRecord _obj) { Dictionary <string, DbFieldEntry> fields = GetFields(_obj); return(DbMgr.CreateInsertClause("JournalRecords", fields)); }
void AddInfoMessage(string userName, string mesage) { var journalRecord = new JournalRecord() { DeviceTime = DateTime.Now, SystemTime = DateTime.Now, StateType = StateType.Info, Description = mesage, User = userName, DeviceDatabaseId = "", DeviceName = "", PanelDatabaseId = "", PanelName = "", ZoneName = "" }; FiresecDB.DatabaseHelper.AddJournalRecords(new List<JournalRecord>() { journalRecord }); NotifyNewJournal(new List<JournalRecord>() { journalRecord }); //try //{ // var journalItem = new FS2JournalItem() // { // DeviceTime = DateTime.Now, // SystemTime = DateTime.Now, // StateType = StateType.Info, // Description = mesage, // UserName = userName, // DeviceName = "", // PanelName = "", // ZoneName = "" // }; // ServerFS2Database.AddJournalItems(new List<FS2JournalItem>() { journalItem }); //} //catch //{ // Logger.Error("FiresecService.AddInfoMessage.FS2JournalItem"); //} }
private DbUpdateStatement GetQuery_UpdateQuery(JournalRecord _obj) { return(DbMgr.CreateUpdateClause("JournalRecords", GetFields(_obj), "JournalRecordID", _obj.JournalRecordID)); }