public void Init(LoadingControl loadingControl)
{
if (this.loadingControl == null)
{
this.loadingControl = loadingControl;
}
this.settingsContainer = Settings.settingsContainer;
}
public GitTfsDialog(IGitUICommands commands, SettingsContainer settings, IEnumerable<string> tfsRemotes)
{
_commands = commands;
_settings = settings;
InitializeComponent();
TfsRemoteComboBox.DataSource = tfsRemotes.ToList();
InitializeFromSettings();
}
static void Save() {
using (FileStream stream = new FileStream("Settings.xml", FileMode.Create)) {
SettingsContainer container = new SettingsContainer();
XmlWriterSettings writerSettings = new XmlWriterSettings() {
OmitXmlDeclaration = true,
Indent = true
};
XmlSerializerNamespaces namespaces = new XmlSerializerNamespaces();
namespaces.Add("", "");
using (XmlWriter writer = XmlWriter.Create(stream, writerSettings)) {
new XmlSerializer(typeof (SettingsContainer)).Serialize(writer, container, namespaces);
}
}
}
static GlobalSettings() {
try {
_instance = Download();
Debug.Log("Settings file loaded from remote website");
}
catch {
try {
_instance = Load();
Debug.LogWarning("Settings file loaded from local backup");
}
catch {
_instance = new SettingsContainer();
Save();
Debug.LogError("New settings file created");
}
}
}
public static void SetDate(string name, DateTime?value)
{
SettingsContainer.SetDate(name, value);
}
private async Task <(int UpdatesMade, bool PullRequestCreated)> MakeUpdatePullRequests(
IGitDriver git, RepositoryData repository,
NuGetSources sources, SettingsContainer settings,
IReadOnlyCollection <PackageUpdateSet> updates)
{
_logger.Normal(UpdatesLogger.OldVersionsToBeUpdated(updates));
await git.Checkout(repository.DefaultBranch);
// branch
var branchWithChanges = BranchNamer.MakeName(updates, settings.BranchSettings.BranchNameTemplate);
_logger.Detailed($"Using branch name: '{branchWithChanges}'");
var ditCheckOut = await git.CheckoutNewBranch(branchWithChanges);
if (!ditCheckOut)
{
await git.CheckoutRemoteToLocal(branchWithChanges);
}
var filteredUpdates = await _existingCommitFilter.Filter(git, updates, repository.DefaultBranch, branchWithChanges);
foreach (var filtered in updates.Where(u => !filteredUpdates.Contains(u)))
{
var commitMessage = _collaborationFactory.CommitWorder.MakeCommitMessage(filtered);
_logger.Normal($"Commit '{commitMessage}' already in branch '{branchWithChanges}'");
}
var haveUpdates = filteredUpdates.Any();
foreach (var updateSet in filteredUpdates)
{
var commitMessage = _collaborationFactory.CommitWorder.MakeCommitMessage(updateSet);
await _updateRunner.Update(updateSet, sources);
await git.Commit(commitMessage);
}
bool pullRequestCreated = false;
// bug: pr might not have been created yet
if (haveUpdates)
{
await git.Push(repository.Remote, branchWithChanges);
string qualifiedBranch;
if (!repository.IsFork) //check if we are on a fork, if so qualify the branch name
{
qualifiedBranch = branchWithChanges;
}
else
{
qualifiedBranch = repository.Push.Owner + ":" + branchWithChanges;
}
bool pullRequestExists = await _collaborationFactory.CollaborationPlatform.PullRequestExists(repository.Pull, qualifiedBranch, repository.DefaultBranch);
if (!pullRequestExists)
{
var title = _collaborationFactory.CommitWorder.MakePullRequestTitle(updates);
var body = _collaborationFactory.CommitWorder.MakeCommitDetails(updates);
var pullRequestRequest = new PullRequestRequest(qualifiedBranch, title, repository.DefaultBranch, settings.BranchSettings.DeleteBranchAfterMerge, settings.SourceControlServerSettings.Repository.SetAutoMerge)
{
Body = body
};
await _collaborationFactory.CollaborationPlatform.OpenPullRequest(repository.Pull, pullRequestRequest, settings.SourceControlServerSettings.Labels);
pullRequestCreated = true;
}
else
{
_logger.Normal($"A pull request already exists for {repository.DefaultBranch} <= {qualifiedBranch}");
}
}
await git.Checkout(repository.DefaultBranch);
return(filteredUpdates.Count, pullRequestCreated);
}
protected virtual ValidationResult ValidateSettings(SettingsContainer settings)
{
return(ValidationResult.Success);
}
public ParsingController(SettingsContainer settings)
{
_settings = settings;
}
protected override async Task <int> Run(SettingsContainer settings)
{
await _engine.Run(settings);
return(0);
}
public static Color GetColor(string name, Color defaultValue)
{
return(SettingsContainer.GetColor(name, defaultValue));
}
private void ParseLog(object logFile)
{
UploadController up_controller = null;
System.Globalization.CultureInfo before = Thread.CurrentThread.CurrentCulture;
Thread.CurrentThread.CurrentCulture =
new System.Globalization.CultureInfo("en-US");
GridRow row = new GridRow(logFile as string, "")
{
BgWorker = new System.ComponentModel.BackgroundWorker()
{
WorkerReportsProgress = true
}
};
row.Metadata.FromConsole = true;
FileInfo fInfo = new FileInfo(row.Location);
if (!fInfo.Exists)
{
throw new CancellationException(row, new FileNotFoundException("File does not exist", fInfo.FullName));
}
//Upload Process
Task <string> DREITask = null;
Task <string> DRRHTask = null;
Task <string> RaidarTask = null;
string[] uploadresult = new string[3] {
"", "", ""
};
try
{
SettingsContainer settings = new SettingsContainer(Properties.Settings.Default);
ParsingController control = new ParsingController(settings);
if (!GeneralHelper.HasFormat())
{
throw new CancellationException(row, new Exception("No output format has been selected"));
}
if (GeneralHelper.IsSupportedFormat(fInfo.Name))
{
//Process evtc here
ParsedLog log = control.ParseLog(row, fInfo.FullName);
Console.Write("Log Parsed\n");
if (Properties.Settings.Default.UploadToDPSReports)
{
Console.Write("Uploading to DPSReports using EI\n");
if (up_controller == null)
{
up_controller = new UploadController();
}
DREITask = Task.Factory.StartNew(() => up_controller.UploadDPSReportsEI(fInfo));
if (DREITask != null)
{
while (!DREITask.IsCompleted)
{
System.Threading.Thread.Sleep(100);
}
uploadresult[0] = DREITask.Result;
}
else
{
uploadresult[0] = "Failed to Define Upload Task";
}
}
if (Properties.Settings.Default.UploadToDPSReportsRH)
{
Console.Write("Uploading to DPSReports using RH\n");
if (up_controller == null)
{
up_controller = new UploadController();
}
DRRHTask = Task.Factory.StartNew(() => up_controller.UploadDPSReportsRH(fInfo));
if (DRRHTask != null)
{
while (!DRRHTask.IsCompleted)
{
System.Threading.Thread.Sleep(100);
}
uploadresult[1] = DRRHTask.Result;
}
else
{
uploadresult[1] = "Failed to Define Upload Task";
}
}
if (Properties.Settings.Default.UploadToRaidar)
{
Console.Write("Uploading to Raidar\n");
if (up_controller == null)
{
up_controller = new UploadController();
}
RaidarTask = Task.Factory.StartNew(() => up_controller.UploadRaidar(fInfo));
if (RaidarTask != null)
{
while (!RaidarTask.IsCompleted)
{
System.Threading.Thread.Sleep(100);
}
uploadresult[2] = RaidarTask.Result;
}
else
{
uploadresult[2] = "Failed to Define Upload Task";
}
}
//Creating File
//save location
DirectoryInfo saveDirectory;
if (Properties.Settings.Default.SaveAtOut || Properties.Settings.Default.OutLocation == null)
{
//Default save directory
saveDirectory = fInfo.Directory;
}
else
{
//Customised save directory
saveDirectory = new DirectoryInfo(Properties.Settings.Default.OutLocation);
}
if (saveDirectory == null)
{
throw new CancellationException(row, new InvalidDataException("Save Directory not found"));
}
string result = log.FightData.Success ? "kill" : "fail";
string encounterLengthTerm = Properties.Settings.Default.AddDuration ? "_" + (log.FightData.FightDuration / 1000).ToString() + "s" : "";
string PoVClassTerm = Properties.Settings.Default.AddPoVProf ? "_" + log.PlayerList.Find(x => x.AgentItem.Name.Split(':')[0] == log.LogData.PoV.Split(':')[0]).Prof.ToLower() : "";
StatisticsCalculator statisticsCalculator = new StatisticsCalculator(settings);
StatisticsCalculator.Switches switches = new StatisticsCalculator.Switches();
if (Properties.Settings.Default.SaveOutHTML)
{
HTMLBuilder.UpdateStatisticSwitches(switches);
}
if (Properties.Settings.Default.SaveOutCSV)
{
CSVBuilder.UpdateStatisticSwitches(switches);
}
if (Properties.Settings.Default.SaveOutJSON || Properties.Settings.Default.SaveOutXML)
{
RawFormatBuilder.UpdateStatisticSwitches(switches);
}
Statistics statistics = statisticsCalculator.CalculateStatistics(log, switches);
Console.Write("Statistics Computed\n");
string fName = fInfo.Name.Split('.')[0];
fName = $"{fName}{PoVClassTerm}_{log.FightData.Logic.Extension}{encounterLengthTerm}_{result}";
if (Properties.Settings.Default.SaveOutHTML)
{
string outputFile = Path.Combine(
saveDirectory.FullName,
$"{fName}.html"
);
using (FileStream fs = new FileStream(outputFile, FileMode.Create, FileAccess.Write))
{
using (StreamWriter sw = new StreamWriter(fs))
{
var builder = new HTMLBuilder(log, settings, statistics, uploadresult);
builder.CreateHTML(sw, saveDirectory.FullName);
}
}
}
if (Properties.Settings.Default.SaveOutCSV)
{
string outputFile = Path.Combine(
saveDirectory.FullName,
$"{fName}.csv"
);
using (FileStream fs = new FileStream(outputFile, FileMode.Create, FileAccess.Write))
{
using (StreamWriter sw = new StreamWriter(fs, Encoding.GetEncoding(1252)))
{
var builder = new CSVBuilder(sw, ",", log, settings, statistics, uploadresult);
builder.CreateCSV();
}
}
}
if (Properties.Settings.Default.SaveOutJSON)
{
string outputFile = Path.Combine(
saveDirectory.FullName,
$"{fName}.json"
);
using (FileStream fs = new FileStream(outputFile, FileMode.Create, FileAccess.Write))
{
using (StreamWriter sw = new StreamWriter(fs, Encoding.UTF8))
{
var builder = new RawFormatBuilder(sw, log, settings, statistics, uploadresult);
builder.CreateJSON();
}
}
}
if (Properties.Settings.Default.SaveOutXML)
{
string outputFile = Path.Combine(
saveDirectory.FullName,
$"{fName}.xml"
);
using (FileStream fs = new FileStream(outputFile, FileMode.Create, FileAccess.Write))
{
using (StreamWriter sw = new StreamWriter(fs, Encoding.UTF8))
{
var builder = new RawFormatBuilder(sw, log, settings, statistics, uploadresult);
builder.CreateXML();
}
}
}
Console.Write("Generation Done\n");
}
else
{
Console.Error.Write("Not EVTC");
throw new CancellationException(row, new InvalidDataException("Not EVTC"));
}
}
catch (SkipException s)
{
Console.Error.Write(s.Message);
throw new CancellationException(row, s);
}
catch (TooShortException t)
{
Console.Error.Write(t.Message);
throw new CancellationException(row, t);
}
catch (Exception ex) when(!System.Diagnostics.Debugger.IsAttached)
{
Console.Error.Write(ex.Message);
throw new CancellationException(row, ex);
}
finally
{
Thread.CurrentThread.CurrentCulture = before;
}
}
public static void SetColor(string name, Color?value)
{
SettingsContainer.SetColor(name, value);
}
public static Color?GetColor(string name)
{
return(SettingsContainer.GetColor(name));
}
public static Font GetFont(string name, Font defaultValue)
{
return(SettingsContainer.GetFont(name, defaultValue));
}
public static void SetFont(string name, Font value)
{
SettingsContainer.SetFont(name, value);
}
public static DateTime?GetDate(string name)
{
return(SettingsContainer.GetDate(name));
}
public static void SetInt(string name, int?value)
{
SettingsContainer.SetInt(name, value);
}
public static void SetEnum <T>(string name, T value)
{
SettingsContainer.SetEnum(name, value);
}
public IPackageUpdater Create(SettingsContainer settings)
{
return(new PackageUpdater(_githubCreator.Create(settings), _updateRunner, _logger));
}
public static T GetEnum <T>(string name, T defaultValue) where T : struct
{
return(SettingsContainer.GetEnum(name, defaultValue));
}
protected override ValidationResult PopulateSettings(SettingsContainer settings)
{
var baseResult = base.PopulateSettings(settings);
if (!baseResult.IsSuccess)
{
return(baseResult);
}
var fileSettings = FileSettingsCache.GetSettings();
var endpoint = Concat.FirstValue(ApiEndpoint, fileSettings.Api, settings.SourceControlServerSettings.Repository?.ApiUri.ToString());
var forkMode = ForkMode ?? fileSettings.ForkMode;
var platform = Platform ?? fileSettings.Platform;
if (!Uri.TryCreate(endpoint, UriKind.Absolute, out var baseUri))
{
return(ValidationResult.Failure($"Bad Api Base '{endpoint}'"));
}
try
{
var collaborationResult = CollaborationFactory.Initialise(
baseUri, PersonalAccessToken,
forkMode, platform);
if (!collaborationResult.IsSuccess)
{
return(collaborationResult);
}
}
#pragma warning disable CA1031
catch (Exception ex)
#pragma warning restore CA1031
{
return(ValidationResult.Failure(ex.Message));
}
if (CollaborationFactory.Settings.Token == null)
{
return(ValidationResult.Failure("The required access token was not found"));
}
settings.UserSettings.ConsolidateUpdatesInSinglePullRequest =
Concat.FirstValue(Consolidate, fileSettings.Consolidate, false);
const int defaultMaxPackageUpdates = 3;
settings.PackageFilters.MaxPackageUpdates =
Concat.FirstValue(MaxPackageUpdates, fileSettings.MaxPackageUpdates, defaultMaxPackageUpdates);
var defaultLabels = new List <string> {
"nukeeper"
};
settings.SourceControlServerSettings.Labels =
Concat.FirstPopulatedList(Label, fileSettings.Label, defaultLabels);
var deleteBranchAfterMergeValid = PopulateDeleteBranchAfterMerge(settings);
if (!deleteBranchAfterMergeValid.IsSuccess)
{
return(deleteBranchAfterMergeValid);
}
return(ValidationResult.Success);
}
public static void SetNullableEnum <T>(string name, T?value) where T : struct
{
SettingsContainer.SetNullableEnum(name, value);
}
protected override void PopulateSettings(SettingsContainer settings)
{
base.PopulateSettings(settings);
settings.ModalSettings.Mode = RunMode.Inspect;
}
public static T?GetNullableEnum <T>(string name) where T : struct
{
return(SettingsContainer.GetNullableEnum <T>(name));
}
public async Task <(int UpdatesMade, bool ThresholdReached)> MakeUpdatePullRequests(
IGitDriver git,
RepositoryData repository,
IReadOnlyCollection <PackageUpdateSet> updates,
NuGetSources sources,
SettingsContainer settings
)
{
if (settings == null)
{
throw new ArgumentNullException(nameof(settings));
}
if (git == null)
{
throw new ArgumentNullException(nameof(git));
}
if (repository == null)
{
throw new ArgumentNullException(nameof(repository));
}
var openPrs = await _collaborationFactory.CollaborationPlatform.GetNumberOfOpenPullRequests(
repository.Pull.Owner,
repository.Pull.Name
);
var allowedPrs = settings.UserSettings.MaxOpenPullRequests;
if (openPrs >= allowedPrs)
{
_logger.Normal("Number of open pull requests equals or exceeds allowed number of open pull requests.");
return(0, true);
}
int totalCount = 0;
var groups = UpdateConsolidator.Consolidate(updates,
settings.UserSettings.ConsolidateUpdatesInSinglePullRequest);
foreach (var updateSets in groups)
{
var(updatesMade, pullRequestCreated) = await MakeUpdatePullRequests(
git, repository,
sources, settings, updateSets);
totalCount += updatesMade;
if (pullRequestCreated)
{
openPrs++;
}
if (openPrs == allowedPrs)
{
return(totalCount, true);
}
}
return(totalCount, false);
}
public static void SetString(string name, string value)
{
SettingsContainer.SetString(name, value);
}
protected virtual void PopulateSettings(SettingsContainer settings)
{
}
private void SaveSettings(string settingfilename)
{
SettingsContainer allsettings = new SettingsContainer()
{
BrokerSettings = this.serversett,
Topics = this.uitopics.ToList()
};
if (this.currenttopic != null)
allsettings.currenttopicpath = this.currenttopic.Path;
XmlSerializer serializer = new XmlSerializer(typeof(SettingsContainer));
string settingname = settingfilename.EndsWith(".xml") ? settingfilename : settingfilename + ".xml";
if (!Directory.Exists(settingsDirectory))
Directory.CreateDirectory(settingsDirectory);
string settingspath = Path.Combine(settingsDirectory, settingname);
using (FileStream fs = new FileStream(settingspath, FileMode.Create))
{
serializer.Serialize(fs, allsettings);
}
}
protected abstract Task <int> Run(SettingsContainer settings);
public static int?GetInt(string name)
{
return(SettingsContainer.GetInt(name));
}
public static string GetString(string name, string defaultValue)
{
return(SettingsContainer.GetString(name, defaultValue));
}
public static DateTime GetDate(string name, DateTime defaultValue)
{
return(SettingsContainer.GetDate(name, defaultValue));
}
void RenderSelectableContainer(SettingsContainer pContainer, bool pOdd)
{
bool selected = false;
if(mSelectedContainer != null && pContainer.mType == mSelectedContainer.mConcerningType)
{
selected = GUILayout.Button(pContainer.DisplayName,UEDSStyles.selectedListEntry, GUILayout.MaxWidth(kListWidth));
}else
{
selected = GUILayout.Button(pContainer.DisplayName,(pOdd)? UEDSStyles.selectableListEntryOdd : UEDSStyles.selectableListEntry, GUILayout.MaxWidth(kListWidth));
}
if(pContainer.DisplayGizmo != null && pContainer.DisplayGizmo.image != null)
{
Rect r = GUILayoutUtility.GetLastRect();
float height = pContainer.DisplayGizmo.image.height / (float)pContainer.DisplayGizmo.image.width * 16;
GUI.DrawTexture(new Rect( r.x +(r.width - 26), r.y + (r.height - height) / 2, 16,height),pContainer.DisplayGizmo.image);
}
if(selected)
{
mUpdateContainer = true;
mSelectedSettingsContainer = pContainer;
mSelectedContainerName = Settings.kDefaultInstanceName;
}
}
public async Task <int> Run(RepositorySettings repository,
GitUsernamePasswordCredentials credentials,
SettingsContainer settings, User user)
{
try
{
var repositoryData = await BuildGitRepositorySpec(repository, credentials.Username);
if (repositoryData == null)
{
return(0);
}
// should perform the remote check for "is this a .NET repo"
// (and also not a github fork)
// only when we have multiple remote repos
// otherwise it's ok to work locally, and check there
if (!(settings.SourceControlServerSettings.Scope == ServerScope.Repository || repository.IsLocalRepo))
{
var remoteRepoContainsDotNet = await _repositoryFilter.ContainsDotNetProjects(repository);
if (!remoteRepoContainsDotNet)
{
return(0);
}
}
IFolder folder;
if (repository.IsLocalRepo)
{
folder = new Folder(_logger, new DirectoryInfo(repository.RemoteInfo.LocalRepositoryUri.AbsolutePath));
settings.WorkingFolder = new Folder(_logger, new DirectoryInfo(repository.RemoteInfo.WorkingFolder.AbsolutePath));
repositoryData.DefaultBranch = repository.RemoteInfo.BranchName;
repositoryData.Remote = repository.RemoteInfo.RemoteName;
}
else
{
folder = _folderFactory.UniqueTemporaryFolder();
settings.WorkingFolder = folder;
}
if (!string.IsNullOrEmpty(repository.TargetBranch))
{
repositoryData.DefaultBranch = repository.TargetBranch;
}
repositoryData.IsLocalRepo = repository.IsLocalRepo;
var git = new LibGit2SharpDriver(_logger, folder, credentials, user);
var updatesDone = await _repositoryUpdater.Run(git, repositoryData, settings);
if (!repository.IsLocalRepo)
{
folder.TryDelete();
}
return(updatesDone);
}
catch (Exception ex)
{
_logger.Error($"Failed on repo {repository.RepositoryName}", ex);
return(1);
}
}
void SaveSettings(SettingsContainer settings)
{
/*suppress warning*/ _ = /**/ SettingsManager.SaveAsync(settings);
}
public static void SetBool(string name, bool?value)
{
SettingsContainer.SetBool(name, value);
}
