/// <summary>
/// Loads an output from a path on disk.
/// </summary>
/// <param name="path">Path to output file saved on disk.</param>
/// <param name="suppressVersionCheck">Suppresses wix.dll version mismatch check.</param>
/// <returns>Output object.</returns>
public static Output Load(string path, bool suppressVersionCheck)
{
using (FileStream stream = File.OpenRead(path))
using (FileStructure fs = FileStructure.Read(stream))
{
if (FileFormat.Wixout != fs.FileFormat)
{
throw new WixUnexpectedFileFormatException(path, FileFormat.Wixout, fs.FileFormat);
}
Uri uri = new Uri(Path.GetFullPath(path));
using (XmlReader reader = XmlReader.Create(fs.GetDataStream(), null, uri.AbsoluteUri))
{
try
{
reader.MoveToContent();
return(Output.Read(reader, suppressVersionCheck));
}
catch (XmlException xe)
{
throw new WixCorruptFileException(path, fs.FileFormat, xe);
}
}
}
}
/// <summary>
/// Uploads the file.
/// </summary>
/// <param name="curDir">The current cloud directory where the file will be uploaded</param>
public override void UploadFile(FileStructure curDir)
{
var openFileDialog = new OpenFileDialog {
Filter = "All files (*.*)|*.*", FileName = ""
};
if (openFileDialog.ShowDialog() == true)
{
string mimeType = "application/unknown";
string ext = Path.GetExtension(openFileDialog.FileName).ToLower(CultureInfo.InvariantCulture);
RegistryKey regKey = Registry.ClassesRoot.OpenSubKey(ext);
if (regKey != null && regKey.GetValue("Content Type") != null)
{
mimeType = regKey.GetValue("Content Type").ToString();
}
string shortFileName = openFileDialog.FileName;
shortFileName = shortFileName.Substring(shortFileName.LastIndexOf('\\', shortFileName.Length - 2) + 1);
var file = new Google.Apis.Drive.v3.Data.File
{
Name = shortFileName,
Parents = FolderItems[0].Parents,
};
FilesResource.CreateMediaUpload request;
using (var stream = new FileStream(openFileDialog.FileName,
FileMode.Open))
{
request = Service.Files.Create(
file, stream, mimeType);
request.Fields = "id";
request.Upload();
}
}
}
public MainWindow()
{
jsonSettings = new JsonSerializerSettings
{
PreserveReferencesHandling = PreserveReferencesHandling.All,
TypeNameHandling = TypeNameHandling.Auto
};
InitializeComponent();
var viewModel = new FileStructureViewModel();
var structure = new FileStructure();
if (File.Exists("Sample.json"))
{
structure = JsonConvert.DeserializeObject <FileStructure>(File.ReadAllText("Sample.json"), jsonSettings);
}
viewModel.Initialize(structure);
DataContext = viewModel;
this.Closed += (s, e) =>
{
File.WriteAllText("Sample.json", JsonConvert.SerializeObject(viewModel.GetStructure(), jsonSettings));
};
}
/// <summary>
/// New file structure template
/// </summary>
/// <param name="parameter">Grid parameter</param>
/// <returns>Grid invoke result, to control grid refresh</returns>
public static GridInvokeMethodResult NewFileStructureTemplate(GridFunctionParameter parameter)
{
var fileStructureWindow = new FileStructureWindow();
// Create new, maybe template
var fileStructure = new FileStructure
{
IsTemplate = true,
Name = "Template",
Directories = new List <Directory>
{
new Directory
{
Id = Guid.NewGuid(),
Name = localizationService.Translate("filestructure_add_directory")
}
}
};
fileStructureWindow.Initialize(fileStructure);
fileStructureWindow.WindowMode = Framework.UI.WindowMode.Edit;
fileStructureWindow.Show();
// Refresh grid after closed
fileStructureWindow.Closed += (s, e) =>
{
parameter.GridView.RefreshData();
};
return(new GridInvokeMethodResult
{
RefreshGrid = false,
Window = fileStructureWindow
});
}
/// <summary>
/// Gets a collection of the files.
/// </summary>
/// <returns></returns>
public override ObservableCollection <FileStructure> GetFiles()
{
FilesResource.ListRequest listRequest = Service.Files.List();
listRequest.PageSize = 1000;
listRequest.Fields = "nextPageToken, files(id, name, fileExtension, size, modifiedByMeTime, parents, trashed, ownedByMe, shared)";
listRequest.PageToken = null;
var request = listRequest.Execute();
var files = request.Files;
ObservableCollection <Google.Apis.Drive.v3.Data.File> fileList;
if (files != null && files.Count > 0)
{
fileList = new ObservableCollection <Google.Apis.Drive.v3.Data.File>();
foreach (var item in files)
{
if (item.Parents != null && item.OwnedByMe == true && item.Shared == false)
{
fileList.Add(item);
}
}
fileList.Add(new Google.Apis.Drive.v3.Data.File {
Name = "Trash", Parents = new List <string> {
Root
}, Trashed = false
});
}
else
{
fileList = new ObservableCollection <Google.Apis.Drive.v3.Data.File>();
}
return(FileStructure.Convert(fileList, Root));
}
public StageDocument AddStage(string name)
{
var stagePath = FileStructure.CreateStagePath(name);
var stage = new StageDocument(this)
{
Path = stagePath,
Name = name
};
openStages.Add(name, stage);
var info = new StageLinkInfo {
Name = name, StagePath = stagePath
};
Project.AddStage(info);
ViewModelMediator.Current.GetEvent <StageAddedEventArgs>().Raise(this, new StageAddedEventArgs()
{
Stage = info
});
Dirty = true;
return(stage);
}
/// <summary>
/// Initialize control and fill data
/// </summary>
/// <param name="fileStructure">File structure instance</param>
public FileStructureViewModel Initialize(FileStructure fileStructure)
{
var viewModel = new FileStructureViewModel(directoryTreeView, expanderMetadata);
viewModel.Initialize(fileStructure);
DataContext = viewModel;
if (!fileStructure.IsTemplate)
{
// Initialize grid
var stackId = stackService.GetStackId("STACK_Document");
searchOverviewGrid.FillOnProfileChanged = false;
searchOverviewGrid.SetBlobSettings(true, true);
searchOverviewGrid.SetConfig("Grid_Document_FileStructure_Overview", "Search_Documents", stackId, Guid.Empty, new Guid[] { });
// Set file-structure variable
searchOverviewGrid.GridView.SelectedProfileChanged += (s, e) =>
{
searchOverviewGrid.GridView.EmbeddedGridView?.SetPlaceholder("[FileStructureId]", fileStructure.Id.ToString());
};
searchOverviewGrid.GridView.Loaded += (s, e) =>
{
searchOverviewGrid.GridView.EmbeddedGridView?.SetPlaceholder("[FileStructureId]", fileStructure.Id.ToString());
};
}
// Reset dirty status
viewModel.IsDirty = false;
return(viewModel);
}
public static int CalculateRows(FileStructure fileStructure, string fileName, int fileLenght)
{
int rows = 0;
string[] lines = File.ReadAllLines(fileName);
for (int i = fileStructure.HeaderLines; i < fileLenght; i++)
{
bool plantInfo = false;
string line = lines[i];
if (line.Contains("****"))
{
i += 2;
plantInfo = true;
while (plantInfo && i < fileLenght)
{
line = lines[i];
if (line.Contains("****"))
{
plantInfo = false;
i--;
}
else
{
rows++;
i++;
}
}
}
}
return(rows);
}
private string WalkItems(FileStructure fileStructure, IList <Directory> directories)
{
var sb = new StringBuilder();
foreach (var item in directories)
{
var iconImg = GetIcon(item.DirectoryTypeId);
sb.Append("<li>");
if (HasChildren(fileStructure.Directories, item.Id))
{
sb.Append($"<span class=\"caret\">{iconImg} {System.Web.HttpUtility.HtmlEncode(item.Name)}</span>");
sb.Append("<ul class=\"nested\">");
var children = WalkItems(fileStructure, fileStructure.Directories.Where(x => x.Parent?.Id == item.Id).ToList());
if (children.Length > 0)
{
sb.Append(children.ToString());
}
sb.Append("</ul>");
}
else
{
sb.Append($"{iconImg} {item.Name}");
}
sb.Append("</li>");
}
return(sb.ToString());
}
private Directory FindWorkflowDirectory(FileStructure fileStructure, Guid workflowId, Guid documentId, int targetUserId)
{
var userDocument = documentWorkflowTrackerService.IsDocumentUserAssigned(documentId, targetUserId);
if (userDocument)
{
foreach (var directory in fileStructure.Directories)
{
if (directory.WorkflowId == workflowId && directory.IsReturnDirectory)
{
return(directory);
}
}
}
foreach (var directory in fileStructure.Directories)
{
if (directory.WorkflowId == workflowId)
{
return(directory);
}
}
// TODO: Add exception handling, a workflow is not configurated/existing, if no directory was
// found for the specific user instance
return(null);
}
/// <summary>
/// Checks if file has the correct header
/// </summary>
private bool IsValidStructure(FileStructure filestructure)
{
//the reason I chose to compare individual bytes instead of a string or a char array is speed
//it makes the code a little bit less readable, but the speed improvements are significant
return((filestructure.SignatureA == (byte)'M') &
(filestructure.SignatureB == (byte)'M') &&
(filestructure.SignatureC == (byte)'F'));
}
/// <summary>
/// Initialize directory field window
/// </summary>
/// <param name="directory">directory instance</param>
/// <param name="fileStructure">File structure instance</param>
public void Initialize(Directory directory, FileStructure fileStructure)
{
DataContext = directoryFieldControl.Initialize(directory, fileStructure);
//AddPagingObject(directory);
WindowMode = WindowMode.Edit;
}
private void Initialize()
{
Dispatcher.BeginInvoke((Action)(() =>
{
FileStructure fileStructure = null;
if (instanceDataChanged || Content == null)
{
fileStructureControl = new FileStructureControl();
Content = fileStructureControl;
}
fileStructure = fileStructureService.GetByInstanceDataGuid(InstanceDataGuid);
if (fileStructure == null)
{
MessageBoxResult selectFromTemplateResult = MessageBoxResult.None;
selectFromTemplateResult = MessageBox.Show(localizationService.Translate("filestructure_select_template_msg"), localizationService.Translate("filestructure_select_template_title"), MessageBoxButton.YesNo, MessageBoxImage.Question);
if (selectFromTemplateResult == MessageBoxResult.No)
{
// Create new, maybe from template?
fileStructure = new FileStructure
{
InstanceDataGuid = InstanceDataGuid,
StackGuid = StackHelper.Singleton.GetStackGuidByName(StackName),
IsTemplate = false
};
}
else
{
AsyncItemBox templateItemBox = null;
templateItemBox = ItemBoxManager.GetItemBoxFromDB("IB_FileStructureTemplate");
templateItemBox.ShowDialog();
if (templateItemBox.SelectedItem != null)
{
var templateId = (Guid)templateItemBox.GetSelectedItemCell("Id");
var template = fileStructureService.Get(templateId);
// Copy template and connect with instance data entry
fileStructure = template.Copy();
fileStructure.IsTemplate = false;
fileStructure.InstanceDataGuid = InstanceDataGuid;
fileStructure.StackGuid = StackHelper.Singleton.GetStackGuidByName(StackName);
}
}
}
if (fileStructure == null)
{
return;
}
fileStructureService.Save(fileStructure);
// Initialize data context and keep load order
fileStructureControl.Initialize(fileStructure);
instanceDataChanged = false;
}));
}
/// <summary>
/// Scan and connect
/// </summary>
/// <param name="fileStructure">File structure instance</param>
/// <param name="directory">Directory instance</param>
public static void ArchiveFromClipboard(FileStructure fileStructure, Directory directory)
{
var files = Clipboard.GetFileDropList();
foreach (var file in files)
{
ArchiveFile(fileStructure, directory, file);
}
}
public void DeleteFileStructureTest()
{
FileStructure.CreateGameDataPersistenceFileStructure();
FileStructure.DeleteAllPersistenceFiles();
Assert.That(Directory.Exists(FileStructure.PlayerReplayPersistencePath) &&
Directory.Exists(FileStructure.SettingPersistencePath) &&
Directory.Exists(FileStructure.PlayerScorePersistencePath), Is.False);
}
public void CreateFileStructureTest()
{
FileStructure.CreateGameDataPersistenceFileStructure();
Debug.Log(Application.persistentDataPath);
Assert.IsTrue(Directory.Exists(FileStructure.PlayerReplayPersistencePath) &&
Directory.Exists(FileStructure.SettingPersistencePath) &&
Directory.Exists(FileStructure.PlayerScorePersistencePath));
}
public byte[] StreamPrepper(FileStructure fs)
{
byte[] mainData = structureSerializer(fileStructurePrepper(fs));
List <byte> fullLoad = new List <byte>();
fullLoad.AddRange(BitConverter.GetBytes(mainData.Length));
fullLoad.AddRange(mainData);
return(fullLoad.ToArray());
}
private void CB_SkillFile_Skill_SelectedIndexChanged(object sender, EventArgs e)
{
HeroSkill tmp = CB_SkillFile_Skill.SelectedItem as HeroSkill;
TB_Skill.Text = FileStructure.FormatXml(tmp.XML);
TB_SimDesc.Text = FileStructure.FormatXml(tmp.SimDesc);
SkillChanged();
ToolTips.SetToolTip(this.CB_SkillFile_Skill, this.CB_SkillFile_Skill.Text);
}
/// <summary>
/// Gets file information.
/// </summary>
/// <returns>A list of files.</returns>
public override ObservableCollection <FileStructure> GetFiles()
{
var task = Task.Run(() => GetFolderFiles());
task.Wait();
var files = task.Result;
return(FileStructure.Convert(files));
}
//重置数据
void Reset()
{
//_AnimationControllerPath = AnimationControllerPath;
_AnimationPath = AnimationPath;
_ImagePath = ImagePath;
localLocation = true;
hasSelected = false;
frames = 30;
_fileStructure = FileStructure.二级目录;
}
public FileStructure FileStructureRetriever(NetworkStream stream)
{
byte[] length = new byte[4];
stream.Read(length, 0, 4);
byte[] mainData = new byte[BitConverter.ToInt32(length, 0)];
stream.Read(mainData, 0, mainData.Length);
FileStructure fs = fileStructurePrepper(structureDeserializer(mainData));
return(fs);
}
private void OnGUI()
{
GUILayout.BeginHorizontal();
if (GUILayout.Button("帮助"))
{
Help();
}
if (GUILayout.Button("重置工具"))
{
Reset();
}
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal();
_animatedType = (AnimatedType)EditorGUILayout.EnumPopup("动画的类型", _animatedType);
GUILayout.Label("动画帧数(10 ～ 60帧)");
frames = EditorGUILayout.IntSlider(frames, 10, 60);
GUILayout.EndHorizontal();
_fileStructure = (FileStructure)EditorGUILayout.EnumPopup("文件目录结构", _fileStructure);
GUILayout.BeginHorizontal();
if (GUILayout.Button("选择要转换的图片文件根目录"))
{
_ImagePath = EditorUtility.OpenFolderPanel("选择要转换的图片文件根目录", Application.dataPath, "null");
hasSelected = true;
}
//显示其他选项
if (hasSelected)
{
localLocation = GUILayout.Toggle(localLocation, "动画文件本地放置");
if (!localLocation)
{
if (GUILayout.Button("选择动画保存的目录"))
{
_AnimationPath = EditorUtility.OpenFolderPanel("选择要转换的图片文件根目录", Application.dataPath, "null");
}
}
if (GUILayout.Button("创建动画"))
{
BuildAniamtion();
}
GUILayout.EndHorizontal();
GUILayout.BeginVertical();
GUILayout.Label("要处理的文件目录");
EditorGUILayout.SelectableLabel(_ImagePath);
if (!localLocation)
{
GUILayout.Label("保持动画文件目录");
EditorGUILayout.SelectableLabel(_AnimationPath);
}
}
GUILayout.EndVertical();
}
public void OneTimeSetUp()
{
FileStructure.CreatePlayerScorePersistenceFolder();
playerScoreIO = new PlayerScoreIO();
foreach (var score in record)
{
playerScoreIO.SavePlayerScore(score);
}
//playerScoreIO.ReloadPlayerScoresFromSave();
}
public static int CalculateRows(FileStructure fileStructure, int fileLenght)
{
int rows = fileLenght - fileStructure.HeaderLines;
if (fileStructure.SumNeeded)
{
rows -= 2;
}
return(rows);
}
/// <summary>
/// Initialize file structure window
/// </summary>
/// <param name="fileStructure">File structure instance</param>
public void Initialize(FileStructure fileStructure)
{
if (fileStructure.StackGuid != null && fileStructure.InstanceDataGuid != null)
{
Title = $"{Title} - {stackService.GetInstanceDataContent(fileStructure.StackGuid.Value, fileStructure.InstanceDataGuid.Value)}";
}
DataContext = fileStructureControl.Initialize(fileStructure);
AddPagingObject(fileStructure);
WindowMode = WindowMode.Edit;
}
private ByteFileStructure fileStructurePrepper(FileStructure fs)
{
ByteFileStructure bfs = new ByteFileStructure()
{
fileName = Encoding.UTF8.GetBytes(fs.fileName),
fileData = fs.fileData,
dateSent = Encoding.UTF8.GetBytes(fs.dateSent),
ipSender = fs.ipSender.GetAddressBytes()
};
return(bfs);
}
private static bool CheckFormat(ExcelWorksheet worksheet, FileStructure fs)
{
var docColumnHeader = GetCellValue(worksheet, fs.HeaderRow, fs.DocumentColumn).ToString().ToLower();
var operationColumnHeader = GetCellValue(worksheet, fs.HeaderRow, fs.OperationColumn).ToString().ToLower();
if (docColumnHeader == fs.HeaderDocumentName && operationColumnHeader == fs.HeaderOperationName)
{
return(true);
}
return(false);
}
internal Control_DocumentWorkflow(DBInternPage DBInternPage)
{
InitializeComponent();
documentWorkflowUserService = CommonServiceLocator.ServiceLocator.Current.GetInstance <IDocumentWorkflowUserService>();
documentWorkflowAppSettingsService = CommonServiceLocator.ServiceLocator.Current.GetInstance <IDocumentWorkflowAppSettingsService>();
fileStructureService = CommonServiceLocator.ServiceLocator.Current.GetInstance <IFileStructureService>();
sessionService = CommonServiceLocator.ServiceLocator.Current.GetInstance <ISessionService>();
documentWorkflowAppSettings = documentWorkflowAppSettingsService.Get(DBInternPage.Guid);
if (documentWorkflowAppSettings == null || string.IsNullOrWhiteSpace(documentWorkflowAppSettings.InternalName))
{
MessageBox.Show("Konfiguration nicht vorhanden", "...");
return;
}
PageName = documentWorkflowAppSettings.PublicName;
documentWorkflowUser = documentWorkflowUserService.Get(sessionService.CurrentSession.UserId);
if (documentWorkflowUser == null)
{
documentWorkflowUser = new DocumentWorkflowUser
{
UserId = sessionService.CurrentSession.UserId,
IsDeleted = false
// TODO: Set current tenant
};
documentWorkflowUserService.Save(documentWorkflowUser);
}
fileStructureConfiguration = fileStructureService.GetByInstanceDataGuid(documentWorkflowUser.Guid);
if (fileStructureConfiguration == null)
{
fileStructureConfiguration = new FileStructure
{
IsTemplate = false,
InstanceDataGuid = documentWorkflowUser.Guid,
Id = Guid.NewGuid(),
Name = documentWorkflowAppSettings.PublicName,
StackGuid = stackGuid
};
fileStructureService.Save(fileStructureConfiguration);
}
fileStructureConfiguration.Name = $"{documentWorkflowAppSettings.PublicName}({Framework.Base.UserManager.Singleton.GetFriendlyName(sessionService.CurrentSession.UserId)})";
fileStructureControl.Initialize(fileStructureConfiguration);
Loaded += ControlLoaded;
}
private FileStructure fileStructurePrepper(ByteFileStructure bfs)
{
FileStructure fs = new FileStructure()
{
fileName = Encoding.UTF8.GetString(bfs.fileName),
fileData = bfs.fileData,
dateSent = Encoding.UTF8.GetString(bfs.dateSent),
ipSender = new IPAddress(bfs.ipSender)
};
return(fs);
}
/// <summary>
/// Saves an output to a path on disk.
/// </summary>
/// <param name="path">Path to save output file to on disk.</param>
public void Save(string path)
{
Directory.CreateDirectory(Path.GetDirectoryName(Path.GetFullPath(path)));
using (FileStream stream = File.Create(path))
using (FileStructure fs = FileStructure.Create(stream, FileFormat.Wixout, null))
using (XmlWriter writer = XmlWriter.Create(fs.GetDataStream()))
{
writer.WriteStartDocument();
this.Write(writer);
writer.WriteEndDocument();
}
}
