Пример #1
0
 private Octokit.GitHubClient GetClient()
 {
     var client = new Octokit.GitHubClient(new Octokit.ProductHeaderValue(this.Settings.GitHubAppName));
     var basicAuth = new Octokit.Credentials(this.Settings.GitHubUserId, this.Settings.GitHubPassword);
     client.Credentials = basicAuth;
     return client;
 }
Пример #2
0
        public async Task LoginWithToken(string clientId, string clientSecret, string code, string redirect, string requestDomain, string apiDomain)
        {
            var oauthRequest = new Octokit.OauthTokenRequest(clientId, clientSecret, code)
            {
                RedirectUri = new Uri(redirect)
            };

            var client = new Octokit.GitHubClient(OctokitClientFactory.UserAgent);
            var token  = await client.Oauth.CreateAccessToken(oauthRequest);

            var credentials = new Octokit.Credentials(token.AccessToken);

            client = OctokitClientFactory.Create(new Uri(apiDomain), credentials);

            var user = await client.User.Current();

            var account = await _accountsService.Get(apiDomain, user.Login);

            account = account ?? new Account {
                Username = user.Login
            };
            account.OAuth     = token.AccessToken;
            account.AvatarUrl = user.AvatarUrl;
            account.Domain    = apiDomain;
            account.WebDomain = requestDomain;

            await _accountsService.Save(account);

            await _applicationService.LoginAccount(account);
        }
Пример #3
0
        public async Task LoginAccount(Account account)
        {
            var    domain = account.Domain ?? Client.DefaultApi;
            Client client = null;

            Octokit.Credentials credentials = null;

            if (!string.IsNullOrEmpty(account.OAuth))
            {
                client      = Client.BasicOAuth(account.OAuth, domain);
                credentials = new Octokit.Credentials(account.OAuth);
            }
            else if (account.IsEnterprise || !string.IsNullOrEmpty(account.Password))
            {
                client      = Client.Basic(account.Username, account.Password, domain);
                credentials = new Octokit.Credentials(account.Username, account.Password);
            }

            var octoClient = OctokitClientFactory.Create(new Uri(domain), credentials);
            var user       = await octoClient.User.Current();

            account.Username  = user.Login;
            account.AvatarUrl = user.AvatarUrl;
            client.Username   = user.Login;

            await _accountsService.Save(account);

            await _accountsService.SetActiveAccount(account);

            Account      = account;
            Client       = client;
            GitHubClient = octoClient;
        }
Пример #4
0
        Octokit.GitHubClient CreateGitHubClient(string gitHubToken)
        {
            var client    = new Octokit.GitHubClient(new Octokit.ProductHeaderValue("code-central"));
            var basicAuth = new Octokit.Credentials(gitHubToken);

            client.Credentials = basicAuth;
            return(client);
        }
Пример #5
0
        public void ActivateUser(Account account, Client client)
        {
            _accountsService.SetActiveAccount(account).Wait();
            Account = account;
            Client  = client;

            var domain      = account.Domain ?? Client.DefaultApi;
            var credentials = new Octokit.Credentials(account.OAuth);
            var oldClient   = Client.BasicOAuth(account.OAuth, domain);

            GitHubClient = OctokitClientFactory.Create(new Uri(domain), credentials);
        }
Пример #6
0
        public async Task LoginWithBasic(string domain, string user, string pass, string twoFactor = null)
        {
            if (string.IsNullOrEmpty(user))
            {
                throw new ArgumentException("Username is invalid");
            }
            if (string.IsNullOrEmpty(pass))
            {
                throw new ArgumentException("Password is invalid");
            }
            if (domain == null || !Uri.IsWellFormedUriString(domain, UriKind.Absolute))
            {
                throw new ArgumentException("Domain is invalid");
            }

            var newAuthorization = new Octokit.NewAuthorization(
                $"CodeHub: {user}", Scopes, Guid.NewGuid().ToString());

            var credentials = new Octokit.Credentials(user, pass);
            var client      = OctokitClientFactory.Create(new Uri(domain), credentials);

            var authorization = await(twoFactor == null
                                ? client.Authorization.Create(newAuthorization)
                                : client.Authorization.Create(newAuthorization, twoFactor));

            var existingAccount = await _accountsService.Get(domain, user);

            var account = existingAccount ?? new Account
            {
                Username     = user,
                IsEnterprise = true,
                WebDomain    = domain,
                Domain       = domain
            };

            account.OAuth = authorization.Token;

            await _applicationService.LoginAccount(account);
        }
