public SourceWatcherService(IHostingEnvironment env, IConfiguration configuration, IInvokerCacheService invokerCacheService, IGistCacheService gistCacheService, ISearchService searchService) { SourceWatcherType watcherType; if (env.IsProduction()) { string watcherTypeRegistryValue = Registry.GetValue(RegistryConstants.SourceWatcherRegistryPath, RegistryConstants.WatcherTypeKey, 0).ToString(); if (!Enum.TryParse <SourceWatcherType>(watcherTypeRegistryValue, out watcherType)) { throw new NotSupportedException($"Source Watcher Type : {watcherTypeRegistryValue} not supported."); } } else { watcherType = Enum.Parse <SourceWatcherType>(configuration[$"SourceWatcher:{RegistryConstants.WatcherTypeKey}"]); } switch (watcherType) { case SourceWatcherType.LocalFileSystem: _watcher = new LocalFileSystemWatcher(env, configuration, invokerCacheService, gistCacheService); break; case SourceWatcherType.Github: IGithubClient githubClient = new GithubClient(env, configuration); _watcher = new GitHubWatcher(env, configuration, invokerCacheService, gistCacheService, githubClient, searchService); break; default: throw new NotSupportedException("Source Watcher Type not supported"); } }
public async Task ShouldNotCreateIssue(string repoUrl, string branch, string method, string arguments, DateTime errorOccurredAt, bool success) { // Not testing SubscriptionUpdateHistoryEntry since this is always "no" for them. RepositoryBranchUpdateHistoryEntry repositoryBranchUpdate = new RepositoryBranchUpdateHistoryEntry { Repository = repoUrl, Branch = branch, Method = method, Timestamp = errorOccurredAt, Arguments = arguments, Success = success }; Repository repository = new Repository(); GithubClient.Setup(x => x.Repository.Get(It.IsAny <string>(), It.IsAny <string>())).ReturnsAsync(repository); Maestro.Data.Models.Subscription subscription = new Maestro.Data.Models.Subscription(); Context.Subscriptions.Add(subscription); Context.SaveChanges(); Mock <Issue> issue = new Mock <Issue>(); GithubClient.Setup(x => x.Issue.Create(It.IsAny <long>(), It.IsAny <NewIssue>())).ReturnsAsync(issue.Object); Context.RepoBranchUpdateInMemory = new List <RepositoryBranchUpdateHistoryEntry> { repositoryBranchUpdate }; DependencyUpdateErrorProcessor errorProcessor = ActivatorUtilities.CreateInstance <DependencyUpdateErrorProcessor>(Scope.ServiceProvider, Context); await errorProcessor.ProcessDependencyUpdateErrorsAsync(); GithubClient.Verify(x => x.Issue.Create(It.IsAny <long>(), It.IsAny <NewIssue>()), Times.Never); }
public object Post(AddGithubSSHKeyToCurrentUser request) { var context = TepWebContext.GetWebContext(PagePrivileges.UserView); WebGithubProfile result; try { context.Open(); context.LogInfo(this, string.Format("/github/sshkey POST")); GithubProfile user = GithubProfile.FromId(context, context.UserId); UserTep userTep = UserTep.FromId(context, context.UserId); userTep.LoadSSHPubKey(); user.PublicSSHKey = userTep.SshPubKey; GithubClient githubClient = new GithubClient(context); if (!user.IsAuthorizationTokenValid()) { throw new UnauthorizedAccessException("Invalid token"); } if (user.PublicSSHKey == null) { throw new UnauthorizedAccessException("No available public ssh key"); } githubClient.AddSshKey("Terradue ssh key", user.PublicSSHKey, user.Name, user.Token); context.LogDebug(this, string.Format("User {0} added Terradue ssh key to his github account", userTep.Username)); result = new WebGithubProfile(user); context.Close(); } catch (Exception e) { context.LogError(this, e.Message, e); context.Close(); throw e; } return(result); }
public async Task TestGetRepos() { const string reposResp = "[{\"id\": 221949625," + "\"name\": \"Jija\"," + "\"html_url\": \"https://github.com/7Nikita/Jija\"," + "\"owner\": {" + "\"login\": \"7Nikita\"," + "\"avatar_url\": \"https://avatars1.githubusercontent.com/u/20500960?v=4\"," + "\"html_url\": \"https://github.com/7Nikita\"" + "}}" + "]"; _server.Given(Request.Create() .WithPath("/user/repos") .UsingGet() ) .RespondWith(Response.Create() .WithStatusCode(250) .WithBody(reposResp) ); _client = new GithubClient(_config, _httpClient) { Token = "testToken", ApiUrl = _server.Urls[0] }; var reposInfo = await _client.GetRepos(); Assert.AreEqual(1, reposInfo.Count); }
public async Task TestGetUserInfo() { const string userResp = "{" + "\"login\": \"7Nikita\"," + "\"avatar_url\": \"https://avatars1.githubusercontent.com/u/20500960?v=4\"," + "\"html_url\": \"https://github.com/7Nikita\"," + "\"bio\": null" + "}"; _server.Given(Request.Create() .WithPath("/user") .UsingGet() ) .RespondWith(Response.Create() .WithStatusCode(250) .WithBody(userResp) ); _client = new GithubClient(_config, _httpClient) { Token = "testToken", ApiUrl = _server.Urls[0] }; var userInfo = await _client.GetUserInfo(); Assert.AreEqual("7Nikita", userInfo.login); Assert.AreEqual("https://github.com/7Nikita", userInfo.html_url); }
private static async Task CheckMissedBuildsBetween(DiscordClient discordClient, DiscordChannel compatChannel, string?previousUpdatePr, string?latestUpdatePr, CancellationToken cancellationToken) { if (!int.TryParse(previousUpdatePr, out var oldestPr) || !int.TryParse(latestUpdatePr, out var newestPr)) { return; } var mergedPrs = await GithubClient.GetClosedPrsAsync(cancellationToken).ConfigureAwait(false); // this will cache 30 latest PRs var newestPrCommit = await GithubClient.GetPrInfoAsync(newestPr, cancellationToken).ConfigureAwait(false); var oldestPrCommit = await GithubClient.GetPrInfoAsync(oldestPr, cancellationToken).ConfigureAwait(false); if (newestPrCommit?.MergedAt == null || oldestPrCommit?.MergedAt == null) { return; } mergedPrs = mergedPrs?.Where(pri => pri.MergedAt.HasValue) .OrderBy(pri => pri.MergedAt !.Value) .SkipWhile(pri => pri.Number != oldestPr) .Skip(1) .TakeWhile(pri => pri.Number != newestPr) .ToList(); if (mergedPrs is null or { Count : 0 })
public async Task CreateIssue() { RepositoryBranchUpdateHistoryEntry firstError = new RepositoryBranchUpdateHistoryEntry { Repository = RepoUrl, Branch = BranchOne, Method = "ProcessPendingUpdatesAsync", Timestamp = new DateTime(2200, 1, 1), Arguments = "[Error Message]", Success = false, ErrorMessage = "Error Message", Action = "Creating new issue" }; RepositoryBranchUpdateHistoryEntry secondError = new RepositoryBranchUpdateHistoryEntry { Repository = RepoUrl, Branch = BranchTwo, Method = "ProcessPendingUpdatesAsync", Timestamp = new DateTime(2200, 1, 1), Arguments = "[Arguments]", Success = false, ErrorMessage = "ProcessPendingUpdatesAsync error", Action = "Create another issue" }; Context.RepoBranchUpdateInMemory = new List <RepositoryBranchUpdateHistoryEntry> { firstError, secondError }; Repository repository = new Repository(); GithubClient.Setup(x => x.Repository.Get(It.IsAny <string>(), It.IsAny <string>())).ReturnsAsync(repository); Mock <Octokit.Issue> issue = new Mock <Issue>(); List <NewIssue> newIssue = new List <NewIssue>(); GithubClient.Setup(x => x.Issue.Create(It.IsAny <long>(), Capture.In(newIssue))).ReturnsAsync(issue.Object); DependencyUpdateErrorProcessor errorProcessor = ActivatorUtilities.CreateInstance <DependencyUpdateErrorProcessor>(Scope.ServiceProvider, Context); await errorProcessor.ProcessDependencyUpdateErrorsAsync(); Assert.Equal(2, newIssue.Count); Assert.Equal("DependencyUpdateError", newIssue[0].Labels[0]); Assert.Contains(RepoUrl, newIssue[0].Title); Assert.Contains(BranchOne, newIssue[0].Body); Assert.Contains("ProcessPendingUpdatesAsync", newIssue[0].Body); Assert.Contains("1/1/2200 12:00:00 AM", newIssue[0].Body); Assert.Contains(RepoUrl, newIssue[0].Body); Assert.Equal("DependencyUpdateError", newIssue[1].Labels[0]); Assert.Contains(RepoUrl, newIssue[1].Title); Assert.Contains(BranchTwo, newIssue[1].Body); Assert.Contains("ProcessPendingUpdatesAsync error", newIssue[1].Body); Assert.Contains("1/1/2200 12:00:00 AM", newIssue[1].Body); Assert.Contains(RepoUrl, newIssue[1].Body); }
public void GithubClient_GetRepositories_CredentialsFail() { var helper = new Mock <IWebsiteRequestHelper>(); //helper.Setup(a => a.GetStringResponse(null, null, null)) var client = new GithubClient(helper.Object); client.GetRepositories(); }
public async Task <bool> Check() { var client = new GithubClient(Application.ProductName); _repository = await client.GetRepositoryAsync("https://api.github.com/repositories/283887091/releases/latest"); return(new Version(_repository.TagName.Substring(1)) // Remove 'v' from version string .CompareTo(new Version(Application.ProductVersion)) > 0); }
public void SetUp() { var guard = new GuardService(); Client = new GithubClient(); Converter = new ContentConverterService(new ConverterTemplates(), guard); ApiService = new RestApiService(Client, Converter); AuthenticationController = new AuthenticationController(new AuthenticationService(ApiService, Converter)); RepositoryController = new RepositoryController(AuthenticationController, new RepositoryService(ApiService, Converter, guard)); }
public void GithubClient_SearchRepositories_FormsCorrectUrl() { // Arrange const int expectedCount = 3; const string expectedUrl = "https://api.github.com/search/repositories?q=tetris in:name+language:assembly&sort=stars&order=asc"; var mockRest = new Mock <IRestClient>(); mockRest.Setup(rc => rc.Get <GithubResponse>(expectedUrl)).Returns( new GithubResponse() { TotalCount = 3, Items = new List <GithubRepository>() { new GithubRepository() { Name = "Tetris #1", Url = "Tetris #1", Stars = 0, FullName = "Tetris #1", Id = 1, Language = "Assembly" }, new GithubRepository() { Name = "Tetris #2", Url = "Tetris #2", Stars = 1, FullName = "Tetris #2", Id = 2, Language = "Assembly" }, new GithubRepository() { Name = "Tetris #3", Url = "Tetris #3", Stars = 2, FullName = "Tetris #3", Id = 3, Language = "Assembly" } } } ); var client = new GithubClient(mockRest.Object); // Act var result = client.SearchRepositories("q=tetris in:name+language:assembly&sort=stars&order=asc"); // Assert Assert.IsNotNull(result, "Result should not be null!"); Assert.AreEqual(expectedCount, result.Count(), "Result count should be equal to 3!"); }
private static async Task ProcessRepositories(GithubClient github) { var response = await github.GetData(); // var data = await response.Content.ReadAsAsync<JObject>(); var data = await response.Content.ReadAsStringAsync(); var repositories = JsonConvert.DeserializeObject <IEnumerable <Repo> >(data); PrintRepositories(repositories); }
public async Task Test_API_GetRepositories() { var authToken = _configuration["githubAuthToken"]; var client = new GithubClient(new GithubClientOptions(authToken)); var result = await client.GetUserRepos("ThatBlokeCalledJay"); Assert.IsTrue(result.Success, "Request was successful."); Assert.IsTrue(result.Content.Repositories.Count > 0, "Found repositories."); }
public async Task GetCodeFromGitHubFile(string filename = "", bool isFromPublic = false) { var sw = new Stopwatch(); sw.Start(); string code = isFromPublic ? await UpdateFromPublicRepo() : await GithubClient.CodeFromGithub(filename); sw.Stop(); Console.WriteLine($"GitHub file content retrieved in {sw.ElapsedMilliseconds}ms \r\n Returned: {code}"); await UpdateCodeSnippet(code); }
public async Task Should_Add_User_To_Cache() { var handlerMock = GetHandlerMock(); var httpClient = new GithubClient(handlerMock.Object); var cache = new MemoryCache("cache"); var userService = new UserService(new UserRepository(cache, httpClient)); await userService.GetUser("test"); Assert.IsTrue(cache.Contains("test")); }
private async Task Submit() { var codeFile = await GithubClient.CodeFromPublicRepo(FormModel.GithubName, FormModel.RepoName, FormModel.FilePath); var parameters = new ModalDialogParameters { { "FileCode", codeFile } }; ModalService.Close(true, parameters); }
public void GithubClient_GetRepositories_JsonFormatFail() { var helper = new Mock <IWebsiteRequestHelper>(); helper.Setup(a => a.GetStringResponse("azurecoder", "adghjsueu374", "blah")) .Returns(JsonResponseIncorrect); var client = new GithubClient(helper.Object) { Username = "******", Password = "******" }; var list = client.GetRepositories("blah"); }
public static async Task <IActionResult> Run( [HttpTrigger(AuthorizationLevel.Function, "post")] HttpRequest request, ILogger logger) { logger.LogInformation("Initialize called."); try { var configuration = new Configuration.Configuration(); var fileParser = new FileParser(); // Get all the files from GitHub var githubClient = new GithubClient( new HttpClient(), configuration.GithubRepositoryName, configuration.GithubRepositoryOwner, configuration.GithubAccessToken); var githubService = new Services.GithubService(githubClient, fileParser); var codeFiles = await githubService.GetCodeFilesAsync(); // Persist all code sample files var connectionString = configuration.RepositoryConnectionString; var codeFileRepository = await CodeFileRepositoryProvider.CreateCodeFileRepositoryInstance(connectionString); var fragmentsToUpsert = new List <CodeFragment>(); foreach (var codeFile in codeFiles) { await codeFileRepository.StoreAsync(codeFile); fragmentsToUpsert.AddRange(codeFile.CodeFragments); } // Store code fragment event var eventDataRepository = await EventDataRepository.CreateInstance(connectionString); await new EventDataService(eventDataRepository) .SaveCodeFragmentEventAsync(FunctionMode.Initialize, fragmentsToUpsert); return(new OkObjectResult("Initialized.")); } catch (Exception exception) { // This try-catch is required for correct logging of exceptions in Azure var message = $"Exception: {exception.Message}\nStack: {exception.StackTrace}"; throw new GithubServiceException(message); } }
public async Task CanGetUserAsyncFromGithubClientApi(string username, string fullName) { // Arrange var _client = new HttpClient(); _client.BaseAddress = new Uri("https://api.github.com"); _client.DefaultRequestHeaders.UserAgent.Add(new ProductInfoHeaderValue("Yolo", "0.1.0")); var _githubClient = new GithubClient(_client); // Act var response = await _githubClient.GetUserAsync(username); // Assert Assert.Equal(response.Name, fullName); }
public void GithubClient_GetRepositories_List() { var helper = new Mock <IWebsiteRequestHelper>(); helper.Setup(a => a.GetStringResponse("azurecoder", "adghjsueu374", "blah")) .Returns(JsonResponseCorrect); var client = new GithubClient(helper.Object) { Username = "******", Password = "******" }; var list = client.GetRepositories("blah"); list.Count.Should().Be(5); list["b"].Should().Be("a"); }
public async Task TestGetOauthToken() { const string oauthResp = "{ \"access_token\": \"31ccdad924fb247281124be8691955a85054d833\" }"; _server.Given(Request.Create() .WithPath("/") .UsingPost() ) .RespondWith(Response.Create() .WithStatusCode(250) .WithBody(oauthResp) ); _client = new GithubClient(_config, _httpClient) { OauthUrl = _server.Urls[0] }; var oauthToken = await _client.GetOauthToken("sampleToken"); Assert.AreEqual("31ccdad924fb247281124be8691955a85054d833", oauthToken.access_token); }
public async void GetUserByLogin_InputNonExisting_ReturnNull() { var configuration = new HttpConfiguration(); var clientHandlerStub = new DelegatingHandlerStub((request, cancellationToken) => { request.SetConfiguration(configuration); var response = request.CreateResponse( HttpStatusCode.NotFound, "" ); return(Task.FromResult(response)); }); var client = new HttpClient(clientHandlerStub); client.BaseAddress = new Uri("https://api.github.com/"); var githubClient = new GithubClient(client); var githubUser = await githubClient.GetUserByLogin("asdafdsf"); Assert.Null(githubUser); }
public async Task Test_ParseErrorData() { var mockHttp = new MockHttpMessageHandler(); mockHttp.When(HttpMethod.Get, "https://test.com/users/TestUser/repos") .Respond(HttpStatusCode.BadRequest, (m) => new StringContent(JsonConvert.SerializeObject(CreateError()), Encoding.UTF8, "application/json")); var httpClient = new HttpClient(mockHttp) { BaseAddress = new Uri("https://test.com") }; var clientOptions = new GithubClientOptions(httpClient); var client = new GithubClient(clientOptions); var result = await client.GetUserRepos("TestUser"); Assert.IsFalse(result.Success, "Is failed response."); Assert.AreEqual(HttpStatusCode.BadRequest, result.ResponseCode); Assert.AreEqual("https://docs.com", result.DocumentationUrl); Assert.AreEqual("Naughty Robot", result.Message); }
public async Task Test_ParseResponseData() { var mockHttp = new MockHttpMessageHandler(); mockHttp.When(HttpMethod.Get, "https://test.com/users/TestUser/repos") .Respond("application/json", JsonConvert.SerializeObject(CreateRepoList())); var httpClient = new HttpClient(mockHttp) { BaseAddress = new Uri("https://test.com") }; var clientOptions = new GithubClientOptions(httpClient); var client = new GithubClient(clientOptions); var result = await client.GetUserRepos("TestUser"); Assert.IsTrue(result.Success, "Is success response."); Assert.AreEqual(HttpStatusCode.OK, result.ResponseCode); Assert.AreEqual(1, result.Content.Repositories.Count, "A single test repo was returned."); }
public async Task Should_Go_To_Api_If_Not_Cached() { var handlerMock = GetHandlerMock(); var httpClient = new GithubClient(handlerMock.Object); var userService = new UserService(new UserRepository(new MemoryCache("cache"), httpClient)); var result = await userService.GetUser("test"); var expectedUri1 = new Uri("https://api.github.com/users/test"); var expectedUri2 = new Uri("https://api.github.com/users/test/repos"); handlerMock.Protected().Verify( "SendAsync", Times.Exactly(2), ItExpr.Is <HttpRequestMessage>(req => req.Method == HttpMethod.Get && (req.RequestUri == expectedUri1 || req.RequestUri == expectedUri2) ), ItExpr.IsAny <CancellationToken>() ); }
public void UpdateCheck() { try { var update = GithubClient.GetNewRelease(BoxartConfig.Repository, BoxartConfig.Version); if (update != null) { var result = MessageBox.Show(update.UpdateText, "A new update is available!", MessageBoxButtons.YesNo, MessageBoxIcon.Information); if (result == DialogResult.Yes) { OSHelper.OpenBrowser(BoxartConfig.RepositoryReleasesUrl); } } } catch (Exception e) { Log($"An error occured while looking for updates. {e.Message}"); } }
public async Task ShouldCreateIssue(string repoUrl, string branch, string method, string arguments, DateTime errorOccurredAt, bool success) { // Not testing SubscriptionUpdateHistoryEntry since this is always "yes" for them. RepositoryBranchUpdateHistoryEntry repositoryBranchUpdate = new RepositoryBranchUpdateHistoryEntry { Repository = repoUrl, Branch = branch, Method = method, Timestamp = errorOccurredAt, Arguments = arguments, Success = success }; Repository repository = new Repository(); GithubClient.Setup(x => x.Repository.Get(It.IsAny <string>(), It.IsAny <string>())).ReturnsAsync(repository); Mock <Maestro.Data.Models.Subscription> subscription = new Mock <Maestro.Data.Models.Subscription>(); subscription.Object.Id = Guid.Parse(SubscriptionId); Context.Subscriptions.Add(subscription.Object); Context.SaveChanges(); Mock <Issue> issue = new Mock <Issue>(); //Shared mocks works for Xunit as it creates a separate file for each test, but for Nunit there will be a conflict. //We need to take care of this if we port to Nunit in future. GithubClient.Setup(x => x.Issue.Create(It.IsAny <long>(), It.IsAny <NewIssue>())).ReturnsAsync(issue.Object); Context.RepoBranchUpdateInMemory = new List <RepositoryBranchUpdateHistoryEntry> { repositoryBranchUpdate }; DependencyUpdateErrorProcessor errorProcessor = ActivatorUtilities.CreateInstance <DependencyUpdateErrorProcessor>(Scope.ServiceProvider, Context); await errorProcessor.ProcessDependencyUpdateErrorsAsync(); GithubClient.Verify(x => x.Issue.Create(It.IsAny <long>(), It.IsAny <NewIssue>()), Times.Once); }
// The 'typed client' is now available from the service provider public async Task <JObject> Example2([FromServices] GithubClient client) { return(await client.GetIndexAsync()); }
public static async Task <IActionResult> Run( [HttpTrigger(AuthorizationLevel.Function, "post")] HttpRequest request, ILogger logger) { logger.LogInformation("Update called."); try { var configuration = new Configuration.Configuration(); var fileParser = new FileParser(); // Get all the files from GitHub var githubClient = new GithubClient( new HttpClient(), configuration.GithubRepositoryName, configuration.GithubRepositoryOwner, configuration.GithubAccessToken); var githubService = new Services.GithubService(githubClient, fileParser); // Read Webhook message from GitHub WebhookMessage webhookMessage; using (var streamReader = new StreamReader(request.Body, Encoding.UTF8)) { var requestBody = streamReader.ReadToEnd(); webhookMessage = JsonConvert.DeserializeObject <WebhookMessage>(requestBody); } // Get paths to added/modified/deleted files var parser = new WebhookParser(); var(addedFiles, modifiedFiles, removedFiles) = parser.ExtractFiles(webhookMessage); var connectionString = configuration.RepositoryConnectionString; var codeFileRepository = await CodeFileRepositoryProvider.CreateCodeFileRepositoryInstance(connectionString); var fileProcessor = new FileProcessor(githubService, codeFileRepository); var addedFragmentsFromNewFiles = await fileProcessor.ProcessAddedFiles(addedFiles); var(addedFragmentsFromModifiedFiles, modifiedFragments, removedFragmentsFromModifiedFiles) = await fileProcessor.ProcessModifiedFiles(modifiedFiles, logger); var removedFragmentsFromDeletedFiles = await fileProcessor.ProcessRemovedFiles(removedFiles); var allAddedFragments = addedFragmentsFromNewFiles .Concat(addedFragmentsFromModifiedFiles); var allRemovedFragments = removedFragmentsFromModifiedFiles .Concat(removedFragmentsFromDeletedFiles); // Store code fragment event var eventDataRepository = await EventDataRepository.CreateInstance(connectionString); await new EventDataService(eventDataRepository) .SaveCodeFragmentEventAsync( FunctionMode.Update, allAddedFragments, modifiedFragments, allRemovedFragments ); return(new OkObjectResult("Updated.")); } catch (Exception exception) { // This try-catch is required for correct logging of exceptions in Azure var message = $"Exception: {exception.Message}\nStack: {exception.StackTrace}"; throw new GithubServiceException(message); } }
public void initialize() { this.client = new GithubClient(); client.Authenticate(this.userName, this.password); }
internal override void ExecuteCommand() { if (Git && GitHub) { throw new Exception("Please run the command with either -Git or -GitHub options. Not both."); } if (Git) { PublishingUsername = GetPublishingUser(); } WebSpaces webspaceList = null; InvokeInOperationContext(() => { webspaceList = RetryCall(s => Channel.GetWebSpacesWithCache(s)); }); if (webspaceList.Count == 0) { // If location is still empty or null, give portal instructions. string error = string.Format(Resources.PortalInstructions, Name); throw new Exception(!Git ? error : string.Format("{0}\n{1}", error, Resources.PortalInstructionsGit)); } WebSpace webspace = null; if (string.IsNullOrEmpty(Location)) { // If no location was provided as a parameter, try to default it webspace = webspaceList.FirstOrDefault(); if (webspace == null) { // Use east us webspace = new WebSpace { Name = "eastuswebspace", GeoRegion = "East US", Subscription = CurrentSubscription.SubscriptionId, Plan = "VirtualDedicatedPlan" }; } } else { // Find the webspace that corresponds to the georegion webspace = webspaceList.FirstOrDefault(w => w.GeoRegion.Equals(Location, StringComparison.OrdinalIgnoreCase)); if (webspace == null) { // If no webspace corresponding to the georegion was found, attempt to create it webspace = new WebSpace { Name = Regex.Replace(Location.ToLower(), " ", "") + "webspace", GeoRegion = Location, Subscription = CurrentSubscription.SubscriptionId, Plan = "VirtualDedicatedPlan" }; } } SiteWithWebSpace website = new SiteWithWebSpace { Name = Name, HostNames = new[] { Name + General.AzureWebsiteHostNameSuffix }, WebSpace = webspace.Name, WebSpaceToCreate = webspace }; if (!string.IsNullOrEmpty(Hostname)) { List<string> newHostNames = new List<string>(website.HostNames); newHostNames.Add(Hostname); website.HostNames = newHostNames.ToArray(); } try { InvokeInOperationContext(() => RetryCall(s => Channel.CreateSite(s, webspace.Name, website))); // If operation succeeded try to update cache with new webspace if that's the case if (webspaceList.FirstOrDefault(ws => ws.Name.Equals(webspace.Name)) == null) { Cache.AddWebSpace(CurrentSubscription.SubscriptionId, webspace); } Cache.AddSite(CurrentSubscription.SubscriptionId, website); } catch (ProtocolException ex) { // Handle site creating indepently so that cmdlet is idempotent. string message = ProcessException(ex, false); if (message.Equals(string.Format(Resources.WebsiteAlreadyExistsReplacement, Name)) && (Git || GitHub)) { WriteWarning(message); } else { SafeWriteError(new Exception(message)); } } if (Git || GitHub) { try { Directory.SetCurrentDirectory(SessionState.Path.CurrentFileSystemLocation.Path); } catch (Exception) { // Do nothing if session state is not present } LinkedRevisionControl linkedRevisionControl = null; if (Git) { linkedRevisionControl = new GitClient(this); } else if (GitHub) { linkedRevisionControl = new GithubClient(this, GithubCredentials, GithubRepository); } linkedRevisionControl.Init(); CopyIisNodeWhenServerJsPresent(); UpdateLocalConfigWithSiteName(Name, webspace.Name); InitializeRemoteRepo(webspace.Name, Name); Site updatedWebsite = RetryCall(s => Channel.GetSite(s, webspace.Name, Name, "repositoryuri,publishingpassword,publishingusername")); if (Git) { AddRemoteToLocalGitRepo(updatedWebsite); } linkedRevisionControl.Deploy(updatedWebsite); linkedRevisionControl.Dispose(); } }
static void Main(string[] args) { ConsoleEx.WriteGreenLine(BoxartConfig.Credits); Console.WriteLine(); var config = new BoxartConfig(); try { config.Load(); } catch { Console.WriteLine("Could not load TwilightBoxart.ini - using defaults."); } if (!config.DisableUpdates) { try { var update = GithubClient.GetNewRelease(BoxartConfig.Repository, BoxartConfig.Version); if (update != null) { ConsoleEx.WriteGreenLine(update.UpdateText); if (ConsoleEx.YesNoMenu()) { OSHelper.OpenBrowser(BoxartConfig.RepositoryReleasesUrl); } Console.WriteLine(); } } catch (Exception e) { Console.WriteLine($"Could not check for updates: {e.Message}"); } } if (string.IsNullOrEmpty(config.SdRoot)) { var allDrives = new List <DriveInfo>(); try { allDrives = DriveInfo.GetDrives().Where(c => c.DriveType == DriveType.Removable).ToList(); } catch { } var choice = Path.GetDirectoryName(Assembly.GetEntryAssembly().Location); if (allDrives.Count > 0) { var choices = allDrives.Select(c => c.Name).ToList(); choices.Add("Current Directory"); var i = ConsoleEx.MenuIndex("Select your SD location: ", true, choices.ToArray()); if (i != choices.Count - 1) { choice = allDrives[i].RootDirectory.FullName; } } else { Console.WriteLine("No settings or drives found. Using current directory."); } config.SdRoot = choice; } var boxArtPath = config.GetCorrectBoxartPath(); ConsoleEx.WriteGreenLine("Loaded settings:"); Console.WriteLine("SDRoot / Roms location: \t" + config.SdRoot); Console.WriteLine("BoxArt location: \t\t" + boxArtPath); Console.WriteLine(); if (!ConsoleEx.YesNoMenu("Is this OK?")) { Console.WriteLine("Please edit TwilightBoxart.ini or insert your SD card and try again."); return; } Console.WriteLine(); var progress = new Progress <string>(Console.WriteLine); var crawler = new BoxartCrawler(progress); config.BoxartPath = boxArtPath; config.SettingsPath = config.GetCorrectSettingsIniPath(); crawler.DownloadArt(config).Wait(); }
static ConsoleMain() { _client = new GithubClient(); }
public void SetUp() { Client = new GithubClient(); }