private async Task RestoreDeletedPath(DeletedPath path)
{
try
{
var res = await PathService.RestoreDeletedPathAsync(path);
var restored = _paths.FirstOrDefault(x => x.Id == res.Id);
if (restored != null)
{
_paths.Remove(restored);
}
}
catch (ApiError e)
{
if (e.ProblemDetails.Status == 422)
{
PrintErrorDetails((e.ProblemDetails as UnprocessableEntityProblemDetails).Errors);
}
}
catch (Exception e)
{
Snackbar.Add(e.Message, Severity.Error);
}
}
public void WhenPathIsPassedWithNoEndingBackslashAndExistsIsReturnedNextPath()
{
var fileSystemService = new Mock <IFileSystemService>();
fileSystemService
.Setup(d => d.DirectoryExists(It.Is <string>(s => s.Equals("c:", StringComparison.InvariantCultureIgnoreCase))))
.Returns(true);
fileSystemService
.Setup(d => d.DirectoryExists(It.Is <string>(s => s.Equals($"c:{Path.DirectorySeparatorChar}", StringComparison.InvariantCultureIgnoreCase))))
.Returns(true);
fileSystemService
.Setup(d => d.DirectoryExists(It.Is <string>(s => s.Equals($"c:{Path.DirectorySeparatorChar}somedira", StringComparison.InvariantCultureIgnoreCase))))
.Returns(true);
fileSystemService
.Setup(d => d.DirectoryExists(It.Is <string>(s => s.Equals($"c:{Path.DirectorySeparatorChar}somedirb", StringComparison.InvariantCultureIgnoreCase))))
.Returns(true);
fileSystemService
.Setup(d => d.GetDirectories(It.Is <string>(s => s.Equals("c:", StringComparison.InvariantCultureIgnoreCase))))
.Returns(new[] { $"c:{Path.DirectorySeparatorChar}somedira", $"c:{Path.DirectorySeparatorChar}somedirb" });
fileSystemService
.Setup(d => d.GetDirectories(It.Is <string>(s => s.Equals($"c:{Path.DirectorySeparatorChar}", StringComparison.InvariantCultureIgnoreCase))))
.Returns(new[] { $"c:{Path.DirectorySeparatorChar}somedira", $"c:{Path.DirectorySeparatorChar}somedirb" });
var service = new PathService(fileSystemService.Object);
Assert.Equal($"c:{Path.DirectorySeparatorChar}somedirb", service.SuggestPath($"c:{Path.DirectorySeparatorChar}somedira"));
Assert.Equal($"c:{Path.DirectorySeparatorChar}somedirb", service.SuggestPath($"C:{Path.DirectorySeparatorChar}SOMEDIRA"));
Assert.Equal($"c:{Path.DirectorySeparatorChar}somedira", service.SuggestPath($"c:{Path.DirectorySeparatorChar}somedirb"));
Assert.Equal($"c:{Path.DirectorySeparatorChar}somedira", service.SuggestPath($"C:{Path.DirectorySeparatorChar}SOMEDIRB"));
Assert.Equal($"c:{Path.DirectorySeparatorChar}somedirb", service.SuggestPath($" c:{Path.DirectorySeparatorChar}somedira "));
Assert.Equal($"c:{Path.DirectorySeparatorChar}somedirb", service.SuggestPath($" C:{Path.DirectorySeparatorChar}SOMEDIRA "));
Assert.Equal($"c:{Path.DirectorySeparatorChar}somedira", service.SuggestPath($" c:{Path.DirectorySeparatorChar}somedirb "));
Assert.Equal($"c:{Path.DirectorySeparatorChar}somedira", service.SuggestPath($" C:{Path.DirectorySeparatorChar}SOMEDIRB "));
}
public BaseItemQueryHandler(PathService pathService, APIConnection connection, ManagerConfiguration managerConfiguration, FileService fileService)
{
this.connection = connection;
this.ManagerConfiguration = managerConfiguration;
this.pathService = pathService;
this.fileService = fileService;
}
public void WhenPathIsAnIncompletedNetworkPathIsReturnedNull()
{
var fileSystemService = new Mock <IFileSystemService>();
fileSystemService
.Setup(d => d.DirectoryExists(It.Is <string>(s => s.Equals($"{Path.DirectorySeparatorChar}{Path.DirectorySeparatorChar}networkpath", StringComparison.InvariantCultureIgnoreCase))))
.Returns(true);
fileSystemService
.Setup(d => d.DirectoryExists(It.Is <string>(s => s.Equals($"{Path.DirectorySeparatorChar}{Path.DirectorySeparatorChar}networkpath{Path.DirectorySeparatorChar}", StringComparison.InvariantCultureIgnoreCase))))
.Returns(true);
fileSystemService
.Setup(d => d.DirectoryExists(It.Is <string>(s => s.Equals($"{Path.DirectorySeparatorChar}{Path.DirectorySeparatorChar}networkpath{Path.DirectorySeparatorChar}share", StringComparison.InvariantCultureIgnoreCase))))
.Returns(true);
fileSystemService
.Setup(d => d.DirectoryExists(null))
.Returns(false);
fileSystemService
.Setup(d => d.GetDirectories(It.Is <string>(s => s.Equals($"{Path.DirectorySeparatorChar}{Path.DirectorySeparatorChar}networkpath", StringComparison.InvariantCultureIgnoreCase))))
.Throws <ArgumentException>();
fileSystemService
.Setup(d => d.GetDirectories(It.Is <string>(s => s.Equals($"{Path.DirectorySeparatorChar}{Path.DirectorySeparatorChar}networkpath{Path.DirectorySeparatorChar}", StringComparison.InvariantCultureIgnoreCase))))
.Throws <ArgumentException>();
var service = new PathService(fileSystemService.Object);
Assert.Null(service.SuggestPath($"{Path.DirectorySeparatorChar}{Path.DirectorySeparatorChar}networkpath"));
Assert.Null(service.SuggestPath($"{Path.DirectorySeparatorChar}{Path.DirectorySeparatorChar}networkpath{Path.DirectorySeparatorChar}"));
Assert.Null(service.SuggestPath($"{Path.DirectorySeparatorChar}{Path.DirectorySeparatorChar}networkpath{Path.DirectorySeparatorChar}share"));
}
public static TrekplannerConfiguration LoadOrCreate(bool saveIfNew = false)
{
lock (ConfigReaderWriterLock)
{
PathService.EnsurePathExists();
if (!File.Exists(ConfigFilename))
{
var result = new TrekplannerConfiguration();
if (saveIfNew)
{
result.Save();
}
return(result);
}
var existing = JsonConvert.DeserializeObject <TrekplannerConfiguration>(
File.ReadAllText(ConfigFilename),
JsonFormatters.IndentedAutotype);
//future: additional processing
return(existing);
}
}
private async Task EditPathAsync(Path path)
{
try
{
var result = await PathService.EditPathAsync(path);
var item = Paths.FirstOrDefault(x => x.Id == result.Id);
if (item != null)
{
item = result;
}
SnackbarHelper.PrintSuccess(localizer["PathUpdated"]);
}
catch (ApiError e)
{
if (e.ProblemDetails.Status == 422)
{
SnackbarHelper.PrintErrorDetails((e.ProblemDetails as UnprocessableEntityProblemDetails).Errors);
}
}
catch (Exception e)
{
SnackbarHelper.PrintError(e.Message);
}
StateHasChanged();
}
/// <include file="Tools/.Docs/.ManifestUninstaller.xml" path="docs/method[@name='Install(string, ManifestComponents, bool)']/*"/>
public static bool Uninstall(string AppDirectory, ManifestComponents Components, bool ThrowExceptions)
{
foreach (var Component in Components.Values)
{
var Path = PathService.CombinePath(AppDirectory, Component.FileName);
try
{
if (FileService.Exists(Path))
{
FileDeleter.Delete(Path);
}
}
catch
{
if (ThrowExceptions)
{
throw;
}
else
{
return(false);
}
}
}
return(true);
}
public MediaPagedViewModel PagedListBy(ApiCall call)
{
string by = call.GetValue("by");
if (string.IsNullOrEmpty(by))
{
return(null);
}
var lower = by.ToLower();
if (lower == "page" || lower == "view" || lower == "layout" || lower == "textcontent" || lower == "style" || lower == "htmlblock")
{
int pagesize = ApiHelper.GetPageSize(call, 50);
int pagenr = ApiHelper.GetPageNr(call);
MediaPagedViewModel model = new MediaPagedViewModel();
model.Files = GetPagedFilesBy(call.WebSite.SiteDb(), by, pagesize, pagenr);
model.CrumbPath = PathService.GetCrumbPath("/");
return(model);
}
else
{
return(null);
}
}
public MediaLibraryViewModel ListBy(ApiCall call)
{
string by = call.GetValue("by");
if (string.IsNullOrEmpty(by))
{
return(null);
}
var lower = by.ToLower();
if (lower == "page" || lower == "view" || lower == "layout" || lower == "textcontent" || lower == "style" || lower == "htmlblock")
{
MediaLibraryViewModel model = new MediaLibraryViewModel();
model.Files = GetFilesBy(call.WebSite.SiteDb(), by);
model.CrumbPath = PathService.GetCrumbPath("/");
return(model);
}
else
{
return(null);
}
}
private static void Main(string[] args)
{
logger.Info($"Started {DateTime.Now}");
PathService.EnsurePathExists();
logger.Info($"Service data resides in `{PathService.AppData}`");
var container = CreateDiContainer();
HostFactory.Run(configurator =>
{
configurator.UseLog4Net();
configurator.StartAutomatically();
configurator.EnableServiceRecovery(rc =>
{
rc.RestartService(1); // restart the service after 1 minute
});
configurator.Service <TelegramBotService>(s =>
{
s.ConstructUsing(hostSettings => container.Resolve <TelegramBotService>());
s.WhenStarted(tc => tc.Start());
s.WhenStopped(tc => tc.Stop());
});
configurator.RunAsLocalSystem();
configurator.SetDescription("Telegram Theory Bot host");
configurator.SetDisplayName("Telegram Theory Bot");
configurator.SetServiceName("Theorbo");
});
}
/// <include file="Tools/.Docs/.ManifestInstaller.xml" path="docs/method[@name='Install(string, ManifestComponents, bool)']/*"/>
public static bool Install(string AppDirectory, ManifestComponents Components, bool ThrowExceptions)
{
foreach (var Component in Components.Values)
{
var InstallationPath = PathService.CombinePath(AppDirectory, Component.FileName);
try
{
PathCreator.Create(PathService.GetDirectoryPath(InstallationPath));
FileCreator.Create(InstallationPath, Component.Data);
}
catch
{
if (ThrowExceptions)
{
throw;
}
else
{
return(false);
}
}
}
return(true);
}
public void PathService_ProjectNaem_ReturnNotEmpty()
{
var service = new PathService();
var result = service.PjName();
Assert.That(result, Is.Not.Empty);
}
void DrawDebugButtons()
{
if (GUI.Button(new Rect(0, 0, 100, 50), "Next Step"))
{
PathService.ConnectPathFromPreviousNodeColors(model, Config.Width, ++step);
}
if (GUI.Button(new Rect(100, 0, 100, 50), "Complete"))
{
PathService.ConnectPathFromPreviousNodeColors(model, Config.Width, Config.Height);
}
if (GUI.Button(new Rect(0, 50, 100, 50), "Move"))
{
TrainService.MoveTrainForward(model);
}
if (GUI.Button(new Rect(100, 50, 100, 50), "Reset"))
{
InitWorld();
}
if (GUI.Button(new Rect(0, 100, 100, 50), "Save"))
{
Save();
}
if (GUI.Button(new Rect(100, 100, 100, 50), "Load"))
{
Load();
}
if (GUI.Button(new Rect(0, 150, 100, 50), "Toggle Nodes"))
{
model.debugSettings.isShowingNodes = !model.debugSettings.isShowingNodes;
}
if (GUI.Button(new Rect(100, 150, 100, 50), "Toggle Connection Info"))
{
model.debugSettings.isShowingConnectionInfo = !model.debugSettings.isShowingConnectionInfo;
}
}
protected override async Task OnAfterRenderAsync(bool firstRender)
{
if (firstRender || Retry)
{
if (Loading)
{
ValidationResult <User> user = await CertificateService.GetUserAsync();
if (user.Success)
{
User = user.Result;
Identifier = PathService.GetUserIdentifier();
Navigation.NavigateTo("/Admin/Certificates");
}
else
{
NoUserMessage = user.ErrorMessages.FirstOrDefault();
Navigation.NavigateTo("/Admin/FirstCertificate");
}
}
Loading = false;
StateHasChanged();
}
}
public void AddUsefulTips()
{
try
{
var pathService = new PathService();
var tipsProvider = new TipsProvider(pathService);
var tipContexts = new List <TipContext>();
foreach (var language in tipsProvider.SupportedLanguages)
{
var tipsLanguageFullPath = GetTipsLanguagePath(language);
CreateTipsImportContent(tipsLanguageFullPath, language);
var tipsImportFile = Path.Combine(tipsLanguageFullPath, "TipsImport.xml");
var tips = GetTipsForImport(tipsProvider, tipsImportFile, tipsLanguageFullPath);
if (tips?.Count > 0)
{
tipContexts.Add(new TipContext
{
LanguageId = language,
Tips = tips
});
}
}
tipsProvider.AddTips(tipContexts, StringResources.SDLTM_Anonymizer_Name);
}
catch (Exception ex)
{
Trace.WriteLine(ex.Message);
}
}
public void TestTrimPathSeparators(string directory, string expectedResult)
{
var environmentPathServiceMock = new Mock <IEnvironmentPathService>();
var pathService = new PathService(environmentPathServiceMock.Object);
var path = pathService.TrimPathSeparators(directory);
Assert.Equal(path, expectedResult);
}
public void WhenPathIsNotValidoOrNotExistsTheResultIsNull()
{
var fileSystemService = new Mock <IFileSystemService>();
var service = new PathService(fileSystemService.Object);
Assert.Null(service.SuggestPath($"z:{Path.DirectorySeparatorChar}" + Guid.NewGuid()));
Assert.Null(service.SuggestPath("$\"!£%"));
}
public UsersSeeder(DataContainer dataContainer, string configDir)
{
this.dataContainer = dataContainer;
this.configDir = configDir;
configSeedAvatarsDir = Path.Combine(configDir, SeederPathsNames.InitDir, SeederPathsNames.AvatarsDir);
PathService pathService = new PathService(configDir);
uploadImagesDir = pathService.GetPath(PathNames.UploadImagesDirName);
}
private void ddlPathDataBind()
{
PathService pathService = new PathService();
ddlPath.DataSource = pathService.FindAll();
ddlPath.DataTextField = "PathName";
ddlPath.DataValueField = "PathId";
ddlPath.DataBind();
}
public LEOUserItemQueryHandler(
PathService pathService,
APIConnection connection,
IAuditLogStore auditLogStore, LEOUploadModule leoUploadModule, ManagerConfiguration managerConfiguration, FileService fileService) : base(pathService, connection, managerConfiguration, fileService)
{
this.auditLogStore = auditLogStore;
this.LEOUploadModule = leoUploadModule;
this.ManagerConfiguration = managerConfiguration;
}
public void DeleteUserSession()
{
string sessionPath = new PathService().SessionPath() + ".dat";
if (File.Exists(sessionPath))
{
File.Delete(sessionPath);
}
}
public DbProjectFileGeneration(
DbProjectFileDomainAddition dbProjectFileDomainAddition,
DbProjectFileEntityAddition dbProjectFileEntityAddition,
PathService pathService)
{
this.dbProjectFileDomainAddition = dbProjectFileDomainAddition;
this.dbProjectFileEntityAddition = dbProjectFileEntityAddition;
this.pathService = pathService;
}
// GET: Path/Create
public IActionResult Create()
{
PathService pathService = new PathService(_context);
ViewBag.originalStationsList = pathService.ReturnListStationsForDropDowns(0, false);
ViewBag.destinationStationsList = pathService.ReturnListStationsForDropDowns(0, false);
ViewBag.via1StationsList = pathService.ReturnListStationsForDropDowns(0, true);
ViewBag.via2StationsList = pathService.ReturnListStationsForDropDowns(0, true);
return(View());
}
public void WhenNoPathPassedTheResultIsNull()
{
var fileSystemService = new Mock <IFileSystemService>();
var service = new PathService(fileSystemService.Object);
Assert.Null(service.SuggestPath(null));
Assert.Null(service.SuggestPath(string.Empty));
Assert.Null(service.SuggestPath(" "));
}
public PathServiceTests()
{
_fileSystemProviderMock = new Mock <IFileSystemProvider>();
_steamServiceMock = new Mock <ISteamService>();
_steamServiceMock.Setup(steamService => steamService.GetSteamGamesPath())
.Returns(SteamPath);
_pathService = new PathService(_fileSystemProviderMock.Object, _steamServiceMock.Object);
}
private void GetLayout(string layoutContent)
{
if (this.Request.Cookies.ContainsCookie(AuthenticationCookieKey) && this.Request.Cookies.GetCookie(AuthenticationCookieKey).Expires >= DateTime.UtcNow)
{
layoutContent = System.IO.File.ReadAllText(PathService.HtmlFinder("_LoggedInayout"));
}
else
{
layoutContent = System.IO.File.ReadAllText(PathService.HtmlFinder("_LoggedOutLayout"));
}
}
public LogReaderQueryHandler(
PathService pathService,
APIConnection connection,
ManagerConfiguration managerConfiguration,
FileService fileService,
LogReaderService logReaderService
) : base(pathService, connection, managerConfiguration, fileService)
{
this.ManagerConfiguration = managerConfiguration;
this.LogReaderService = logReaderService;
}
public void WhenPathIsPassedWithNoEndingBackslashIsSearchedNextDirectoryThatStartsWithLastToken()
{
var fileSystemService = new Mock <IFileSystemService>();
fileSystemService
.Setup(d => d.DirectoryExists(It.Is <string>(s => s.Equals("c:", StringComparison.InvariantCultureIgnoreCase))))
.Returns(true);
fileSystemService
.Setup(d => d.DirectoryExists(It.Is <string>(s => s.Equals($"c:{Path.DirectorySeparatorChar}", StringComparison.InvariantCultureIgnoreCase))))
.Returns(true);
fileSystemService
.Setup(d => d.DirectoryExists(It.Is <string>(s => s.Equals($"c:{Path.DirectorySeparatorChar}some", StringComparison.InvariantCultureIgnoreCase))))
.Returns(true);
fileSystemService
.Setup(d => d.DirectoryExists(It.Is <string>(s => s.Equals($"c:{Path.DirectorySeparatorChar}somedir", StringComparison.InvariantCultureIgnoreCase))))
.Returns(true);
fileSystemService
.Setup(d => d.DirectoryExists(It.Is <string>(s => s.Equals($"c:{Path.DirectorySeparatorChar}otherdir", StringComparison.InvariantCultureIgnoreCase))))
.Returns(true);
fileSystemService
.Setup(d => d.GetDirectories(It.Is <string>(s => s.Equals("c:", StringComparison.InvariantCultureIgnoreCase))))
.Returns(new[]
{
$"c:{Path.DirectorySeparatorChar}somedir",
$"c:{Path.DirectorySeparatorChar}otherdir",
$"c:{Path.DirectorySeparatorChar}some"
});
fileSystemService
.Setup(d => d.GetDirectories(It.Is <string>(s => s.Equals($"c:{Path.DirectorySeparatorChar}", StringComparison.InvariantCultureIgnoreCase))))
.Returns(new[]
{
$"c:{Path.DirectorySeparatorChar}somedir",
$"c:{Path.DirectorySeparatorChar}otherdir",
$"c:{Path.DirectorySeparatorChar}some"
});
var service = new PathService(fileSystemService.Object);
Assert.Equal($"c:{Path.DirectorySeparatorChar}somedir", service.SuggestPath($"c:{Path.DirectorySeparatorChar}some"));
Assert.Equal($"c:{Path.DirectorySeparatorChar}some", service.SuggestPath($"c:{Path.DirectorySeparatorChar}otherdir"));
Assert.Equal($"c:{Path.DirectorySeparatorChar}somedir", service.SuggestPath($"C:{Path.DirectorySeparatorChar}SOME"));
Assert.Equal($"c:{Path.DirectorySeparatorChar}otherdir", service.SuggestPath($"C:{Path.DirectorySeparatorChar}SOMEDIR"));
Assert.Equal($"c:{Path.DirectorySeparatorChar}some", service.SuggestPath($"C:{Path.DirectorySeparatorChar}OTHERDIR"));
Assert.Equal($"c:{Path.DirectorySeparatorChar}somedir", service.SuggestPath($" c:{Path.DirectorySeparatorChar}some "));
Assert.Equal($"c:{Path.DirectorySeparatorChar}otherdir", service.SuggestPath($" c:{Path.DirectorySeparatorChar}somedir "));
Assert.Equal($"c:{Path.DirectorySeparatorChar}some", service.SuggestPath($" c:{Path.DirectorySeparatorChar}otherdir "));
Assert.Equal($"c:{Path.DirectorySeparatorChar}somedir", service.SuggestPath($" C:{Path.DirectorySeparatorChar}SOME "));
Assert.Equal($"c:{Path.DirectorySeparatorChar}otherdir", service.SuggestPath($" C:{Path.DirectorySeparatorChar}SOMEDIR "));
Assert.Equal($"c:{Path.DirectorySeparatorChar}some", service.SuggestPath($" C:{Path.DirectorySeparatorChar}OTHERDIR "));
Assert.Equal($"c:{Path.DirectorySeparatorChar}some", service.SuggestPath($" C:{Path.DirectorySeparatorChar}s"));
Assert.Equal($"c:{Path.DirectorySeparatorChar}otherdir", service.SuggestPath($" C:{Path.DirectorySeparatorChar}o"));
Assert.Equal($"c:{Path.DirectorySeparatorChar}otherdir", service.SuggestPath($" C:{Path.DirectorySeparatorChar}somedir"));
}
public void TestGetRelativePath()
{
var environmentPathServiceMock = new Mock <IEnvironmentPathService>();
environmentPathServiceMock
.Setup(m => m.GetRelativePath(Directory, File))
.Returns(FullPath);
var pathService = new PathService(environmentPathServiceMock.Object);
var path = pathService.GetRelativePath(Directory, File);
Assert.Equal(FullPath, path);
}
public MainController(
ISocialService socialService,
ConcurrencyService concurrencyService,
PathService pathService,
ILogger <MainController> logger
)
{
_socialService = socialService;
_concurrencyService = concurrencyService;
_pathService = pathService;
_logger = logger;
}