moosetechnology / GitProjectHealth / 13386705041

GithubModelImporter >> api [

        self

                deprecated: 'Use #repoApi instead'

                on: '7 October 2024'

                in:

                'Pharo-11.0.0+build.726.sha.aece1b5473acf3830a0e082c1bc3a15d4ff3522b (64 Bit)'.

        ^ repoApi

]

GithubModelImporter >> api: anObject [

        self

                deprecated: 'Use #repoApi: instead'

                on: '7 October 2024'

                in:

                'Pharo-11.0.0+build.726.sha.aece1b5473acf3830a0e082c1bc3a15d4ff3522b (64 Bit)'.

        repoApi := anObject

]

GithubModelImporter >> completeImportProject: aGLHProject [

        self importPipelinesOf: aGLHProject.

        self importBranchesOf: aGLHProject.

        self withCommitsSince ifNotNil: [ :withCommitSince | "If not nil, it means we have to import commit"

                | commits |

                commits := self importCommitsOfProject: aGLHProject.

                self chainsCommitsFrom: commits ]

]

GithubModelImporter >> completeImportedCommit: aGLHCommit [

        | result |

        ('completing commit: ' , aGLHCommit short_id printString) recordInfo.

        "link commit to user"

        self importCreatorOfCommit: aGLHCommit.

        "import deletion and addition"

        result := self repoApi

                          commit: aGLHCommit id

                          ofOrganisation: aGLHCommit repository project group name

                          ofProject: aGLHCommit repository project name.

        aGLHCommit deletions:

                ((result at: #files) collect: [ :file | file at: #deletions ]) sum.

        aGLHCommit additions:

                ((result at: #files) collect: [ :file | file at: #additions ]) sum.

        "import diffs of this commits"

        self withCommitDiffs ifTrue: [

                | diffs |

                aGLHCommit diffs ifEmpty: [

                        diffs := self parseDiffresult: result.

                        diffs := aGLHCommit diffs

                                         addAll: diffs

                                         unless: self blockForDiffEquality.

                        self glhModel addAll: diffs unless: self blockForDiffEquality.

                        diffs do: [ :diff | self importDiffRangesForDiff: diff ] ] ].

        ^ aGLHCommit 

]

GithubModelImporter >> convertApiFileAsFile: aAPIFile [

        aAPIFile type = 'dir' ifTrue: [ 

                ^ GLHFileDirectory new

                          name: aAPIFile name;

                          yourself ].

        ^ GLHFileBlob new

                  name: aAPIFile name;

                  yourself

]

GithubModelImporter >> ensureGroupNamed: aGroupName [

        ^ self glhModel

                  detect: [ :a |

                  (a isKindOf: GLHGroup) and: [ a name = aGroupName ] ]

                  ifNone: [ self glhModel newGroupNamed: aGroupName ]

]

GithubModelImporter >> importBranchesOf: project [

        "add the pipeline (actions runs) in the project"

        | branchesResult branches repository |

        branchesResult := self repoApi

                                  branchesOfRepo: project name

                                  ofOrganization: project group name.

        branches := self parseBranchesResult: branchesResult.

        self glhModel addAll: branches.

        repository := GLHRepository new.

        self glhModel add: repository.

        project repository: repository.

        branches do: [ :branch | 

                repository addBranch: branch.

                self withFiles ifTrue: [ self importFilesOfBranch: branch ] ]

]

GithubModelImporter >> importCommitsOfProject: aGLHProject [

        | itemByPage foundCommits tmp pageNumber |

        itemByPage := 100.

        pageNumber := 1.

        ('Extract all commits of ' , aGLHProject name) recordInfo.

        foundCommits := OrderedCollection new.

        ('Extract commits from ' , foundCommits size printString , ' to '

         , (foundCommits size + itemByPage) printString) recordInfo.

        "also check that there is at least one commit with the error handling"

        [

        tmp := self parseCommitsResult: (self repoApi

                                commitsOfProject: aGLHProject name

                                ofOrganization: aGLHProject group name

                                since: self withCommitsSince

                                perPage: itemByPage

                                page: pageNumber) ]

                on: GHRepositoryEmptyError

                do: [ ^ {  } ].

        foundCommits addAll: tmp.

        [ tmp size = itemByPage ] whileTrue: [

                pageNumber := pageNumber + 1.

                ('Extract issues from ' , foundCommits size printString , ' to '

                 , (foundCommits size + itemByPage) printString) recordInfo.

                tmp := self parseCommitsResult: (self repoApi

                                        commitsOfProject: aGLHProject name

                                        ofOrganization: aGLHProject group name

                                        since: self withCommitsSince

                                        perPage: itemByPage

                                        page: pageNumber).

                foundCommits addAll: tmp ].

        "add the imported commits (unless they are already added to this repository)"

        aGLHProject repository commits

                addAll: foundCommits

                unless: [ :existing :new | existing id = new id ].

        "add the imported commits to the model unles they are already added to the model"

        ^ self glhModel

                  addAll: foundCommits

                  unless: [ :existing :new | existing id = new id ]

]

GithubModelImporter >> importCreatorOfCommit: aGLHCommit [ 

                | creator |

        (self glhModel allWithType: GLHUser)

                detect: [ :user | user username = aGLHCommit author_name ]

                ifFound: [ :user |

                        aGLHCommit commitCreator: user.

                        ^ user ].

        creator := self importUserByUsername: aGLHCommit author_name.

        aGLHCommit commitCreator: creator.

        ^ creator

]

GithubModelImporter >> importDiffOfCommit: aGLHCommit [

        | result diffsResult |

        aGLHCommit diffs ifNotEmpty: [

                'Diff already importer: '

                , aGLHCommit short_id printString recordInfo.

                ^ aGLHCommit diffs ].

        ('Import diff of commit: ' , aGLHCommit short_id printString)

                recordInfo.

        result := self repoApi

                          commit: aGLHCommit id

                          ofOrganisation: aGLHCommit repository project group name

                          ofProject: aGLHCommit repository project name.

        diffsResult := self parseDiffresult: result.

        ^ aGLHCommit diffs

                  addAll: diffsResult

                  unless: self blockForDiffEquality

]

GithubModelImporter >> importDirectoryFiles: aDirectoryFile OfBranch: aBranch [

        | result files apiFiles |

        ('Explore ' , aDirectoryFile name) recordInfo.

        result := self api

                          contentsOfRepo: aBranch repository project name

                          ofOrganization: aBranch repository project group name

                          inBranch: aBranch name

                          withPath: aDirectoryFile path.

        apiFiles := self parseFileTreeResult: result.

        files := apiFiles collect: [ :apiFile | 

                         self convertApiFileAsFile: apiFile ].

        files do: [ :file | 

                self glhModel add: file.

                aDirectoryFile addFile: file ].

        files

                select: [ :file | file isKindOf: GLHFileDirectory ]

                thenCollect: [ :file | 

                self importDirectoryFiles: file OfBranch: aBranch ]

]

GithubModelImporter >> importFilesOfBranch: aBranch [

        | result files apiFiles |

        result := self api

                          contentsOfRepo: aBranch repository project name

                          ofOrganization: aBranch repository project group name

                          inBranch: aBranch name

                          withPath: nil.

        apiFiles := self parseFileTreeResult: result.

        files := apiFiles collect: [ :apiFile | 

                         self convertApiFileAsFile: apiFile ].

        files do: [ :file | 

                self glhModel add: file.

                aBranch addFile: file ].

        files

                select: [ :file | file isKindOf: GLHFileDirectory ]

                thenCollect: [ :file | 

                self importDirectoryFiles: file OfBranch: aBranch ]

]

GithubModelImporter >> importGroup: aGroupName [

        | result groupResult |

        result := self repoApi organization: aGroupName.

        groupResult := self parseGroupResult: result.

        self glhModel add: groupResult.

        self importRepositoriesOfGroup: groupResult.

        ^ groupResult

]

GithubModelImporter >> importMergeRequests: aProject [ 

        |response mergeRequests|

        response := self repoApi 

                        mergeRequestsOfRepo: aProject group name 

                        ofProject: aProject name.

        mergeRequests := self parseMergeRequestResult: response. 

        mergeRequests := aProject mergeRequests addAll:mergeRequests unless: self blockOnIdEquality.

        ^ mergeRequests

]

GithubModelImporter >> importPipelinesOf: project [

        "add the pipeline (actions runs) in the project"

        | pipelinesResult ghApiPipelineOverview |

        pipelinesResult := self repoApi

                                   actionsRunOfRepo: project name

                                   ofOrganization: project group name.

        ghApiPipelineOverview := self parsePipelinesResult: pipelinesResult.

        ghApiPipelineOverview workflow_runs do: [ :pipeline | 

                project addPipeline: pipeline ]

]

GithubModelImporter >> importProject: aProjectName ofGroup: aGroupName [

        | result projectResult group |

        group := self ensureGroupNamed: aGroupName.

        result := self repoApi organization: aGroupName repo: aProjectName.

        projectResult := self parseProjectResult: result.

        projectResult group: group.

        self glhModel add: projectResult.

        self completeImportProject: projectResult.

        ^ projectResult

]

GithubModelImporter >> importRepositoriesOfGroup: groupResult [

        | reposResult itemByPage pageNumber reposFound tmp |

        itemByPage := 100.

        pageNumber := 1.

        ('Extract all repository of ' , groupResult name) recordInfo.

        reposFound := OrderedCollection new.

        ('Extract commits from ' , reposFound size printString , ' to '

         , (reposFound size + itemByPage) printString) recordInfo.

        tmp := self parseArrayOfProject: (self repoApi

                                reposOfOrganization: groupResult name

                                perPage: itemByPage

                                page: pageNumber).

        reposFound addAll: tmp.

        [ tmp size = itemByPage ] whileTrue: [

                pageNumber := pageNumber + 1.

                ('Extract issues from ' , reposFound size printString , ' to '

                 , (reposFound size + itemByPage) printString) recordInfo.

                tmp := self parseArrayOfProject: (self repoApi

                                        reposOfOrganization: groupResult name

                                        perPage: itemByPage

                                        page: pageNumber).

                reposFound addAll: tmp ].

        reposResult := self repoApi reposOfOrganization: groupResult name.

        groupResult projects addAll: reposFound.

        self glhModel addAll: groupResult projects.

        groupResult projects do: [ :project |

                self completeImportProject: project ].

        ^ groupResult

]

GithubModelImporter >> importUser: userID [

        | result userResult |

        (glhModel allWithType: GLHUser)

                detect: [ :user | user id = userID ]

                ifFound: [ :user | ^ user ].

        ('Import user: ' , userID printString) recordInfo.

        result := self repoApi user: userID.

        userResult := self parseUserResult: result.

        ^ glhModel

                  add: userResult

                  unless: [ :current :new | current id = new id ]

]

GithubModelImporter >> parseArrayOfProject: arrayOfProjects [

        | reader |

        reader := NeoJSONReader on: arrayOfProjects readStream.

        reader

                for: #ArrayOfProjects

                customDo: [ :customMappting | 

                customMappting listOfElementSchema: GLHProject ].

        reader for: GLHProject do: [ :mapping | 

                mapping mapInstVar: #name to: #name.

                mapping mapInstVar: #description to: #description.

                mapping mapInstVar: #id to: #id.

                mapping mapInstVar: #archived to: #archived.

                mapping mapInstVar: #web_url to: #html_url.

                mapping mapInstVar: #topics to: #topics ].

        ^ reader nextAs: #ArrayOfProjects

]

GithubModelImporter >> parseBranchesResult: arrayOfBranch [

        | reader |

        reader := NeoJSONReader on: arrayOfBranch readStream.

        reader mapInstVarsFor: GLHBranch.

        reader

                for: #ArrayOfBranch

                customDo: [ :customMappting | 

                customMappting listOfElementSchema: GLHBranch ].

        ^ reader nextAs: #ArrayOfBranch

]

GithubModelImporter >> parseDiffresult: response [

        | result |

        result := (response at: #files) collect: [ :file |

                          GLHDiff new

                                  diffString: (file at: #patch);

                                  old_path: (file at: #filename);

                                  new_path: (file at: #filename) ].

        ^ result

]

GithubModelImporter >> parseFileTreeResult: aResult [

        | reader |

        reader := NeoJSONReader on: aResult readStream.

        reader mapInstVarsFor: GHApiFile.

        reader

                for: #ArrayOfFile

                customDo: [ :customMappting | 

                customMappting listOfElementSchema: GHApiFile ].

        ^ reader nextAs: #ArrayOfFile

]

GithubModelImporter >> parseGroupResult: aResult [

        | reader |

        reader := NeoJSONReader on: aResult readStream.

        reader for: GLHGroup do: [ :mapping | 

                mapping mapInstVar: #name to: #login.

                mapping mapInstVar: #description to: #description.

                mapping mapInstVar: #id to: #id.

                mapping mapInstVar: #web_url to: #html_url ].

        ^ reader nextAs: GLHGroup

]

GithubModelImporter >> parseMergeRequestResult: response [

        | result |

        self flag: 'temp version, must remade using NeoJsonReader'.

        result := response collect: [ :aPull |

                          GLHMergeRequest new

                                  id: (aPull at: #id);

                                  title: (aPull at: #title);

                                  state: (aPull at: #state);

                                  closed_at:

                                          ((aPull at: #closed_at) ifNotNil: #asDateAndTime);

                                  merged_at:

                                          ((aPull at: #merged_at) ifNotNil: #asDateAndTime);

                                  updated_at:

                                          ((aPull at: #updated_at) ifNotNil: #asDateAndTime);

                                  created_at:

                                          ((aPull at: #created_at) ifNotNil: #asDateAndTime);

                                  sha: (aPull at: #head at: #sha);

                                  merge_commit_sha: (aPull at: #merge_commit_sha) ].

        result := self glhModel addAll: result unless: self blockOnIdEquality.

        ^ result

]

GithubModelImporter >> parseProjectResult: aResult [

        | reader |

        reader := NeoJSONReader on: aResult readStream.

        reader for: GLHProject do: [ :mapping |

                mapping mapInstVar: #name to: #name.

                mapping mapInstVar: #description to: #description.

                mapping mapInstVar: #id to: #id.

                mapping mapInstVar: #archived to: #archived.

                mapping mapInstVar: #web_url to: #html_url.

                mapping mapInstVar: #topics to: #topics ].

        ^ reader nextAs: GLHProject

]

GithubModelImporter >> privateToken [

        ^ self api privateToken

]

GithubModelImporter >> privateToken: aTokenString [

        ^ self repoApi privateToken: aTokenString

]