done refactoring and auth

Author: groenborg

.phlow

@@ -5,10 +5,11 @@
     issue_url = https://api.github.com
     pipeline_url = http://concourse.bosh.praqma.cloud/teams/main/pipelines/git-phlow
     delivery_branch_prefix = ready
+
 [jira]
-    service = sd
-    integration_branch = gh_pages
-    remote = fork
-    repo_url = jira
+    integration_branch = master
+    remote = origin
+    service = http://jira.teamsinspace.com:8080
     issue_url = jira
-    delivery_branch_prefix = integrateme
+    pipeline_url = http://concourse.bosh.praqma.cloud/teams/main/pipelines/git-phlow
+    delivery_branch_prefix = ready

ci/test/test.sh

@@ -7,14 +7,14 @@ export PATH=$PATH:$GOPATH/bin
 
 # RESOLVE DEPENDENCIES - TEST AND PRODUCTION
 cd $GOPATH/src/github.com/praqma/git-phlow
-go get -t -d -v ./...
+go get -t -v ./...
 
 #install ginkgo
 go install github.com/onsi/ginkgo/ginkgo
 
 
 # run tests
-go test -p 1 -v ./...
+go test -v ./...
 
 
 

cmd/auth.go

@@ -6,22 +6,28 @@ import (
 	"github.com/praqma/git-phlow/phlow"
 	"github.com/praqma/git-phlow/ui"
 	"github.com/spf13/cobra"
+	"github.com/praqma/git-phlow/options"
 )
 
 //enable command
 var authCmd = &cobra.Command{
 	Use:   "auth",
-	Short: "authenticate with github",
+	Short: "authenticate with different services",
 	Long: fmt.Sprintf(`
-%s is required to enable 'workon' with issue management.
-Auth will prompt you for a GitHub username and password to generate a token.
-Don't worry, the token does not include admininstrator rights, only access to manage issues for public repositories.
+%s will authenticate to a service specified in your .phlow or .gitconfig files. It will use the default service if no other is specified.
+Auth supports two services:
+- Jira
+- GitHub
 `, ui.Format.Bold("auth")),
 	Run: func(cmd *cobra.Command, args []string) {
+
 		phlow.AuthCaller()
+
 	},
 }
 
 func init() {
 	RootCmd.AddCommand(authCmd)
+
+	authCmd.Flags().StringVarP(&options.GlobalFlagTarget, "target", "t", "", "the name of the INI block in your .phlow files")
 }

docs/README.md

@@ -1,3 +1,26 @@
+### phlow auth
+```
+git phlow auth -t <target>
+```
+Git phlow auth, authorizes towards a chosen service which can be either `github` or `jira`. Auth is used by git phlow to access and manage issues in your chosen provider.
+
+Auth is dependent on a configuration file unless you are using GitHub.com for your issues and Repositories, in that case you can complete omit using the `--target` flag
+
+#### Self hosted services or Jira
+To authenticate with your own hosted service or Jira you _must_ provide a valid configuration (see **Configuration** section). Your configuration must contain a base url to where your service is hosted and the name of the service. When authenticating set your `--target` to the name of the configuration e.g.
+
+```ini
+[myjiraconfig]
+    integration_branch = master
+    remote = origin
+    service = jira
+    issue_url = https://my.jira.instance.com
+    delivery_branch_prefix = ready
+```
+```bash
+git phlow auth --target myjiraconfig
+```
+
 ### Configuration
 git phlow is configured via `.phlow`, or `.gitignore`  files., in your local workspace or in the home folder of your computer. The configuration is standard INI files, just like gitconfig.
 

githandler/git.go

@@ -74,6 +74,16 @@ func (os *Git) Merge(argv ...string) (string, error) {
 	return os.Run("git", "merge", argv...)
 }
 
+//Config ...
+//Executes local git config with params
+func (os *Git) Config(argv ...string) (string, error) {
+	stdOut, stdErr := os.Run("git", "config", argv...)
+	if stdErr != nil {
+		return "", stdErr
+	}
+	return strings.Replace(stdOut, "\n", "", -1), nil
+}
+
 //DEPRECATESD SECTION ---------------------------------------------------------------
 //FormatPatch ...
 //dry runs patch to see if we can auto merge

