/// <summary> /// Loads the definition contents asynchronous. /// </summary> /// <param name="parameters">The parameters.</param> /// <param name="path">The path.</param> /// <returns>Task<System.String>.</returns> public Task <string> LoadDefinitionContentsAsync(ModPatchExporterParameters parameters, string path) { var patchPath = Path.Combine(parameters.RootPath, parameters.PatchName, path); if (File.Exists(patchPath)) { return(File.ReadAllTextAsync(patchPath)); } return(Task.FromResult(string.Empty)); }
/// <summary> /// export definition as an asynchronous operation. /// </summary> /// <param name="parameters">The parameters.</param> /// <returns>Task<System.Boolean>.</returns> /// <exception cref="ArgumentNullException">Game.</exception> /// <exception cref="ArgumentNullException">Definitions.</exception> public async Task <bool> ExportDefinitionAsync(ModPatchExporterParameters parameters) { if (string.IsNullOrWhiteSpace(parameters.Game)) { throw new ArgumentNullException("Game."); } var definitionsInvalid = (parameters.Definitions == null || parameters.Definitions.Count() == 0) && (parameters.OrphanConflicts == null || parameters.OrphanConflicts.Count() == 0) && (parameters.OverwrittenConflicts == null || parameters.OverwrittenConflicts.Count() == 0) && (parameters.CustomConflicts == null || parameters.CustomConflicts.Count() == 0); if (definitionsInvalid) { throw new ArgumentNullException("Definitions."); } var definitionInfoProvider = definitionInfoProviders.FirstOrDefault(p => p.CanProcess(parameters.Game)); if (definitionInfoProvider != null) { var results = new List <bool>(); if (parameters.Definitions?.Count() > 0) { results.Add(await CopyBinariesAsync(parameters.Definitions.Where(p => p.ValueType == Parser.Common.ValueType.Binary), GetPatchRootPath(parameters.RootPath, parameters.PatchName), false)); results.Add(await WriteMergedContentAsync(parameters.Definitions.Where(p => p.ValueType != Parser.Common.ValueType.Binary), GetPatchRootPath(parameters.RootPath, parameters.PatchName), parameters.Game, false, FileNameGeneration.GenerateFileName)); } if (parameters.OrphanConflicts?.Count() > 0) { results.Add(await CopyBinariesAsync(parameters.OrphanConflicts.Where(p => p.ValueType == Parser.Common.ValueType.Binary), GetPatchRootPath(parameters.RootPath, parameters.PatchName), false)); results.Add(await WriteMergedContentAsync(parameters.OrphanConflicts.Where(p => p.ValueType != Parser.Common.ValueType.Binary), GetPatchRootPath(parameters.RootPath, parameters.PatchName), parameters.Game, false, FileNameGeneration.GenerateFileName)); } if (parameters.OverwrittenConflicts?.Count() > 0) { results.Add(await CopyBinariesAsync(parameters.OverwrittenConflicts.Where(p => p.ValueType == Parser.Common.ValueType.Binary), GetPatchRootPath(parameters.RootPath, parameters.PatchName), false)); results.Add(await WriteMergedContentAsync(parameters.OverwrittenConflicts.Where(p => p.ValueType != Parser.Common.ValueType.Binary), GetPatchRootPath(parameters.RootPath, parameters.PatchName), parameters.Game, false, FileNameGeneration.UseExistingFileNameAndWriteEmptyFiles)); } if (parameters.CustomConflicts?.Count() > 0) { results.Add(await WriteMergedContentAsync(parameters.CustomConflicts.Where(p => p.ValueType != Parser.Common.ValueType.Binary), GetPatchRootPath(parameters.RootPath, parameters.PatchName), parameters.Game, true, FileNameGeneration.UseExistingFileName)); } return(results.All(p => p)); } return(false); }
/// <summary> /// rename patch mod as an asynchronous operation. /// </summary> /// <param name="parameters">The parameters.</param> /// <returns>Task<System.Boolean>.</returns> public async Task <bool> RenamePatchModAsync(ModPatchExporterParameters parameters) { var result = await CopyPathModInternalAsync(parameters); if (result) { var oldPath = Path.Combine(parameters.RootPath, parameters.ModPath); if (Directory.Exists(oldPath)) { Directory.Delete(oldPath, true); } } return(result); }
/// <summary> /// Gets the patch files. /// </summary> /// <param name="parameters">The parameters.</param> /// <returns>IEnumerable<System.String>.</returns> public IEnumerable <string> GetPatchFiles(ModPatchExporterParameters parameters) { var path = GetPatchRootPath(parameters.RootPath, parameters.PatchName); var files = new List <string>(); if (Directory.Exists(path)) { foreach (var item in Directory.EnumerateFiles(path, "*", SearchOption.AllDirectories)) { var relativePath = item.Replace(path, string.Empty).Trim(Path.DirectorySeparatorChar); if (relativePath.Contains(Path.DirectorySeparatorChar) && !relativePath.Contains(StateHistory, StringComparison.OrdinalIgnoreCase)) { files.Add(relativePath); } } } return(files); }
/// <summary> /// Saves the state asynchronous. /// </summary> /// <param name="parameters">The parameters.</param> /// <returns>Task<System.Boolean>.</returns> public async Task <bool> SaveStateAsync(ModPatchExporterParameters parameters) { var state = await GetPatchStateInternalAsync(parameters, true); if (state == null) { state = DIResolver.Get <IPatchState>(); } var modifiedHistory = new List <IDefinition>(); var path = Path.Combine(GetPatchRootPath(parameters.RootPath, parameters.PatchName)); state.IgnoreConflictPaths = parameters.IgnoreConflictPaths; state.ResolvedConflicts = MapDefinitions(parameters.ResolvedConflicts, false); state.Conflicts = MapDefinitions(parameters.Conflicts, false); state.OrphanConflicts = MapDefinitions(parameters.OrphanConflicts, false); state.IgnoredConflicts = MapDefinitions(parameters.IgnoredConflicts, false); state.OverwrittenConflicts = MapDefinitions(parameters.OverwrittenConflicts, false); state.CustomConflicts = MapDefinitions(parameters.CustomConflicts, false); state.Mode = parameters.Mode; var history = state.ConflictHistory != null?state.ConflictHistory.ToList() : new List <IDefinition>(); var indexed = DIResolver.Get <IIndexedDefinitions>(); indexed.InitMap(history); if (parameters.ResolvedConflicts != null) { foreach (var item in parameters.ResolvedConflicts.Where(s => !string.IsNullOrWhiteSpace(s.Code))) { var existingHits = indexed.GetByTypeAndId(item.TypeAndId).ToList(); var existing = existingHits.FirstOrDefault(p => item.Code.Equals(p.Code)); if (existing == null) { history.RemoveAll(p => existingHits.Any(x => p.Equals(x))); history.Add(item); modifiedHistory.Add(item); } else { existingHits.Remove(existing); history.RemoveAll(p => existingHits.Any(x => p.Equals(x))); } } } if (parameters.Definitions != null) { foreach (var item in parameters.Definitions.Where(s => !string.IsNullOrWhiteSpace(s.Code) && !modifiedHistory.Any(p => p.TypeAndId.Equals(s.TypeAndId)))) { var existingHits = indexed.GetByTypeAndId(item.TypeAndId).ToList(); history.RemoveAll(p => existingHits.Any(x => p.Equals(x))); history.Add(item); modifiedHistory.Add(item); } } state.ConflictHistory = MapDefinitions(history, true); var externallyLoadedCode = cache.Get <HashSet <string> >(CacheStatePrefix, CacheExternalCodeKey); if (externallyLoadedCode == null) { externallyLoadedCode = new HashSet <string>(); cache.Set(CacheStatePrefix, CacheExternalCodeKey, externallyLoadedCode); } return(StoreState(state, modifiedHistory, externallyLoadedCode, path)); }
/// <summary> /// get patch state as an asynchronous operation. /// </summary> /// <param name="parameters">The parameters.</param> /// <param name="loadExternalCode">if set to <c>true</c> [load external code].</param> /// <returns>IPatchState.</returns> public async Task <IPatchState> GetPatchStateAsync(ModPatchExporterParameters parameters, bool loadExternalCode = true) { return(await GetPatchStateInternalAsync(parameters, loadExternalCode)); }
/// <summary> /// Copies the patch mod asynchronous. /// </summary> /// <param name="parameters">The parameters.</param> /// <returns>Task<System.Boolean>.</returns> public Task <bool> CopyPatchModAsync(ModPatchExporterParameters parameters) { return(CopyPathModInternalAsync(parameters)); }