def generic_build(request, project_id_or_slug=None):
    try:
        project = Project.objects.get(pk=project_id_or_slug)
    # Allow slugs too
    except (Project.DoesNotExist, ValueError):
        try:
            project = Project.objects.get(slug=project_id_or_slug)
        except (Project.DoesNotExist, ValueError):
            pc_log.error(
                "(Incoming Generic Build) Repo not found:  %s" % (
                    project_id_or_slug))
            return HttpResponseNotFound(
                'Repo not found: %s' % project_id_or_slug)
    if request.method == 'POST':
        slug = request.POST.get('version_slug', None)
        if slug:
            pc_log.info(
                "(Incoming Generic Build) %s [%s]" % (project.slug, slug))
            _build_version(project, slug)
        else:
            pc_log.info(
                "(Incoming Generic Build) %s [%s]" % (project.slug, LATEST))
            trigger_build(project=project, force=True)
    else:
        return HttpResponse("You must POST to this resource.")
    return redirect('builds_project_list', project.slug)

    def done(self, form_list, **kwargs):
        """Save form data as object instance

        Don't save form data directly, instead bypass documentation building and
        other side effects for now, by signalling a save without commit. Then,
        finish by added the members to the project and saving.
        """
        form_data = self.get_all_cleaned_data()
        extra_fields = ProjectExtraForm.Meta.fields
        # expect the first form
        basics_form = form_list[0]
        # Save the basics form to create the project instance, then alter
        # attributes directly from other forms
        project = basics_form.save()
        tags = form_data.pop('tags', [])
        for tag in tags:
            project.tags.add(tag)
        for field, value in form_data.items():
            if field in extra_fields:
                setattr(project, field, value)
        basic_only = True
        project.save()
        project_import.send(sender=project, request=self.request)
        trigger_build(project, basic=basic_only)
        return HttpResponseRedirect(reverse('projects_detail',
                                            args=[project.slug]))

    def get(self, request, *args, **kwargs):
        """Process link request as a form post to the project import form"""
        self.request = request
        self.args = args
        self.kwargs = kwargs

        data = self.get_form_data()
        project = (Project.objects.for_admin_user(request.user)
                   .filter(repo=data['repo']).first())
        if project is not None:
            messages.success(
                request, _('The demo project is already imported!'))
        else:
            kwargs = self.get_form_kwargs()
            form = self.form_class(data=data, **kwargs)
            if form.is_valid():
                project = form.save()
                project.save()
                trigger_build(project, basic=True)
                messages.success(
                    request, _('Your demo project is currently being imported'))
            else:
                for (__, msg) in form.errors.items():
                    log.error(msg)
                messages.error(request,
                               _('There was a problem adding the demo project'))
                return HttpResponseRedirect(reverse('projects_dashboard'))
        return HttpResponseRedirect(reverse('projects_detail',
                                            args=[project.slug]))

    def test_trigger_build_when_version_not_provided_default_version_exist(self, update_docs_task):
        self.assertFalse(Version.objects.filter(slug='test-default-version').exists())

        project_1 = get(Project)
        version_1 = get(Version, project=project_1, slug='test-default-version', active=True)

        project_1.default_version = 'test-default-version'
        project_1.save()

        default_version = project_1.get_default_version()
        self.assertEqual(default_version, 'test-default-version')

        trigger_build(project=project_1)
        kwargs = {
            'version_pk': version_1.pk,
            'record': True,
            'force': False,
            'build_pk': mock.ANY,
        }

        update_docs_task.signature.assert_has_calls([
            mock.call(
                args=(project_1.pk,),
                kwargs=kwargs,
                options=mock.ANY,
                immutable=True,
            ),
        ])

 def handle(self, *args, **options):
     record = options['record']
     force = options['force']
     version = options['version']
     if len(args):
         for slug in args:
             if version and version != "all":
                 log.info("Updating version %s for %s" % (version, slug))
                 for version in Version.objects.filter(project__slug=slug, slug=version):
                     trigger_build(project=version.project, version=version)
             elif version == "all":
                 log.info("Updating all versions for %s" % slug)
                 for version in Version.objects.filter(project__slug=slug,
                                                       active=True,
                                                       uploaded=False):
                     tasks.update_docs(pk=version.project_id,
                                       record=False,
                                       version_pk=version.pk)
             else:
                 p = Project.all_objects.get(slug=slug)
                 log.info("Building %s" % p)
                 trigger_build(project=p, force=force)
     else:
         if version == "all":
             log.info("Updating all versions")
             for version in Version.objects.filter(active=True,
                                                   uploaded=False):
                 tasks.update_docs(pk=version.project_id,
                                   record=record,
                                   force=force,
                                   version_pk=version.pk)
         else:
             log.info("Updating all docs")
             tasks.update_docs_pull(record=record,
                                    force=force)

    def handle(self, *args, **options):
        force = options['force']
        version = options['version']

        if options.get('slugs', []):
            for slug in options['slugs']:
                if version and version != 'all':
                    log.info('Updating version %s for %s', version, slug)
                    for version in Version.objects.filter(
                            project__slug=slug,
                            slug=version,
                    ):
                        trigger_build(project=version.project, version=version)
                elif version == 'all':
                    log.info('Updating all versions for %s', slug)
                    for version in Version.objects.filter(
                            project__slug=slug,
                            active=True,
                            uploaded=False,
                    ):

                        build = Build.objects.create(
                            project=version.project,
                            version=version,
                            type='html',
                            state='triggered',
                        )

                        # pylint: disable=no-value-for-parameter
                        tasks.update_docs_task(
                            version.project_id,
                            build_pk=build.pk,
                            version_pk=version.pk,
                        )
                else:
                    p = Project.all_objects.get(slug=slug)
                    log.info('Building %s', p)
                    trigger_build(project=p, force=force)
        else:
            if version == 'all':
                log.info('Updating all versions')
                for version in Version.objects.filter(
                        active=True,
                        uploaded=False,
                ):
                    # pylint: disable=no-value-for-parameter
                    tasks.update_docs_task(
                        version.project_id,
                        force=force,
                        version_pk=version.pk,
                    )
            else:
                log.info('Updating all docs')
                for project in Project.objects.all():
                    # pylint: disable=no-value-for-parameter
                    tasks.update_docs_task(
                        project.pk,
                        force=force,
                    )

    def sync_versions(self, request, **kwargs):  # noqa: D205
        """
        Sync the version data in the repo (on the build server) with what we
        have in the database.

        Returns the identifiers for the versions that have been deleted.
        """
        project = get_object_or_404(
            Project.objects.api(request.user), pk=kwargs['pk'])

        # If the currently highest non-prerelease version is active, then make
        # the new latest version active as well.
        old_highest_version = determine_stable_version(project.versions.all())
        if old_highest_version is not None:
            activate_new_stable = old_highest_version.active
        else:
            activate_new_stable = False

        try:
            # Update All Versions
            data = request.data
            added_versions = set()
            if 'tags' in data:
                ret_set = api_utils.sync_versions(
                    project=project, versions=data['tags'], type=TAG)
                added_versions.update(ret_set)
            if 'branches' in data:
                ret_set = api_utils.sync_versions(
                    project=project, versions=data['branches'], type=BRANCH)
                added_versions.update(ret_set)
            deleted_versions = api_utils.delete_versions(project, data)
        except Exception as e:
            log.exception("Sync Versions Error: %s", e.message)
            return Response({'error': e.message}, status=status.HTTP_400_BAD_REQUEST)

        promoted_version = project.update_stable_version()
        if promoted_version:
            new_stable = project.get_stable_version()
            log.info(
                "Triggering new stable build: {project}:{version}".format(
                    project=project.slug,
                    version=new_stable.identifier))
            trigger_build(project=project, version=new_stable)

            # Marking the tag that is considered the new stable version as
            # active and building it if it was just added.
            if (
                    activate_new_stable and
                    promoted_version.slug in added_versions):
                promoted_version.active = True
                promoted_version.save()
                trigger_build(project=project, version=promoted_version)

        return Response({
            'added_versions': added_versions,
            'deleted_versions': deleted_versions,
        })

    def handle(self, *args, **options):
        record = options['record']
        force = options['force']
        version = options['version']
        if args:
            for slug in args:
                if version and version != "all":
                    log.info("Updating version %s for %s", version, slug)
                    for version in Version.objects.filter(project__slug=slug, slug=version):
                        trigger_build(project=version.project, version=version)
                elif version == "all":
                    log.info("Updating all versions for %s", slug)
                    for version in Version.objects.filter(project__slug=slug,
                                                          active=True,
                                                          uploaded=False):

                        build_pk = None
                        if record:
                            build = Build.objects.create(
                                project=version.project,
                                version=version,
                                type='html',
                                state='triggered',
                            )
                            build_pk = build.pk

                        tasks.UpdateDocsTask().run(
                            pk=version.project_id,
                            build_pk=build_pk,
                            record=record,
                            version_pk=version.pk
                        )
                else:
                    p = Project.all_objects.get(slug=slug)
                    log.info("Building %s", p)
                    trigger_build(project=p, force=force, record=record)
        else:
            if version == "all":
                log.info("Updating all versions")
                for version in Version.objects.filter(active=True,
                                                      uploaded=False):
                    tasks.UpdateDocsTask().run(
                        pk=version.project_id,
                        record=record,
                        force=force,
                        version_pk=version.pk
                    )
            else:
                log.info("Updating all docs")
                for project in Project.objects.all():
                    tasks.UpdateDocsTask().run(
                        pk=project.pk,
                        record=record,
                        force=force
                    )

 def build_default_version(self, request, queryset):
     """Trigger a build for the project version."""
     total = 0
     for project in queryset:
         trigger_build(project=project)
         total += 1
     messages.add_message(
         request,
         messages.INFO,
         'Triggered builds for {} project(s).'.format(total),
     )

 def save_version(self, version):
     new_value = self.cleaned_data.get('version-%s' % version.slug, None)
     privacy_level = self.cleaned_data.get('privacy-%s' % version.slug,
                                           None)
     if ((new_value is None or
          new_value == version.active)
         and (privacy_level is None or
              privacy_level == version.privacy_level)):
         return
     version.active = new_value
     version.privacy_level = privacy_level
     version.save()
     if version.active and not version.built and not version.uploaded:
         trigger_build(project=self.project, version=version)

 def build_version(self, request, queryset):
     """Trigger a build for the project version."""
     total = 0
     for version in queryset:
         trigger_build(
             project=version.project,
             version=version,
         )
         total += 1
     messages.add_message(
         request,
         messages.INFO,
         'Triggered builds for {} version(s).'.format(total),
     )

    def post(self, request, project_slug):
        project = get_object_or_404(
            Project.objects.for_admin_user(self.request.user),
            slug=project_slug
        )
        version_slug = request.POST.get('version_slug')
        version = get_object_or_404(
            Version,
            project=project,
            slug=version_slug,
        )

        trigger_build(project=project, version=version)
        return HttpResponseRedirect(reverse('builds_project_list', args=[project.slug]))

    def post(self, request, project_slug):
        project = get_object_or_404(Project, slug=project_slug)

        if not AdminPermission.is_admin(request.user, project):
            return HttpResponseForbidden()

        version_slug = request.POST.get('version_slug')
        version = get_object_or_404(
            Version,
            project=project,
            slug=version_slug,
        )

        trigger_build(project=project, version=version)
        return HttpResponseRedirect(reverse('builds_project_list', args=[project.slug]))

    def post(self, request, project_slug):
        project = get_object_or_404(Project, slug=project_slug)

        if not AdminPermission.is_admin(request.user, project):
            return HttpResponseForbidden()

        version_slug = request.POST.get('version_slug')
        version = get_object_or_404(
            Version,
            project=project,
            slug=version_slug,
        )

        update_docs_task, build = trigger_build(
            project=project,
            version=version,
        )
        if (update_docs_task, build) == (None, None):
            # Build was skipped
            messages.add_message(
                request,
                messages.WARNING,
                "This project is currently disabled and can't trigger new builds.",
            )
            return HttpResponseRedirect(
                reverse('builds_project_list', args=[project.slug]),
            )

        return HttpResponseRedirect(
            reverse('builds_detail', args=[project.slug, build.pk]),
        )

 def test_trigger_build_time_limit(self, update_docs):
     """Pass of time limit"""
     trigger_build(project=self.project, version=self.version)
     update_docs().si.assert_has_calls([
         mock.call(
             self.project.pk,
             time_limit=720,
             soft_time_limit=600,
             queue=mock.ANY,
             force=False,
             record=True,
             build_pk=mock.ANY,
             version_pk=self.version.id,
         ),
     ])
     update_docs().si().apply_async.assert_called()

 def test_trigger_build_rounded_time_limit(self, update_docs):
     """Time limit should round down"""
     self.project.container_time_limit = 3
     trigger_build(project=self.project, version=self.version)
     update_docs().si.assert_has_calls([
         mock.call(
             self.project.pk,
             time_limit=3,
             soft_time_limit=3,
             queue=mock.ANY,
             force=False,
             record=True,
             build_pk=mock.ANY,
             version_pk=self.version.id,
         ),
     ])
     update_docs().si().apply_async.assert_called()

 def save_version(self, version):
     """Save version if there has been a change, trigger a rebuild."""
     new_value = self.cleaned_data.get(
         'version-{}'.format(version.slug),
         None,
     )
     privacy_level = self.cleaned_data.get(
         'privacy-{}'.format(version.slug),
         None,
     )
     if ((new_value is None or new_value == version.active) and
             (privacy_level is None or privacy_level == version.privacy_level)):  # yapf: disable  # noqa
         return
     version.active = new_value
     version.privacy_level = privacy_level
     version.save()
     if version.active and not version.built and not version.uploaded:
         trigger_build(project=self.project, version=version)

 def test_trigger_build_time_limit(self, update_docs):
     """Pass of time limit"""
     trigger_build(project=self.project, version=self.version)
     update_docs.assert_has_calls([
         mock.call.apply_async(
             time_limit=720,
             soft_time_limit=600,
             queue=mock.ANY,
             kwargs={
                 'pk': self.project.id,
                 'force': False,
                 'basic': False,
                 'record': True,
                 'build_pk': mock.ANY,
                 'version_pk': self.version.id
             }
         )
     ])

 def test_trigger_skipped_project(self, update_docs_task):
     self.project.skip = True
     self.project.save()
     result = trigger_build(
         project=self.project,
         version=self.version,
     )
     self.assertEqual(result, (None, None))
     self.assertFalse(update_docs_task.signature.called)
     self.assertFalse(update_docs_task.signature().apply_async.called)

 def test_trigger_build_invalid_time_limit(self, update_docs):
     """Time limit as string"""
     self.project.container_time_limit = '200s'
     trigger_build(project=self.project, version=self.version)
     update_docs().apply_async.assert_has_calls([
         mock.call(
             time_limit=720,
             soft_time_limit=600,
             queue=mock.ANY,
             kwargs={
                 'pk': self.project.id,
                 'force': False,
                 'basic': False,
                 'record': True,
                 'build_pk': mock.ANY,
                 'version_pk': self.version.id
             }
         )
     ])