main.go

@@ -1,8 +1,6 @@
 package main
 
-import (
-	"github.com/praqma/git-phlow/cmd"
-)
+import "github.com/praqma/git-phlow/cmd"
 
 func main() {
 	cmd.Execute()

options/option.go

@@ -35,6 +35,9 @@ var (
 	//GlobalFlagForce ...
 	GlobalFlagForceMessage string
 
+	//GlobalFlagTarget ...
+	GlobalFlagTarget string
+
 	//Sha1 git commit hash
 	Sha1 string
 
@@ -43,16 +46,10 @@ var (
 
 	//Date date of build
 	Date string
-)
-
-func init() {
-
-}
-
-func windows() {
-
-}
 
-func unix() {
+	//AuthFlagJira ...
+	AuthFlagJira = false
 
-}
+	//AuthFlagGitHub ...
+	AuthFlagGitHub = false
+)

phlow/auth.go

@@ -12,31 +12,41 @@ import (
 	"github.com/praqma/git-phlow/plugins"
 	"github.com/praqma/git-phlow/executor"
 	"github.com/praqma/git-phlow/setting"
+	"github.com/praqma/git-phlow/githandler"
+	"github.com/praqma/git-phlow/options"
 )
 
 //AuthCaller
 //Wraps auth and injects dependencies
 func AuthCaller() {
-	cf := setting.GitConfig{Run: executor.RunCommand}
-	Auth(cf)
+	INIBlock := options.GlobalFlagTarget
+	conf := setting.NewProjectStg(INIBlock)
+
+	if "jira" == strings.ToLower(conf.Service) {
+		Auth(INIBlock, plugins.AuthorizeJIRA, plugins.AuthenticateJIRA, "phlow.jirauser", "phlow.jiratoken", conf.Service)
+	}
+
+	Auth(INIBlock, plugins.AuthorizeGitHub, plugins.AuthenticateGitHub, "phlow.user", "phlow.token", conf.Service)
 }
 
 //Auth ...
-//Authenticates the user
-func Auth(cf setting.Configurator) {
-	token := cf.Get(setting.PhlowToken)
-	user := cf.Get(setting.PhlowUser)
+func Auth(INIBlock string, authorization plugins.Authorization, authentication plugins.Authentication, configUser string, configToken string, service string) {
+	conf := setting.NewProjectStg(INIBlock)
+	git := githandler.Git{Run: executor.RunGit}
+
+	token, err := git.Config("--get", configToken)
+	user, err := git.Config("--get", configUser)
 
 	if token != "" && user != "" {
-		fmt.Println("Checking token validity...")
-		isAuthenticated, err := plugins.GitHub.CheckAuth()
+		fmt.Printf("Checking token validity for %s... \n", service)
+		isAuthenticated, err := authentication(conf.IssueURL, user, token)
 		if !isAuthenticated {
 			fmt.Println("Token test expected HTTP code 200 but received " + err.Error())
 			if ReadInput("Delete local token and reauthenticate? (y/n): ", os.Stdin) == "y" {
 				fmt.Println("Deleting local token and reauthenticating...")
-				cf.Unset(setting.PhlowToken)
-				cf.Unset(setting.PhlowUser)
-				AuthCaller()
+				git.Config("--global", "--unset", configUser)
+				git.Config("--global", "--unset", configToken)
+				Auth(conf.INIBlock, authorization, authentication, configUser, configToken, service)
 			} else {
 				fmt.Println("Aborting...")
 			}
@@ -46,21 +56,21 @@ func Auth(cf setting.Configurator) {
 		return
 	}
 
-	fmt.Fprintf(os.Stdout, "Enter credentials for %s \n", "GitHub")
+	fmt.Fprintf(os.Stdout, "Enter credentials for %s \n", service)
 
 	//Read user input username
 	username := ReadInput("username: ", os.Stdin)
 	//Read user input password
 	password := ReadPassword("password: ")
 
-	token, err := plugins.GitHub.Auth(username, password)
+	_, err = authorization(conf.IssueURL, username, password)
 	if err != nil {
 		fmt.Println()
 		fmt.Println(err)
 		return
 	}
-	cf.Set(setting.PhlowUser, username)
-	cf.Set(setting.PhlowToken, token)
+	_, err = git.Config("--global", configUser, password)
+	_, err = git.Config("--global", configToken, username)
 
 	fmt.Println("")
 	fmt.Println(fmt.Sprintf("%s Successfully authorized: 'git phlow' is now enabled", username))

plugins/gh.go

@@ -55,6 +55,64 @@ func init() {
 	}
 }
 
+//AuthorizeGitHub ...
+//Retrieve token from github for authorization
+func AuthorizeGitHub(githubBaseURL, user, pass string) (token string, err error) {
+
+	perm, err := createGHPermissions()
+	if err != nil {
+		return "", err
+	}
+
+	req, _ := http.NewRequest("POST", githubBaseURL+"/authorizations", bytes.NewBuffer([]byte(perm)))
+	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+	req.SetBasicAuth(user, pass)
+	client := http.DefaultClient
+
+	res, err := client.Do(req)
+	if err != nil {
+		return "", err
+	}
+
+	err = requestStatus(res)
+	if err != nil {
+		return "", err
+	}
+	defer res.Body.Close()
+
+	re := Auth{}
+	err = json.NewDecoder(res.Body).Decode(re)
+	if err != nil {
+		return "", err
+	}
+	return re.Token, nil
+}
+
+//AuthenticateGitHub
+//Checks personal access token validity by requesting private repositories and checking status code
+func AuthenticateGitHub(githubBaseURL string, user, token string) (bool, error) {
+
+	req, _ := http.NewRequest("GET", githubBaseURL+"/user/repos", nil)
+	q := req.URL.Query()
+	q.Add("access_token", token)
+	req.URL.RawQuery = q.Encode()
+	client := http.DefaultClient
+
+	res, err := client.Do(req)
+	if err != nil {
+		return false, err
+	}
+	defer res.Body.Close()
+
+	if res.StatusCode != http.StatusOK {
+		return false, errors.New(strconv.Itoa(res.StatusCode))
+	}
+	return true, nil
+}
+
+
+// ------------------------------------------ DEPRECATE SECTION
+
 //GetIssues ...
 func (g *GitHubImpl) GetIssues() (issues []Issue, err error) {
 	URL := fmt.Sprintf(g.URLNoEsc(urls.issueURL), g.org, g.repo)
@@ -98,6 +156,7 @@ func (g *GitHubImpl) SetLabel(label string, issue int) (labels []Label, err erro
 	return re, nil
 }
 
+
 //Default ...
 //Get default branch of a GitHub issue
 func (g *GitHubImpl) Default() (defaultBranch string, err error) {

plugins/jira.go

@@ -0,0 +1,43 @@
+package plugins
+
+import (
+	"net/http"
+	"github.com/go-errors/errors"
+)
+
+
+//AuthenticateJIRA ...
+func AuthenticateJIRA(url, user, pass string) (bool, error) {
+	verifyURL := "/rest/api/latest/mypermissions"
+	req, _ := http.NewRequest("GET", url+verifyURL, nil)
+	req.Header.Set("Content-Type", "application/json")
+	req.SetBasicAuth(user, pass)
+	client := http.DefaultClient
+
+	res, err := client.Do(req)
+	if err != nil {
+		return false, err
+	}
+	defer res.Body.Close()
+
+	if res.StatusCode != 200 {
+		return false, errors.New("Could not verify credentials")
+	}
+	return true, nil
+}
+
+//AuthorizeJIRA ...
+//JIRA basic auth do not require authorization, so we just validate the user have giving right credentials with AuthenticateJIRA
+func AuthorizeJIRA(URL, user, pass string) (token string, err error) {
+
+	authorized, err := AuthenticateJIRA(URL, user, pass)
+	if err != nil {
+		return "", err
+	}
+
+	if authorized == false {
+		return "", errors.New("not authorized")
+	}
+
+	return pass, nil
+}