void Should_generate_id_with_correct_format() { string id = "date_20170808"; var generatedId = AppUsageRecord.GetGeneratedId(new DateTime(2017, 8, 8)); Assert.Equal(id, generatedId); }
public async Task <IActionResult> Get(DateTime date) { var appUsage = await _repository.GetAsync(AppUsageRecord.GetGeneratedId(date)); var processInfoCollection = Mapper.Map <IEnumerable <ProcessInfo>, IEnumerable <ProcessInfoDto> >(appUsage.ActiveApps.Select(c => c.Value)); return(Ok(processInfoCollection)); }
private void PersistentRecords(object state) { Debug.WriteLine($"{nameof(PersistentRecords)} is running on thread id={Thread.CurrentThread.ManagedThreadId}"); if (_isIdle) { return; } if (_mainRepositoryUnavailable) { var result = TryGetFromMainRepository(); if (result.Item2 == false) { BackupLocally(); return; } else { _mainRepositoryUnavailable = false; if (result.Item1 != null) { _bufferedTodayAppRecord.MergeWith(result.Item1); _backupRepository.Delete(_bufferedTodayAppRecord.Id); } } } try { var todayPersistentRecord = _repository.Get(AppUsageRecord.GetGeneratedId(DateTime.Now)); if (todayPersistentRecord != null) { todayPersistentRecord.ActiveApps = _bufferedTodayAppRecord.ActiveApps; _repository.Update(todayPersistentRecord, todayPersistentRecord.Id); } else { _repository.Add(_bufferedTodayAppRecord); } } catch (Exception ex) { Debug.WriteLine($"Error when persisting data: {ex.Message}"); LoggingService.LogException(ex); _mainRepositoryUnavailable = true; this.PersistentRecords(state); } Debug.WriteLine("Persisting data sucessfully"); }
void Should_instantiate_with_correct_properties() { var date = new DateTime(2018, 1, 1); var id = "date_20180101"; var record = new AppUsageRecord(date); Assert.Equal(record.Date, date); Assert.Equal(record.Id, id); Assert.True(record.ActiveApps.Count == 0); }
public void Update(AppUsageRecord record) { var store = DocumentStoreHolder.RavenStore; if (store.WasDisposed) { return; } using (var session = store.OpenSession()) { store.DatabaseCommands.Put(record.Id, null, RavenJObject.FromObject(record), new RavenJObject()); session.SaveChanges(); } }
public async Task <IActionResult> GetPredictedForDate(DateTime date) { var appUsage = await _appUsageRecordRepository.GetAsync(AppUsageRecord.GetGeneratedId(date)); var processInfoCollection = appUsage.ActiveApps.Select(pair => pair.Value).ToArray(); var dtos = Mapper.Map <ProcessInfoLabeledItemDto[]>(processInfoCollection); var results = _predictKarmaService.Predict(processInfoCollection); dtos.Merge(results, (dto, category) => { dto.Category = category; }); return(Ok(dtos)); }
public void Add(AppUsageRecord record) { var store = DocumentStoreHolder.RavenStore; if (store.WasDisposed) { return; } using (var session = store.OpenSession()) { session.Store(record, record.Id); session.SaveChanges(); } }
private void MonitorUserActiveProcess(object state) { if (DateTime.Now.Date != _bufferedTodayAppRecord.Date) { _bufferedTodayAppRecord = new AppUsageRecord(DateTime.Now); } if (this._isIdle = IsUserIdle()) { return; } var activeProcess = ProcessUtils.GetActiveProcess(); if (activeProcess != null) { var processInfoId = ProcessInfoFactory.CreateId(activeProcess); var activeApps = _bufferedTodayAppRecord.ActiveApps; ProcessInfo processInfo = null; if (!string.IsNullOrWhiteSpace(processInfoId) && activeApps.ContainsKey(processInfoId)) { processInfo = activeApps[processInfoId]; processInfo.TotalAmountOfTime += TimeSpan.FromSeconds(Settings.MonitorInterval); } else { processInfo = ProcessInfoFactory.Create(activeProcess, Settings.MonitorInterval); activeApps.Add(processInfo.Id, processInfo); } if (_currentProcessId != processInfoId) { if (!string.IsNullOrEmpty(_currentProcessId)) { var oldProcessInfo = activeApps[_currentProcessId]; oldProcessInfo.EndCurrentSession(DateTime.Now.TimeOfDay); } processInfo.StartNewSession(DateTime.Now.TimeOfDay); } _currentProcessId = processInfoId; } }
private Tuple <AppUsageRecord, bool> TryGetFromMainRepository() { AppUsageRecord appRecord = null; try { appRecord = _repository.Get(AppUsageRecord.GetGeneratedId(DateTime.Now)); } catch (Exception ex) { Debug.WriteLine(ex); return(new Tuple <AppUsageRecord, bool>(null, false)); } return(new Tuple <AppUsageRecord, bool>(appRecord, true)); }
public void Update(AppUsageRecord entity, object id) { string savesDir = savesFolderPath; if (!Directory.Exists(savesDir)) { Directory.CreateDirectory(savesDir); } string fileName = Path.Combine(savesDir, (string)id + ".bin"); using (var saveFileStream = File.OpenWrite(fileName)) { BinaryFormatter serializer = new BinaryFormatter(); serializer.Serialize(saveFileStream, entity); Debug.WriteLine("Backing up locally successfully"); } }
public AppUsageRecord Get(object id) { var path = Path.Combine(savesFolderPath, (string)id + ".bin"); if (File.Exists(path)) { Debug.WriteLine("Reading local backup"); using (var openFileStream = File.OpenRead(path)) { BinaryFormatter deserializer = new BinaryFormatter(); AppUsageRecord backup = (AppUsageRecord)deserializer.Deserialize(openFileStream); return(backup); } } return(null); }
void BufferPersistentRecords_should_return_from_main_repository() { var mockMainRepository = new Mock <IAppUsageRecordRepository>(); var mockBackupRepository = new Mock <IAppUsageRecordRepository>(); TrackingUserApplicationService _service = new TrackingUserApplicationService(mockMainRepository.Object, mockBackupRepository.Object); var appUsageRecord = new AppUsageRecord(DateTime.Now); mockMainRepository.Setup(r => r.Get(AppUsageRecord.GetGeneratedId(DateTime.Now))).Returns(appUsageRecord); mockBackupRepository.Setup(r => r.Get(AppUsageRecord.GetGeneratedId(DateTime.Now))).Returns <AppUsageRecord>(null); _service.BufferPersistentRecords(); var bufferedRecord = _service.GetBufferedRecord(); Assert.Equal(appUsageRecord.Id, bufferedRecord.Id); Assert.Equal(appUsageRecord.Date, bufferedRecord.Date); Assert.Equal(appUsageRecord.ActiveApps, bufferedRecord.ActiveApps); }
void Should_merge_with_other_record_correctly() { var record1 = new AppUsageRecord(new DateTime(2018, 1, 1)); record1.ActiveApps.Add(new KeyValuePair <string, ProcessInfo>("key1", new ProcessInfo("key1") { TotalAmountOfTime = TimeSpan.FromSeconds(1) })); var record2 = new AppUsageRecord(new DateTime(2018, 1, 1)); record2.ActiveApps.Add(new KeyValuePair <string, ProcessInfo>("key2", new ProcessInfo("key2") { TotalAmountOfTime = TimeSpan.FromSeconds(2) })); record1.MergeWith(record2); Assert.Equal("key2", record1.ActiveApps["key2"].Id); Assert.Equal(TimeSpan.FromSeconds(2), record1.ActiveApps["key2"].TotalAmountOfTime); }
public void BufferPersistentRecords() { var todayRecordId = AppUsageRecord.GetGeneratedId(DateTime.Now); try { _bufferedTodayAppRecord = _repository.Get(todayRecordId); var backupRecord = _backupRepository.Get(todayRecordId); if (_bufferedTodayAppRecord == null) { _bufferedTodayAppRecord = new AppUsageRecord(DateTime.Now); } if (backupRecord != null) { _bufferedTodayAppRecord.MergeWith(backupRecord); _backupRepository.Delete(todayRecordId); } } catch (TimeoutException ex) { Debug.WriteLine(ex.Message); _mainRepositoryUnavailable = true; var backupRecord = _backupRepository.Get(todayRecordId); if (backupRecord == null) { _bufferedTodayAppRecord = new AppUsageRecord(DateTime.Now); } else { _bufferedTodayAppRecord = backupRecord; } } }
private static void TrainingRecordData() { var mongoClient = new MongoClient("mongodb://*****:*****@"[^a-zA-Z]", " ").Trim().ToLowerInvariant().Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries).Where(d => d.Count() < 20).ToArray(); var trainingDataCollection = database.GetCollection <ProcessInfoLabeledItem>("training_data"); var records = trainingDataCollection.Find(Builders <ProcessInfoLabeledItem> .Filter.Empty).ToList(); var vocabulary = records.Select(c => c.Title + " " + c.Process).SelectMany(filter).Distinct().OrderBy(str => str).ToList(); List <string> x = records.Select(item => item.Title + " " + item.Process).ToList(); double[] y = records.Select(item => (double)item.Category).ToArray(); var problemBuilder = new TextClassificationProblemBuilder(); problemBuilder.RefineText = filter; var problem = problemBuilder.CreateProblem(x, y, vocabulary.ToList()); const int C = 1; var model = new C_SVC(problem, KernelHelper.LinearKernel(), C); var _predictionDictionary = new Dictionary <Karma, string> { { Karma.Bad, "Bad" }, { Karma.Good, "Good" }, { Karma.Neutral, "Neutral" } }; var newXs = database.GetCollection <AppUsageRecord>("daily_records").Find(Builders <AppUsageRecord> .Filter.Eq(f => f.Id, AppUsageRecord.GetGeneratedId(DateTime.Now))).FirstOrDefault().ActiveApps.Select(c => c.Value).Select(c => c.MainWindowTitle + " " + c.ProcessName); foreach (var _x in newXs) { var newX = TextClassificationProblemBuilder.CreateNode(_x, vocabulary, problemBuilder.RefineText); var predictedY = model.Predict(newX); Console.WriteLine($"For title {_x}"); Console.WriteLine($"The prediction is {_predictionDictionary[(Karma)predictedY]}"); } }
public async Task UpdateAsync(AppUsageRecord entity, object id) { var collection = _mongoDb.GetCollection <AppUsageRecord>(_appSettings.DailyRecordCollectionName); await collection.ReplaceOneAsync(Builders <AppUsageRecord> .Filter.Eq(f => f.Id, (string)id), entity); }
public async Task AddAsync(AppUsageRecord entity) { var collection = _mongoDb.GetCollection <AppUsageRecord>(_appSettings.DailyRecordCollectionName); await collection.InsertOneAsync(entity, null); }
public void Update(AppUsageRecord entity, object id) { var collection = MongoDatabaseHolder.Database.GetCollection <AppUsageRecord>(CollectionName); var result = collection.ReplaceOne(Builders <AppUsageRecord> .Filter.Eq(f => f.Id, (string)id), entity); }
public void Update(AppUsageRecord entity, object id) { throw new System.NotImplementedException(); }
private static async Task Verify() { KarmaPredictor predictor = new KarmaPredictor(); if (!predictor.IsModelTrained()) { return; } predictor.LoadModel(); Func <string, string[]> filter = w => Regex.Replace(w, @"[^a-zA-Z]", " ").Trim().ToLowerInvariant().Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries).Where(d => d.Count() < 20).ToArray(); var client = new MongoClient("mongodb://localhost:27017"); var db = client.GetDatabase("active_app_record"); var trainingCollection = db.GetCollection <AppUsageRecord>("daily_records"); var cursor = await trainingCollection.FindAsync(Builders <AppUsageRecord> .Filter.Eq(f => f.Id, AppUsageRecord.GetGeneratedId(DateTime.Now))); var trainingData = await cursor.FirstOrDefaultAsync(); var processInfos = trainingData.ActiveApps.Select(f => f.Value).ToArray(); var predictions = predictor.Predict(processInfos); for (int i = 0; i < processInfos.Length; i++) { Console.WriteLine($"for window title [{processInfos[i].MainWindowTitle}] result: {predictions[i]}"); } }
public void Add(AppUsageRecord record) { var recordCollection = MongoDatabaseHolder.Database.GetCollection <AppUsageRecord>(CollectionName); recordCollection.InsertOne(record); }