Пример #7
0
        public async Task LoginWithToken(string apiDomain, string webDomain, string token, bool enterprise)
        {
            if (string.IsNullOrEmpty(token))
            {
                throw new ArgumentException("Token is invalid");
            }
            if (apiDomain != null && !Uri.IsWellFormedUriString(apiDomain, UriKind.Absolute))
            {
                throw new ArgumentException("API Domain is invalid");
            }
            if (webDomain != null && !Uri.IsWellFormedUriString(webDomain, UriKind.Absolute))
            {
                throw new ArgumentException("Web Domain is invalid");
            }

            var credentials = new Octokit.Credentials(token);
            var client      = OctokitClientFactory.Create(new Uri(apiDomain), credentials);
            var userInfo    = await client.User.Current();

            var scopes = await GetScopes(apiDomain, userInfo.Login, token);

            CheckScopes(scopes);

            var account = (await _accountsService.Get(apiDomain, userInfo.Login)) ?? new Account();

            account.Username     = userInfo.Login;
            account.Domain       = apiDomain;
            account.WebDomain    = webDomain;
            account.IsEnterprise = enterprise;
            account.OAuth        = token;
            account.AvatarUrl    = userInfo.AvatarUrl;

            await _accountsService.Save(account);

            await _applicationService.LoginAccount(account);
        }
Пример #8
0
        public void ProcessRequest(HttpContext context)
        {
            string path = System.Web.HttpContext.Current.Server.MapPath("/");
            appPath = path + "app\\apps\\";
            appPathDev = path + "app\\apps\\dev\\";
            appPathPub = path + "app\\apps\\pub\\";

            try
            {

                context.Response.ContentType = "text/plain";
                string appName = context.Request.QueryString.Get("appid");
                string mode = context.Request.QueryString.Get("mode");  //mode 1 dev mode 2 publish
                if (appName == null)
                {
                    context.Response.StatusCode = 404;
                    context.Response.Write("appid not found");
                    context.Response.End();
                    return;
                }

                if (mode == null)
                {
                    context.Response.StatusCode = 404;
                    context.Response.Write("mode not found");
                    context.Response.End();
                    return;
                }

                if (mode == "1")
                {
                    appPath = appPathDev;
                }
                else if (mode == "2")
                {
                    appPath = appPathPub;
                }

                var credentials = new Octokit.Credentials("Xapps00", "xapps00xapps00");
                var connection = new Octokit.Connection(new Octokit.ProductHeaderValue("XApps"))
                {
                    Credentials = credentials
                };
                var octokitClient = new Octokit.GitHubClient(connection);
                var branch = octokitClient.Repository.GetBranch("xapps00", appName, "master").Result;
                var branchTree = octokitClient.GitDatabase.Tree.Get("xapps00", appName, branch.Commit.Sha).Result;

                if (Directory.Exists(appPath + appName))
                {

                }
                else
                {
                    Directory.CreateDirectory(appPath + appName);

                }

                foreach (var treeItem in branchTree.Tree)
                {
                    if (treeItem.Type.Equals(Octokit.TreeType.Tree))
                    {
                        if (!Directory.Exists(appPath + "/" + appName + "/" + treeItem.Path))
                        {
                            Directory.CreateDirectory(appPath + "/" + appName + "/" + treeItem.Path);
                        }

                        var subBranch = octokitClient.GitDatabase.Tree.Get("xapps00", appName, treeItem.Sha).Result;

                        foreach (var item in subBranch.Tree)
                        {
                            if (item.Type.Equals(Octokit.TreeType.Blob))
                            {
                                var tempBlob = octokitClient.GitDatabase.Blob.Get("xapps00", appName, item.Sha).Result;
                                var tempContents = tempBlob.Content;

                                byte[] data = Convert.FromBase64String(tempContents);
                                string decodedString = Encoding.UTF8.GetString(data);

                                if (!File.Exists(appPath + "/" + appName + "/" + treeItem.Path))
                                {
                                    //File.Create(appPath + "/" + appName + "/" + treeItem.Path+"/"+item.Path);
                                    StreamWriter file =
                                        new StreamWriter(appPath + "/" + appName + "/" + treeItem.Path + "/" + item.Path);
                                    file.Write(decodedString);
                                    file.Close();
                                }
                                else
                                {
                                    //TO-DO: check the hash values from DB and retrive
                                }

                            }
                        }

                    }
                }

                context.Response.StatusCode = 200;
                context.Response.Write("{appName:'" + appName + "', appPath:'" + appPath + "'");
            }
            catch (Exception e)
            {
                context.Response.StatusCode = 404;//send error code
            }
        }