public async Task <StandardResponse> UpdateQuestion(ClaimsPrincipal identity, QuestionUpdateViewModel model, ModelStateDictionary modelState) { if (!modelState.IsValid) { return(modelState.StandardError()); } using (var db = new ServiceDb()) { using (var user = await _userService.Become(db, identity)) { await _questionService.UpdateQuestion(db, user, new UpdateQuestion() { QuestionId = model.QuestionId, RowVersion = model.RowVersion, Body = model.Body, Tags = model.Tags ?? new string[] { }, Title = model.Title, Topic = model.Topic }); await db.SaveChangesAsync(); var question = await _questionService.GetQuestion(db, user, model.QuestionId); return(StandardResponse.For(QuestionViewModel.From(question))); } } }
public async Task <StandardResponse> AskQuestion(ClaimsPrincipal identity, QuestionAddViewModel model, ModelStateDictionary modelState) { if (!modelState.IsValid) { return(modelState.StandardError()); } using (var db = new ServiceDb()) { using (var user = await _userService.Become(db, identity, null)) { var question = await _questionService.CreateQuestion(db, user, new CreateNewQuestion() { Title = model.Title, Body = model.Body, Tags = model.Tags, Topic = model.Topic ?? Topic.DefaultTopic }); await db.SaveChangesAsync(); return(StandardResponse.For(new { question.QuestionId })); } } }
public async Task <StandardResponse> UpdateAnswerMetadata(ClaimsPrincipal identity, AnswerMetadataUpdateViewModel model, ModelStateDictionary modelState) { if (!modelState.IsValid) { return(modelState.StandardError()); } using (var db = new ServiceDb()) { using (var user = await _userService.Become(db, identity, null)) { var metadata = await _answerService.UpdateAnswerMetadata(db, user, new UpdateAnswerMeta() { AnswerId = model.AnswerId, RowVersion = model.RowVersion, Votes = model.Votes, }); await db.SaveChangesAsync(); return(StandardResponse.For(AnswerMetaViewModel.From(metadata))); } } }
private async Task <ITaskState> DoTask(ITaskState taskState, ScheduleMode mode, CancellationToken cancellationToken) { var configuredOn = DateTimeOffset.Now; using (db = dbf.GetWebDbContext <ServiceDb>()) { await db.Database.EnsureCreatedAsync(); //var sm = new ServerManager(); //foreach (var site in sm.Sites) //{ // await AddSiteFolder(configuredOn, site); //} foreach (var fs in options.FolderSources) { await AddFolderSource(configuredOn, fs); } var staleList = await db.SourceFolders .Include(x => x.Backups) .Where(x => x.ConfiguredOn < configuredOn).ToArrayAsync(); foreach (var sf in staleList) { var backups = sf.Backups.ToArray(); db.Backups.RemoveRange(backups); db.SourceFolders.Remove(sf); log.LogInformation($"{sf.DisplayName} {sf.FullPath} (with {backups.Count()} backups) removed"); } await db.SaveChangesAsync(); var count = db.SourceFolders.Count(); log.LogInformation($"found {count} source folders in database"); return(null);// Task.FromResult<ITaskState>(null); } }
public async Task <StandardResponse> UpdateTopic(ClaimsPrincipal identity, TopicUpdateViewModel model, ModelStateDictionary modelState) { if (!modelState.IsValid) { return(modelState.StandardError()); } using (var db = new ServiceDb()) { using (var user = await _userService.Become(db, identity)) { var result = await _topicService.UpdateTopic(db, user, new UpdateTopic() { TopicId = model.TopicId, Description = model.Description, Icon = PangulStringEncoding.GetBytesFromDataUrl(model.Icon), IconType = PangulStringEncoding.GetTypeFromDataUrl(model.Icon), RowVersion = model.RowVersion }); await db.SaveChangesAsync(); return(StandardResponse.For(new { result.TopicId })); } } }
public ActionResult DeleteConfirmed(int id) { ServiceDb serviceDb = db.ServiceDb.Find(id); db.ServiceDb.Remove(serviceDb); db.SaveChanges(); return(RedirectToAction("Index")); }
public void Create(ServiceVm vm) { Service service = new Service(); service.Name = vm.Name; service.CostPerHour = vm.CostPerHour; service.ServiceTypeId = vm.ServiceTypeId; ServiceDb.Create(service); }
public BackupController(IOptionsMonitor <ServiceOptions> options, IHostedService hostedService, ILogger <BackupController> logger, ServiceDb serviceDb, IHostingEnvironment env) : base(env) { this.serviceOptions = options.CurrentValue; options.OnChangeWithDelay((opt) => this.serviceOptions = opt); this.log = logger; this.serviceDb = serviceDb; this.schedulerService = hostedService as SchedulerService; //this.serviceDb.Database.EnsureCreated(); }
public void Edit(ServiceVm vm) { Service service = new Service(); service.Id = vm.Id; service.Name = vm.Name; service.CostPerHour = vm.CostPerHour; service.ServiceTypeId = vm.ServiceTypeId; ServiceDb.Edit(service); }
public ActionResult Edit([Bind(Include = "id,name")] ServiceDb serviceDb) { if (ModelState.IsValid) { db.Entry(serviceDb).State = EntityState.Modified; db.SaveChanges(); return(RedirectToAction("Index")); } return(View(serviceDb)); }
public ActionResult Create([Bind(Include = "id,name")] ServiceDb serviceDb) { if (ModelState.IsValid) { db.ServiceDb.Add(serviceDb); db.SaveChanges(); return(RedirectToAction("Index")); } return(View(serviceDb)); }
// GET: Service/Edit/5 public ActionResult Edit(int id) { var row = ServiceDb.GetServiceById(id).Rows[0]; ServiceVm vm = new ServiceVm(); vm.Id = id; vm.Name = row["Name"].ToString(); vm.CostPerHour = (decimal)row["CostPerHour"]; vm.ServiceTypeId = (int)row["ServiceTypeId"]; vm.ServiceTypes = GetAllServiceTypes(); return(View(vm)); }
// GET: ServiceDbs/Delete/5 public ActionResult Delete(int?id) { if (id == null) { return(new HttpStatusCodeResult(HttpStatusCode.BadRequest)); } ServiceDb serviceDb = db.ServiceDb.Find(id); if (serviceDb == null) { return(HttpNotFound()); } return(View(serviceDb)); }
public SearchImagesService() { _rng = new Random(); _http = new HttpClient(); _http.AddFakeHeaders(); _cache = new SearchImageCacher(); _db = new ServiceDb <SearchImageContext>(SearchImageContext.BaseOptions.Build()); using (var uow = _db.GetDbContext()) { _blacklistedTags = new ConcurrentDictionary <ulong, HashSet <string> >(uow.BlacklistedTags .ToDictionary(x => x.GuildId, x => new HashSet <string>(x.Tags))); } }
private async Task SetupPipeline() { List <IPipelineTask> list = new List <IPipelineTask>(); using (db = dbf.GetWebDbContext <ServiceDb>()) { var sources = await db.SourceFolders.Where(x => x.BackupEnabled).ToArrayAsync(); foreach (var sf in sources) { list.Add(new BackupTask(options, sf.Id, dbf, CreatePipelineLogger <BackupTask>())); } } CreatePipeline(list); }
public List <ViewServiceVm> GetAllServices() { var db = ServiceDb.GetAllServices(); var services = new List <ViewServiceVm>(); foreach (DataRow row in db.Rows) { var vm = new ViewServiceVm(); vm.Id = (int)row["Id"]; vm.Name = (string)row["Name"]; vm.CostPerHour = (decimal)row["CostPerHour"]; vm.ServiceType = (string)row["ServiceType"]; services.Add(vm); } return(services); }
private async Task RequireUserRecordForUser(string username) { using (var db = new ServiceDb()) { try { await _userService.Become(db, username, null); } catch (Exception) { await _userService.Create(db, username); await db.SaveChangesAsync(); } } }
public async Task <StandardResponse> GetAnswer(ClaimsPrincipal identity, GetAnswerViewModel model, ModelStateDictionary modelState) { if (!modelState.IsValid) { return(modelState.StandardError()); } using (var db = new ServiceDb()) { using (var user = await _userService.Become(db, identity, null)) { var answer = await _answerService.GetAnswer(db, user, model.Id); return(StandardResponse.For(AnswerViewModel.From(answer))); } } }
public async Task <StandardResponse> FindAnswers(ClaimsPrincipal identity, SearchAnswersViewModel model, ModelStateDictionary modelState) { if (!modelState.IsValid) { return(modelState.StandardError()); } using (var db = new ServiceDb()) { using (var user = await _userService.Become(db, identity, null)) { var matches = await _searchService.FindAnswersForQuestion(db, user, model.QuestionId, model.Offset, model.Limit); return(StandardResponse.For(matches)); } } }
public async Task <StandardResponse> DeleteAnswer(ClaimsPrincipal identity, DeleteAnswerViewModel model, ModelStateDictionary modelState) { if (!modelState.IsValid) { return(modelState.StandardError()); } using (var t = new ServiceDb().WithTransaction()) { using (var user = await _userService.Become(t.Db, identity, null)) { await _purgeService.PurgeExistingAnswer(t.Db, user, model.Id, new BackupConfig()); return(StandardResponse.ForSuccess()); } } }
public async Task <StandardResponse> FindQuestions(ClaimsPrincipal identity, PerformSearchViewModel model, ModelStateDictionary modelState) { if (!modelState.IsValid) { return(modelState.StandardError()); } using (var db = new ServiceDb()) { using (var user = await _userService.Become(db, identity, null)) { var result = await _searchService.SearchForQuestions(db, user, model.Query, model.Offset, model.Limit); return(StandardResponse.For(result)); } } }
public async Task <StandardResponse> GetQuestionMetadata(ClaimsPrincipal identity, GetQuestionViewModel model, ModelStateDictionary modelState) { if (!modelState.IsValid) { return(modelState.StandardError()); } using (var db = new ServiceDb()) { using (var user = await _userService.Become(db, identity, null)) { var meta = await _questionService.GetQuestionMetadata(db, user, model.Id); return(StandardResponse.For(QuestionMetaViewModel.From(meta))); } } }
public async Task <StandardResponse> DeleteTopic(ClaimsPrincipal identity, TopicDeleteViewModel model, ModelStateDictionary modelState) { if (!modelState.IsValid) { return(modelState.StandardError()); } using (var db = new ServiceDb()) { using (var user = await _userService.Become(db, identity)) { await _topicService.DeleteTopic(db, user, model.TopicId, model.RowVersion); await db.SaveChangesAsync(); return(StandardResponse.ForSuccess()); } } }
public async Task <StandardResponse> GetTopic(ClaimsPrincipal identity, TopicGetViewModel model, ModelStateDictionary modelState) { if (!modelState.IsValid) { return(modelState.StandardError()); } using (var db = new ServiceDb()) { using (var user = await _userService.Become(db, identity)) { var result = !string.IsNullOrWhiteSpace(model.TopicName) ? await _topicService.RequireTopic(db, user, model.TopicName) : await _topicService.GetTopic(db, user, model.TopicId); return(StandardResponse.For(new TopicViewModel(result))); } } }
public Task <MigrationStatusViewModel> GetMigrationStatus() { using (var db = new ServiceDb()) { var migrationsAssembly = db.GetService <IMigrationsAssembly>(); var historyRepository = db.GetService <IHistoryRepository>(); var all = migrationsAssembly.Migrations.Keys.ToList(); var applied = historyRepository.GetAppliedMigrations().ToList(); var pending = all.Except(applied.Select(i => i.MigrationId)); return(Task.FromResult(new MigrationStatusViewModel() { MigrationsCompleted = applied.Count(), MigrationsPending = pending.Count(), LastApplied = applied[applied.Count - 1].MigrationId })); } }
public async Task <StandardResponse> AddAnswerToQuestion(ClaimsPrincipal identity, AddAnswerViewModel model, ModelStateDictionary modelState) { if (!modelState.IsValid) { return(modelState.StandardError()); } using (var db = new ServiceDb()) { using (var user = await _userService.Become(db, identity, null)) { var answer = await _answerService.CreateAnswer(db, user, model.QuestionId, model.Body); await db.SaveChangesAsync(); return(StandardResponse.For(new { answer.AnswerId })); } } }
public async Task <StandardResponse> GetQuestionSummary(ClaimsPrincipal identity, GetQuestionViewModel model, ModelStateDictionary modelState) { if (!modelState.IsValid) { return(modelState.StandardError()); } using (var db = new ServiceDb()) { using (var user = await _userService.Become(db, identity, null)) { var question = await _questionService.GetQuestion(db, user, model.Id); var results = await _searchService.FindAnswersForQuestion(db, user, model.Id, 0, 1); var bestAnswer = results.HasResults ? Option.Some(await _answerService.GetAnswer(db, user, results.IdentityList[0].ToString())) : Option.None <Answer>(); return(StandardResponse.For(QuestionSummaryViewModel.From(question, bestAnswer))); } } }
public async Task <StandardResponse> UpdateAnswer(ClaimsPrincipal identity, UpdateAnswerViewModel model, ModelStateDictionary modelState) { if (!modelState.IsValid) { return(modelState.StandardError()); } using (var db = new ServiceDb()) { using (var user = await _userService.Become(db, identity, null)) { await _answerService.UpdateExistingAnswer(db, user, new UpdateAnswer() { AnswerId = model.AnswerId, NewBody = model.Body, RowVersion = model.RowVersion }); await db.SaveChangesAsync(); return(StandardResponse.ForSuccess()); } } }
private async Task <ITaskState> DoTask(ITaskState taskState, ScheduleMode mode, CancellationToken cancellationToken) { if (options.IsBackupDestinationAvailable()) { using (db = dbf.GetWebDbContext <ServiceDb>()) { var sf = await db.SourceFolders .Include(x => x.Backups) .SingleAsync(x => x.Id == sourceFolderId); //log.LogInformation($"Backup task for source {sf.DisplayName}"); var destinationFolder = Path.Combine(options.GetBackupDestination(), sf.DisplayName); if (!Directory.Exists(destinationFolder)) { Directory.CreateDirectory(destinationFolder); log.LogInformation($"{destinationFolder} created"); } var isPending = await IsBackupPending(sf); if (isPending.result) { //log.LogInformation($"Backup of {sf.GetFullname()} to {destinationFolder} is required"); var backup = isPending.backup; var namePart = sf.DisplayName; var datePart = $"{(backup.ScheduledOn.ToString("yyyy.MM.dd"))}"; var backupFileName = $"{namePart}.{datePart}.zip"; backup.FullPath = Path.Combine(destinationFolder, backupFileName); backup.State = BackupState.Started; var now = DateTimeOffset.Now; var todaysScheduledTime = new DateTimeOffset(now.Year, now.Month, now.Day, sf.ScheduledTime, 0, 0, now.Offset); log.LogInformation($"Backup of {sf.DisplayName} to {destinationFolder} started ({(todaysScheduledTime.ToString("ddMMMyyyy HH:mm:ss"))})"); if (sf.Type == SourceType.Website) { TakeSiteOffline(sf); } await db.SaveChangesAsync(); try { if (File.Exists(backup.FullPath)) { File.Delete(backup.FullPath); log.LogWarning($"{backup.FullPath} deleted"); } zip(sf.FullPath, backup.FullPath); backup.State = BackupState.Finished; backup.BackedUpOn = DateTimeOffset.Now; await db.SaveChangesAsync(); log.LogInformation($"Backup of {sf.DisplayName} to {backup.FullPath} completed"); } catch (Exception xe) { log.LogError(xe, $"backup failed {sf.DisplayName} to {backup.FullPath}"); backup.State = BackupState.Failed; backup.BackedUpOn = DateTimeOffset.Now; await db.SaveChangesAsync(); //throw; } finally { if (sf.Type == SourceType.Website) { BringSiteOnline(sf); } } await PurgeBackups(sf); } else { log.LogInformation($"Backup of {sf.DisplayName} is not pending"); } } } else { foreach (var d in DriveInfo.GetDrives()) { log.LogInformation($"Found drive {d.Name}, label {d.VolumeLabel}, ready = {d.IsReady}"); } log.LogWarning($"Backup destination not available - no disk with volume label {options.BackupDriveLabel} found"); } return(null); }
public void Delete(int id) { ServiceDb.Delete(id); }