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);
}
