def getDetail(project_id):
        # Load project from internal database
        project = models.Project.query.filter_by(id=project_id).first()

        # Check if project was found
        if not project:
            validation = ValidationResult(dict())
            validation.addError("Project not in internal database")

            return validation

        # Init result cloud api
        resultCloud = ResultCloud(config.RESULT_CLOUD_API)
        
        # Try to load project
        try:
            response = resultCloud.get_project(project.ext_id)
        except:
            # Prepare validation and return result
            validation = ValidationResult(models.serialize(project))
            return validation

        # Init result
        result = models.serialize(project)

        # If there was a response, get submissions
        if response:
            result["submissions"] = resultCloud.last_response['Result']['Submissions']

        # Prepare validation and return result
        validation = ValidationResult(result)
        return validation
    def getList():
        # Init api handler
        resultCloud = ResultCloud(config.RESULT_CLOUD_API)

        # Try to load projects from result cloud
        try:
            response  = resultCloud.get_git_projects()   
        except:
            # Load internal projects
            internalProjects = models.Project.query.all()

            # Prepare validation and return result
            validation =  ValidationResult([models.serialize(project) for project in internalProjects])
            return validation
 
        # Check if the request was successful
        if not response:
            # Load failed
            validationResult = ValidationResult(dict())
            validationResult.addError("Failed to load projects from ResultCloud repository")

            # Return result
            return validationResult
        else:
            # Load was successful
            externalProjects = resultCloud.last_response['Result']

            # Merge new projects
            for project in externalProjects:
                if not models.Project.query.filter_by(ext_id=project["Id"]).first():
                    new_project = models.Project(project["Id"], project["Name"], project["GitRepository"])
                    ProjectService.save(new_project)

            # Load internal projects
            internalProjects = models.Project.query.all()

            # Prepare validation and return result
            validation =  ValidationResult([models.serialize(project) for project in internalProjects])
            return validation
    def create(project_id):
        StateService.set("Getting project information")
        # Get detail about project
        validation = ProjectService.getDetail(project_id);

        # If getting detail failed, pass it
        if not validation.isValid:
            return validation;

        # Init tuple to hold data
        measurements = dict()

        # It went ok, so let us begin
        # We need to process each submission
        sortedSubmissions = sorted(validation.data["submissions"], key=lambda k: k['SequenceNumber'])
        for index, submission in enumerate(sortedSubmissions, start=0): 
            StateService.set(validation.data["name"] + ": Processing submission (" + str(index + 1) + "/" + str(sortedSubmissions.__len__()) + ")")
            # Init api handler
            resultCloud = ResultCloud(config.RESULT_CLOUD_API)

            # Get submission with test cases from result cloud
            try:
                response  = resultCloud.get_submission_by_id(submission["Id"])   
            except:
                # Prepare validation and return result
                validation.addError("Failed to load submission from ResultCloud")
                return validation

            # Failed to get response
            if not response:
                # Prepare validation and return result
                validation.addError("Failed to load submission from ResultCloud")
                return validation
            
            # Assign result 
            rcSubmission = resultCloud.last_response['Result']

            # Get changes of submission
            if index < 1:
                # There is no previous submission
                submissionValidation = RepositoryService.getRevisionDifference(validation.data["repository"], submission["GitHash"] + "^", submission["GitHash"])
            else:
                submissionValidation = RepositoryService.getRevisionDifference(validation.data["repository"], sortedSubmissions[index-1]["GitHash"] , submission["GitHash"])

            # Check if validation is ok
            if not validation.append(submissionValidation):
                return validation

            # We have all we need
            for testCase in ModelService._extractTestCases(rcSubmission):
                # Update measurements
                measurements = ModelService._updateModelMeasurements(measurements, ntpath.basename(testCase["Name"]), submissionValidation.data, testCase["ChangeFlag"])

        StateService.set(validation.data["name"] + ":Saving models")

        # Calculate and save models
        classifiers = ModelService._calculate(measurements)
        ModelService._saveClassifiers(classifiers, "project_" + project_id)

        StateService.reset()

        # Return validation
        return validation