private static Vector2i NextField(Directories dir, Vector2i vect)
{
if (dir == Directories.Right)
vect.X++;
else if (dir == Directories.Left)
vect.X--;
else if (dir == Directories.Up)
vect.Y--;
else if (dir == Directories.Down)
vect.Y++;
else if (dir == Directories.LeftUp)
{
vect.X--;
vect.Y--;
}
else if (dir == Directories.LeftDown)
{
vect.X--;
vect.Y++;
}
else if (dir == Directories.RightUp)
{
vect.X++;
vect.Y--;
}
else if (dir == Directories.RightDown)
{
vect.X++;
vect.Y++;
}
return vect;
}
/// <summary>
///
/// </summary>
/// <param name="field">Das Spielfeld</param>
/// <param name="dir">Die Richtung, in die überprüft werden soll.</param>
/// <param name="player"></param>
/// <param name="from">Der inklusive untere Vector der Startposition.</param>
/// <returns></returns>
private static int DoCheck(Fields.Field field, Directories dir, char player, Vector2i from)
{
int counter = 0;
for (int a = 0; a < GewinnBedingung; a++)
{
if (field.GetField(from) == player)
counter++;
else break;
from = NextField(dir, from);
}
return counter;
}
private void btnProcess_Click(object sender, EventArgs e)
{
Cursor.Current = Cursors.WaitCursor;
try
{
string fullPath = Path.GetFullPath(txtPath.Text);
Directories d = new Directories(fullPath, txtFilters.Text, rdbSuppressEmpty.Checked, rdbWriteChildren.Checked );
txtJSON.Text = d.GetJsonPretty();
File.WriteAllText(Path.Combine(fullPath, "directory.json"), d.GetJson());
}
finally
{
Cursor.Current = Cursors.Default;
}
}
public static string WriteToTemp(this HttpPostedFileBase file)
{
var guid = Strings.NewGuid();
var folderPath = Path.Combine(Path.Combine(Directories.Temp(), guid));
if (!folderPath.Exists())
{
Directory.CreateDirectory(folderPath);
}
var filePath = Path.Combine(
folderPath,
Path.GetFileName(file.FileName));
file.SaveAs(filePath);
return(guid);
}
private Directory GetCurrentOrErrorDirectory()
{
if (CurrentDirectory != null)
{
return(CurrentDirectory);
}
var error = Directories.OfType <ErrorDirectory>().FirstOrDefault();
if (error != null)
{
return(error);
}
error = new ErrorDirectory();
PushDirectory(error);
return(error);
}
public override bool Execute()
{
var items = Directories.IsNullOrEmpty() ? new string[0] : Directories.Select(each => each.ItemSpec);
items.Union(Files.IsNullOrEmpty() ? new string[0] : Files.Select(each => each.ItemSpec));
items.Union(Locations.IsNullOrEmpty() ? new string[0] : Locations.Select(each => each.ItemSpec));
items.Union(Directory.IsNullOrEmpty() ? new string[0] : Directory.Select(each => each.ItemSpec));
items.Union(File.IsNullOrEmpty() ? new string[0] : File.Select(each => each.ItemSpec));
items.Union(Location.IsNullOrEmpty() ? new string[0] : Location.Select(each => each.ItemSpec));
foreach (var i in items)
{
Log.LogMessage("Removing '{0}'.".format(i));
i.TryHardToDelete();
}
return(true);
}
public ExportViewmodel(IMediaManager mediaManager, IEnumerable <ExportMedia> exportList)
{
_mediaManager = mediaManager;
Items = new ObservableCollection <ExportMediaViewmodel>(exportList.Select(media => new ExportMediaViewmodel(mediaManager, media)));
Directories = mediaManager.IngestDirectories.Where(d => d.ContainsExport()).Select(d => new MediaDirectoryViewmodel(d, false, true)).ToList();
SelectedDirectory = Directories.FirstOrDefault();
CommandExport = new UICommand()
{
ExecuteDelegate = _export, CanExecuteDelegate = _canExport
};
this._view = new Views.ExportView()
{
DataContext = this, Owner = System.Windows.Application.Current.MainWindow, ShowInTaskbar = false
};
_view.ShowDialog();
}
/// <summary>
/// Fixed:
/// </summary>
public static string UploadImage(Context context, long id)
{
var invalid = BinaryValidators.OnUploadingImage(context: context);
switch (invalid)
{
case Error.Types.OverTenantStorageSize:
return(Messages.ResponseOverTenantStorageSize(
context: context,
data: context.ContractSettings.StorageSize.ToString()).ToJson());
case Error.Types.None: break;
default: return(invalid.MessageJson(context: context));
}
var file = context.PostedFiles.FirstOrDefault();
var bin = file.Byte();
if (Parameters.BinaryStorage.IsLocal())
{
bin.Write(System.IO.Path.Combine(
Directories.BinaryStorage(),
"Images",
file.Guid));
}
Rds.ExecuteNonQuery(
context: context,
statements: Rds.InsertBinaries(
param: Rds.BinariesParam()
.TenantId(context.TenantId)
.ReferenceId(id)
.Guid(file.Guid)
.BinaryType("Images")
.Title(file.FileName)
.Bin(bin, _using: !Parameters.BinaryStorage.IsLocal())
.FileName(file.FileName)
.Extension(file.Extension)
.Size(file.Size)
.ContentType(file.ContentType)));
return(new ResponseCollection()
.InsertText(
"#" + context.Forms.ControlId(),
"".Params(Locations.ShowFile(
context: context,
guid: file.Guid)))
.ToJson());
}
/// <summary>
/// Reads the response data from the service call, if any
/// </summary>
/// <param name="response">
/// The response instance obtained from the previous request
/// </param>
/// <returns>The body content of the response</returns>
public static string ReadResponseBody(HttpWebResponse response, string caminhoDoDownload)
{
if (response == null)
{
throw new ArgumentNullException("response", "Value cannot be null");
}
var responseBody = string.Empty;
using (var responseStream = response.GetResponseStream())
{
if (responseStream != null)
{
if (string.IsNullOrEmpty(caminhoDoDownload))
{
using (var reader = new StreamReader(responseStream))
{
responseBody = reader.ReadToEnd();
}
}
else
{
var diretorio = Path.GetDirectoryName(caminhoDoDownload);
Directories.CreateIfNotExist(diretorio);
using (var reader = responseStream)
{
var bytes = new byte[responseStream.Length];
reader.Read(bytes, 0, bytes.Length);
using (var fileStream = new FileStream(caminhoDoDownload, FileMode.Create))
{
fileStream.Write(bytes, 0, bytes.Length);
fileStream.Flush();
}
}
////using (var output = File.OpenWrite(caminhoDoDownload))
////{
//// responseStream.CopyTo(output);
////}
}
}
}
return(responseBody);
}
public void Load(string filename)
{
ArchivePath = filename;
IsMultiPart = filename.EndsWith("_dir.vpk");
if (IsMultiPart)
{
LoadParts(filename);
}
_reader = new VpkReaderV1(filename);
var hdr = _reader.ReadArchiveHeader();
if (!hdr.Verify())
{
throw new ArchiveParsingException("Invalid archive header");
}
Directories.AddRange(_reader.ReadDirectories(this));
}
public void ReadDataFilesAsync(ContentStorage loc, GameDirectory gameDir, string searchPattern,
Action <KSoft.IO.XmlElementStream, FA> streamProc,
out System.Threading.Tasks.ParallelLoopResult result)
{
Contract.Requires(!string.IsNullOrEmpty(searchPattern));
result = System.Threading.Tasks.Parallel.ForEach(Directories.GetFiles(loc, gameDir, searchPattern), (filename) =>
{
const FA k_mode = FA.Read;
using (var s = new KSoft.IO.XmlElementStream(filename, k_mode, this))
{
SetupStream(s);
streamProc(s, k_mode);
}
});
}
public void DeleteAllFrom(string path)
{
var dirs = Directories.Where(p => p.StartsWith(path + "\\", StringComparison.InvariantCultureIgnoreCase));
Directories = Directories.Except(dirs).ToList();
var files = Files.Where(p => p.StartsWith(path + "\\", StringComparison.InvariantCultureIgnoreCase));
Files = Files.Except(files).ToList();
var manifestKeys = Manifests.Keys.Where(p => p.StartsWith(path + "\\", StringComparison.InvariantCultureIgnoreCase)).ToArray();
foreach (var key in manifestKeys)
{
Manifests.Remove(key);
}
}
public void GivenAString_WhenGettingDirectory_WithAValidPath_ItshouldReturnAListOfFiles()
{
var parameters = new GetDirectoryParams
{
Directory = "darkmatter",
Properties = FileProperties.All()
};
var mock = GetKodiServiceMock(parameters);
var service = mock.Object;
var actual = service.GetDirectory(parameters, "UnitTests");
var expected = Directories.GetDirectory();
Assert.IsInstanceOf <JsonRpcResponse <GetDirectoryResponse> >(actual);
Assert.That(actual.Result.Files.Count, Is.EqualTo(expected.Files.Count));
AssertThatPropertyValuesAreEquals(actual.Result, expected);
}
private List <string> GetAttachmentUrls(int ContextID, int ThreadID)
{
MailAttachmentFilePath mfp = Directories.GetMailAttachment(ContextID, ThreadID);
if (mfp.AllFiles().Count() > 0)
{
List <string> attachmentUrls = new List <string>();
foreach (string filePath in mfp.AllFiles())
{
string attachmentUrl = StringConstants.WebClientRoot + "FileHandler/GetMailAttachment?" + "courseId={0}" + "&threadId={1}" + "&fileName={2}";
attachmentUrl = string.Format(attachmentUrl, ContextID.ToString(), ThreadID.ToString(), Path.GetFileName(filePath));
attachmentUrls.Add(attachmentUrl);
}
return(attachmentUrls);
}
return(new List <string>());
}
public IFileSystemEntry?this[string index]
{
get
{
if (Directories.TryGetValue(index, out var dir))
{
return(dir);
}
if (Files.TryGetValue(index, out var file))
{
return(file);
}
return(null);
}
}
public ActionResult GetMailAttachment(int courseId, int threadId, string fileName)
{
var course = (from c in db.CourseUsers
where c.UserProfileID == CurrentUser.ID && c.AbstractCourseID == courseId
select c).FirstOrDefault();
if (course != null)
{
MailAttachmentFilePath mfp = Directories.GetMailAttachment(courseId, threadId);
Stream stream = FileSystem.GetDocumentForRead(mfp.GetPath() + "\\" + fileName);
return(new FileStreamResult(stream, MimeMapping.GetMimeMapping(fileName))
{
FileDownloadName = fileName
});
}
return(RedirectToAction("Index", "Home"));
}
private void GetSubDirectories(string RootDir, Directory DirElem)
{
DirElem.Name = FileSystemHelperClass.GetAbsoluteName(RootDir);
FileSystemHelperClass Helper = new FileSystemHelperClass();
string[] DirFiles = io.Directory.GetFiles(RootDir);
File[] FileElements = ConvertAsFiles(DirFiles);
FileSystemHelperClass.AddRange(FileElements, DirElem.Files);
Directories Dirs = DirElem.Directories;
foreach (string Folder in io.Directory.GetDirectories(RootDir))
{
Directory FolderElem = new Directory();
GetSubDirectories(Folder, FolderElem);
Dirs.Add(FolderElem);
}
}
public void WriteToLocal()
{
if (Added == true)
{
GetBin().Write(Path.Combine(
Directories.BinaryStorage(),
"Attachments",
Guid));
}
else if (Deleted == true)
{
Files.DeleteFile(Path.Combine(
Directories.BinaryStorage(),
"Attachments",
Guid));
}
}
public Loader(string path)
{
if (Current != null)
{
throw new Exception("Another loader already in progress, make sure only one loader run at a time");
}
Current = this;
Version = Directories.GetVersionFromPath(Path = path);
if (Version == GtaVersion.Unknown)
{
throw new ArgumentException("Invalid Gta path: " + path);
}
Log.Message("No version specified, loaded {0} for {1}", Version, path);
}
protected override void CreateDirectory()
{
if (Directories == null)
{
return;
}
if (exifDir == null)
{
exifDir = Directories.OfType <ExifDirectoryBase>().FirstOrDefault();
}
if (exifSubIfdDir == null)
{
exifSubIfdDir = Directories.OfType <ExifSubIfdDirectory>().FirstOrDefault();
}
}
public Directories GetItems(string login, DateTimeOffset lastUpdate)
{
long count = RemainderToUpdate(login);
if (count == 0L)
{
count = PrepareToUpdate(login, lastUpdate);
}
Directories result = new Directories
{
Count = count,
Items = GetDirectoryInfos(login)
};
return(result);
}
public void CreateDirectory(FilePath path)
{
if (!path.IsDirectory)
{
throw new ArgumentException("The specified path is no directory.", nameof(path));
}
if (Directories.ContainsKey(path))
{
return;
}
if (!Directories.TryGetValue(path.ParentPath, out var subentities))
{
throw new DirectoryNotFoundException();
}
subentities.Add(path);
Directories[path] = new HashSet <FilePath>();
}
public void WriteToLocal(Context context)
{
if (Added == true)
{
GetBin().Write(Path.Combine(
Directories.BinaryStorage(),
"Attachments",
Guid));
}
else if (Deleted == true && !Parameters.BinaryStorage.RestoreLocalFiles)
{
Files.DeleteFile(Path.Combine(
Directories.BinaryStorage(),
"Attachments",
Guid));
}
}
static public bool FileExists(string FileFullPath)
{
string FileDirectory = Utils.CleanDirectorySeparators(Path.GetDirectoryName(FileFullPath));
string DirectoriesKey = FileDirectory.ToLowerInvariant();
DirectoryCache FoundDirectoryCache;
if (!Directories.TryGetValue(DirectoriesKey, out FoundDirectoryCache))
{
// First time we've seen this directory. Gather information about files.
FoundDirectoryCache = new DirectoryCache(FileDirectory);
Directories.Add(DirectoriesKey, FoundDirectoryCache);
}
// Try to find the file in this directory
return(FoundDirectoryCache.HasFile(FileFullPath));
}
private async void SearchCatalogAsync(string searchText)
{
if (searchText.Length >= 1)
{
IsSearchActivated = true;
Directories.Clear();
var updatedList = await _directoryStorage.SearchDirectoriesAsync(searchText);
Directories = new ObservableCollection <Directory>(updatedList.ToList());
}
else
{
IsSearchActivated = false;
Directories.Clear();
await CreateListsAsync();
}
}
/// <summary>
/// Logs the provided Packets List as a Packet Log.
///
/// TO BE USED TO LOG PACKETS ONLY
/// </summary>
/// <param name="Out">String to output</param>
/// <returns>True if log successful</returns>
public static bool Packets(List <string> Out)
{
lock (Threads.GenericThreadSafeLock)
{
Directories.DirectoryPrepare("./Logs/");
Directories.DirectoryPrepare("./Logs/PacketLogs/");
string LogFile = "./Logs/PacketLogs/" + OYS_DateTime.ToOYSLongDateTime(DateTime.Now).ReplaceAll("/", "_").ReplaceAll(" ", "_").ReplaceAll(":", "_") + ".html";
Files.PrepareHTMLLog(LogFile);
List <string> MessagesOut = new List <string>();
foreach (string ThisString in Out)
{
MessagesOut.Add(String.Format("{0}: {1}", OYS_DateTime.ToOYSLongDateTime(DateTime.Now), ThisString));
}
Files.FileHTMLAppend(LogFile, MessagesOut.ToArray());
}
return(true);
}
private void SetReferences()
{
Dictionary <int, RomfsDir> dirDict = Directories.ToDictionary(x => x.Offset, x => x);
Dictionary <int, RomfsFile> fileDict = Files.ToDictionary(x => x.Offset, x => x);
foreach (RomfsDir dir in Directories)
{
if (dir.ParentDirOffset >= 0 && dir.ParentDirOffset != dir.Offset)
{
dir.ParentDir = dirDict[dir.ParentDirOffset];
}
if (dir.NextSiblingOffset >= 0)
{
dir.NextSibling = dirDict[dir.NextSiblingOffset];
}
if (dir.FirstChildOffset >= 0)
{
dir.FirstChild = dirDict[dir.FirstChildOffset];
}
if (dir.FirstFileOffset >= 0)
{
dir.FirstFile = fileDict[dir.FirstFileOffset];
}
if (dir.NextDirHashOffset >= 0)
{
dir.NextDirHash = dirDict[dir.NextDirHashOffset];
}
}
foreach (RomfsFile file in Files)
{
if (file.ParentDirOffset >= 0)
{
file.ParentDir = dirDict[file.ParentDirOffset];
}
if (file.NextSiblingOffset >= 0)
{
file.NextSibling = fileDict[file.NextSiblingOffset];
}
if (file.NextFileHashOffset >= 0)
{
file.NextFileHash = fileDict[file.NextFileHashOffset];
}
}
}
private void Find(object sender, DoWorkEventArgs e)
{
var list = Directories.Select(dd => dd.FullPath).ToList();
var allFiles = new List <FileData>();
var i = 0;
foreach (var dir in list)
{
allFiles.AddRange(Directory.GetFiles(dir).Select(filePath =>
{
_finder.ReportProgress(i++);
return(new FileData(new FileInfo(filePath)));
}));
}
e.Cancel = false;
e.Result = allFiles;
}
public void Load()
{
CommandArguments.Populate();
Preview = CommandArguments.Preview;
Directories = CommandArguments.Directories;
DupesDirectory = CommandArguments.DupesDirectory;
ExcludeDirectoryNames = CommandArguments.ExcludeDirectoryNames;
IncludeFileExtensions = CommandArguments.IncludeFileExtensions;
Clean = CommandArguments.Clean;
Validate();
if (string.IsNullOrWhiteSpace(DupesDirectory))
{
DupesDirectory = Path.Combine(Directories.First(), DupesDirectoryName);
}
}
public ScsDirectory GetDirectory(ulong hash)
{
if (Directories.ContainsKey(hash))
{
return(Directories[hash]);
}
foreach (var scsDirectory in Directories)
{
var res = scsDirectory.Value.GetDirectory(hash);
if (res != null)
{
return(res);
}
}
return(null);
}
internal static void Write(string codePath, string newCode, string existingCode = "")
{
if (existingCode.IsNullOrEmpty() || newCode != existingCode)
{
if (!existingCode.IsNullOrEmpty())
{
CodeHistories.Create(codePath);
}
Consoles.Write(
codePath.Substring(Directories.ServicePath().Length),
Consoles.Types.Info);
newCode.Write(codePath);
}
else
{
Consoles.Write("-", Consoles.Types.Info);
}
}
internal static void CreateSelections()
{
for (Directories i0 = 0; i0 < Directories.Count; ++i0)
{
string key = $"{typeof( Setting)}#{i0}";
string value = EditorUserSettings.GetConfigValue(key);
bool setting;
if (bool.TryParse(value, out setting) == false)
{
setting = false;
}
if (setting != false)
{
CreateDirectory(i0);
}
}
}
public Captcha09(string directory = null)
{
if (directory != null)
{
Directory = Directories.Create(directory).FullName;
}
for (int i = 0; i < 10; i++)
{
if (!Data.ContainsKey(i))
{
Data.Add(i, new ThreadedList <Dictionary <string, double> >());
}
}
Database = new DatabseSimpleton(Directory + @"\data\training.dbs", false);
LoadData();
}
public void FormLoad(string directoryPath)
{
// CurrentDirectoryPath = directoryPath;
IList<Directories> res = new List<Directories>();
Directories dirs;
try
{
if (string.IsNullOrEmpty(directoryPath))
{
this.gvExplorer.DataSource = null;
this.gvExplorer.DataBind();
return;
}
DirectoryInfo directory = new DirectoryInfo(directoryPath);
if (!directory.Exists)
{
this.gvExplorer.DataSource = null;
this.gvExplorer.DataBind();
return;
}
DirectoryInfo[] directories = directory.GetDirectories();
foreach (var item in directories)
{
if (!this.CanViewFolderDeleted && item.Name == "Deleted")
{
continue;
}
dirs = new Directories();
dirs.FullName = item.FullName;
dirs.Name = item.Name;
dirs.Type = "Папка";
dirs.LastWriteTime = Convert.ToDateTime(item.LastWriteTime);
dirs.IsFile = "false";
dirs.ImageSRC = "../Images/Folder.png";
//Директории не могат да се трият
dirs.DeleteVisible = false;
dirs.CbxVisible = false;
dirs.ChbxToArchiveVisible = false;
res.Add(dirs);
}
FileInfo[] files = directory.GetFiles();
foreach (var item in files)
{
dirs = new Directories();
dirs.FullName = item.FullName;
dirs.Name = item.Name;
dirs.Type = "Файл";
dirs.LastWriteTime = Convert.ToDateTime(item.LastWriteTime);
dirs.FileLength = (item.Length / 1024).ToString();
dirs.IsFile = "true";
dirs.ImageSRC = "../Images/FileXPtest.png";
dirs.DeleteVisible = (directory.Name.Equals("Deleted") ? false : CanDeleteFiles);
dirs.CbxVisible = CanViewCbxlink;
dirs.ChbxToArchiveVisible = this.CanViewToArchive;
res.Add(dirs);
}
if (res.Count != 0)
{
this.gvExplorer.DataSource = res;
this.gvExplorer.DataBind();
}
else
{
this.gvExplorer.DataSource = null;
this.gvExplorer.DataBind();
}
}
catch (Exception ex)
{
BasicPage.LogDebug("Грешка при зареждане на списък с прикачени файлове - метод 'FormLoad', форма 'FileExplorer.ascx'!" + ex.ToString());
BasicPage.LogError("Грешка при зареждане на списък с прикачени файлове - метод 'FormLoad', форма 'FileExplorer.ascx'!" + ex.ToString());
}
}
internal DirectoryLocation(
IBinaryDocument binaryDocument,
Directories directory,
uint offset
)
{
this.binaryDocument = binaryDocument;
this.directory = directory;
this.offset = offset;
}
internal void AddDirectoryError(
Directories directory,
uint offset,
MetadataReaderErrorKind errorKind
)
{
foreach (MetadataReaderErrorMessage errMessage in this.ErrorList.GetValuesFor((uint)errorKind)) {
DirectoryLocation/*?*/ directoryLocation = errMessage.Location as DirectoryLocation;
if (directoryLocation == null) {
continue;
}
if (directoryLocation.offset == offset && directoryLocation.directory == directory) {
return;
}
}
this.AddMetadataReaderErrorMessage(new MetadataReaderErrorMessage(this.MetadataReader.ErrorsReporter, new DirectoryLocation(this.BinaryDocument, directory, offset), errorKind));
}
private void SelectDataFromDirectory(IList<Directories> res, DirectoryInfo directory)
{
Directories dirs;
DirectoryInfo[] directories = directory.GetDirectories();
foreach (var item in directories)
{
if (!this.CanViewFolderDeleted && item.Name == "Deleted")
{
continue;
}
dirs = new Directories();
dirs.FullName = item.FullName;
dirs.Name = item.Name;
dirs.Type = "Папка";
//dirs.LastWriteTime = item.LastWriteTime.ToString();
dirs.LastWriteTime = Convert.ToDateTime(item.LastWriteTime);
dirs.IsFile = "false";
dirs.ImageSRC = "../Images/Folder.png";
//Директории не могат да се трият
dirs.DeleteVisible = false;
dirs.CbxVisible = false;
dirs.ChbxToArchiveVisible = false;
res.Add(dirs);
}
FileInfo[] files = directory.GetFiles();
foreach (var item in files)
{
dirs = new Directories();
dirs.FullName = item.FullName;
dirs.Name = item.Name;
dirs.Type = "Файл";
//dirs.LastWriteTime = item.LastWriteTime.ToString();
dirs.LastWriteTime = Convert.ToDateTime(item.LastWriteTime);
dirs.FileLength = (item.Length / 1024).ToString();
dirs.IsFile = "true";
dirs.ImageSRC = "../Images/FileXPtest.png";
dirs.DeleteVisible = (directory.Name.Equals("Deleted") ? false : CanDeleteFiles);
dirs.CbxVisible = CanViewCbxlink;
dirs.ChbxToArchiveVisible = this.CanViewToArchive;
res.Add(dirs);
}
}
