def test_project_list_with_discover_mode_enabled(client, data):
    url = "{}?{}".format(reverse('projects-list'), "discover_mode=true")

    response = client.get(url)
    projects_data = json.loads(response.content.decode('utf-8'))
    assert len(projects_data) == 2
    assert response.status_code == 200

    client.login(data.registered_user)

    response = client.get(url)
    projects_data = json.loads(response.content.decode('utf-8'))
    assert len(projects_data) == 2
    assert response.status_code == 200

    client.login(data.project_member_with_perms)

    response = client.get(url)
    projects_data = json.loads(response.content.decode('utf-8'))
    assert len(projects_data) == 2
    assert response.status_code == 200

    client.login(data.project_owner)

    response = client.get(url)
    projects_data = json.loads(response.content.decode('utf-8'))
    assert len(projects_data) == 2
    assert response.status_code == 200

def test_user_list(client, data):
    url = reverse("users-list")

    response = client.get(url)
    users_data = json.loads(response.content.decode("utf-8"))
    assert len(users_data) == 0
    assert response.status_code == 200

    client.login(data.registered_user)

    response = client.get(url)
    users_data = json.loads(response.content.decode("utf-8"))
    assert len(users_data) == 1
    assert response.status_code == 200

    client.login(data.other_user)

    response = client.get(url)
    users_data = json.loads(response.content.decode("utf-8"))
    assert len(users_data) == 1
    assert response.status_code == 200

    client.login(data.superuser)

    response = client.get(url)
    users_data = json.loads(response.content.decode("utf-8"))
    assert len(users_data) == 3
    assert response.status_code == 200

def test_projects_user_order(client):
    user = f.UserFactory.create(is_superuser=True)
    project_1 = f.create_project()
    role_1 = f.RoleFactory(project=project_1)
    f.MembershipFactory(user=user, project=project_1, is_owner=True, role=role_1, user_order=2)

    project_2 = f.create_project()
    role_2 = f.RoleFactory(project=project_2)
    f.MembershipFactory(user=user, project=project_2, is_owner=True, role=role_2, user_order=1)

    client.login(user)
    #Testing default id order
    url = reverse("projects-list")
    url = "%s?member=%s" % (url, user.id)
    response = client.json.get(url)
    response_content = json.loads(response.content.decode("utf-8"))
    assert response.status_code == 200
    assert(response_content[0]["id"] == project_1.id)

    #Testing user order
    url = reverse("projects-list")
    url = "%s?member=%s&order_by=memberships__user_order" % (url, user.id)
    response = client.json.get(url)
    response_content = json.loads(response.content.decode("utf-8"))
    assert response.status_code == 200
    assert(response_content[0]["id"] == project_2.id)

def test_resolver_list(client, data):
    url = reverse("resolver-list")

    users = [
        None,
        data.registered_user,
        data.project_member_without_perms,
        data.project_member_with_perms,
        data.project_owner,
    ]

    results = helper_test_http_method(client, "get", "{}?project=public".format(url), None, users)
    assert results == [200, 200, 200, 200, 200]
    results = helper_test_http_method(client, "get", "{}?project=private1".format(url), None, users)
    assert results == [200, 200, 200, 200, 200]
    results = helper_test_http_method(client, "get", "{}?project=private2".format(url), None, users)
    assert results == [401, 403, 403, 200, 200]

    client.login(data.other_user)
    response = client.get("{}?project=private2&us=1&task=2&issue=3&milestone=4".format(url))
    assert json.loads(response.content.decode("utf-8")) == {"project": data.private_project2.pk}

    client.login(data.project_owner)
    response = client.get("{}?project=private2&us=1&task=2&issue=3&milestone=4".format(url))
    assert json.loads(response.content.decode("utf-8")) == {
        "project": data.private_project2.pk,
        "us": 1,
        "task": 1,
        "issue": 1,
        "milestone": data.milestone.pk,
    }

def test_task_list(client, data):
    url = reverse("tasks-list")

    response = client.get(url)
    tasks_data = json.loads(response.content.decode("utf-8"))
    assert len(tasks_data) == 2
    assert response.status_code == 200

    client.login(data.registered_user)

    response = client.get(url)
    tasks_data = json.loads(response.content.decode("utf-8"))
    assert len(tasks_data) == 2
    assert response.status_code == 200

    client.login(data.project_member_with_perms)

    response = client.get(url)
    tasks_data = json.loads(response.content.decode("utf-8"))
    assert len(tasks_data) == 3
    assert response.status_code == 200

    client.login(data.project_owner)

    response = client.get(url)
    tasks_data = json.loads(response.content.decode("utf-8"))
    assert len(tasks_data) == 3
    assert response.status_code == 200

def test_epic_related_userstories_list(client, data):
    url = reverse('epics-related-userstories-list', args=[data.public_epic.pk])
    response = client.get(url)
    related_uss_data = json.loads(response.content.decode('utf-8'))
    assert len(related_uss_data) == 1
    assert response.status_code == 200

    client.login(data.registered_user)

    url = reverse('epics-related-userstories-list', args=[data.private_epic1.pk])
    response = client.get(url)
    related_uss_data = json.loads(response.content.decode('utf-8'))
    assert len(related_uss_data) == 1
    assert response.status_code == 200

    client.login(data.project_member_with_perms)

    url = reverse('epics-related-userstories-list', args=[data.private_epic2.pk])
    response = client.get(url)
    related_uss_data = json.loads(response.content.decode('utf-8'))
    assert len(related_uss_data) == 1
    assert response.status_code == 200

    client.login(data.project_owner)

    url = reverse('epics-related-userstories-list', args=[data.blocked_epic.pk])
    response = client.get(url)
    related_uss_data = json.loads(response.content.decode('utf-8'))
    assert len(related_uss_data) == 1
    assert response.status_code == 200

def test_wiki_link_list(client, data):
    url = reverse('wiki-links-list')

    response = client.get(url)
    wiki_links_data = json.loads(response.content.decode('utf-8'))
    assert len(wiki_links_data) == 2
    assert response.status_code == 200

    client.login(data.registered_user)

    response = client.get(url)
    wiki_links_data = json.loads(response.content.decode('utf-8'))
    assert len(wiki_links_data) == 2
    assert response.status_code == 200

    client.login(data.project_member_with_perms)

    response = client.get(url)
    wiki_links_data = json.loads(response.content.decode('utf-8'))
    assert len(wiki_links_data) == 3
    assert response.status_code == 200

    client.login(data.project_owner)

    response = client.get(url)
    wiki_links_data = json.loads(response.content.decode('utf-8'))
    assert len(wiki_links_data) == 3
    assert response.status_code == 200

def test_invalid_issue_import_with_bad_choices(client):
    user = f.UserFactory.create()
    project = f.ProjectFactory.create(owner=user)
    f.MembershipFactory(project=project, user=user, is_owner=True)
    project.default_issue_type = f.IssueTypeFactory.create(project=project)
    project.default_issue_status = f.IssueStatusFactory.create(project=project)
    project.default_severity = f.SeverityFactory.create(project=project)
    project.default_priority = f.PriorityFactory.create(project=project)
    project.save()
    client.login(user)

    url = reverse("importer-issue", args=[project.pk])
    data = {
        "subject": "Imported issue",
        "description": "Imported issue",
        "status": "Not valid"
    }

    response = client.post(url, json.dumps(data), content_type="application/json")
    assert response.status_code == 400
    response_data = json.loads(response.content.decode("utf-8"))
    assert len(response_data) == 1

    url = reverse("importer-issue", args=[project.pk])
    data = {
        "subject": "Imported issue",
        "description": "Imported issue",
        "priority": "Not valid"
    }

    response = client.post(url, json.dumps(data), content_type="application/json")
    assert response.status_code == 400
    response_data = json.loads(response.content.decode("utf-8"))
    assert len(response_data) == 1

    url = reverse("importer-issue", args=[project.pk])
    data = {
        "subject": "Imported issue",
        "description": "Imported issue",
        "severity": "Not valid"
    }

    response = client.post(url, json.dumps(data), content_type="application/json")
    assert response.status_code == 400
    response_data = json.loads(response.content.decode("utf-8"))
    assert len(response_data) == 1

    url = reverse("importer-issue", args=[project.pk])
    data = {
        "subject": "Imported issue",
        "description": "Imported issue",
        "type": "Not valid"
    }

    response = client.post(url, json.dumps(data), content_type="application/json")
    assert response.status_code == 400
    response_data = json.loads(response.content.decode("utf-8"))
    assert len(response_data) == 1

def test_valid_wiki_link_import(client):
    user = f.UserFactory.create()
    project = f.ProjectFactory.create(owner=user)
    f.MembershipFactory(project=project, user=user, is_owner=True)
    client.login(user)

    url = reverse("importer-wiki-link", args=[project.pk])
    data = {
        "title": "Imported wiki_link",
        "href": "imported-wiki-link",
    }

    response = client.post(url, json.dumps(data), content_type="application/json")
    assert response.status_code == 201
    json.loads(response.content.decode("utf-8"))

def test_import_epic_with_user_stories(client):
    project = f.ProjectFactory()
    project.default_points = f.PointsFactory.create(project=project)
    project.default_issue_type = f.IssueTypeFactory.create(project=project)
    project.default_issue_status = f.IssueStatusFactory.create(project=project)
    project.default_epic_status = f.EpicStatusFactory.create(project=project)
    project.default_us_status = f.UserStoryStatusFactory.create(project=project)
    project.default_task_status = f.TaskStatusFactory.create(project=project)
    project.default_priority = f.PriorityFactory.create(project=project)
    project.default_severity = f.SeverityFactory.create(project=project)

    epic = f.EpicFactory.create(subject="test epic export", project=project, status=project.default_epic_status)
    user_story = f.UserStoryFactory.create(project=project, status=project.default_us_status, milestone=None)
    f.RelatedUserStory.create(epic=epic, user_story=user_story, order=55)
    output = io.BytesIO()
    render_project(user_story.project, output)
    project_data = json.loads(output.getvalue())

    epic.project.delete()

    project = store_project_from_dict(project_data)
    assert project.epics.count() == 1
    assert project.epics.first().ref == epic.ref

    assert project.epics.first().user_stories.count() == 1
    related_userstory = project.epics.first().relateduserstory_set.first()
    assert related_userstory.user_story.ref == user_story.ref
    assert related_userstory.order == 55
    assert related_userstory.epic.ref == epic.ref

def test_export_issue_finish_date(client):
    issue = f.IssueFactory.create(finished_date="2014-10-22")
    output = io.StringIO()
    render_project(issue.project, output)
    project_data = json.loads(output.getvalue())
    finish_date = project_data["issues"][0]["finished_date"]
    assert finish_date == "2014-10-22T00:00:00+0000"

    def handle(self, *args, **options):
        dump_file_path = options["dump_file"]
        owner_email = options["owner_email"]
        overwrite = options["overwrite"]

        data = json.loads(open(dump_file_path, 'r').read())
        try:
            with transaction.atomic():
                if overwrite:
                    receivers_back = signals.post_delete.receivers
                    signals.post_delete.receivers = []
                    try:
                        proj = Project.objects.get(slug=data.get("slug", "not a slug"))
                        proj.tasks.all().delete()
                        proj.user_stories.all().delete()
                        proj.issues.all().delete()
                        proj.memberships.all().delete()
                        proj.roles.all().delete()
                        proj.delete()
                    except Project.DoesNotExist:
                        pass
                    signals.post_delete.receivers = receivers_back

                user = User.objects.get(email=owner_email)
                services.store_project_from_dict(data, user)
        except err.TaigaImportError as e:
            if e.project:
                e.project.delete_related_content()
                e.project.delete()

            print("ERROR:", end=" ")
            print(e.message)
            print(json.dumps(e.errors, indent=4))

def test_valid_concurrent_save_for_issue_different_versions(client):
    user = f.UserFactory.create()
    project = f.ProjectFactory.create(owner=user)
    membership = f.MembershipFactory.create(project=project, user=user, is_owner=True)
    client.login(user)

    mock_path = "taiga.projects.issues.api.IssueViewSet.pre_conditions_on_save"
    with patch(mock_path) as m:
        url = reverse("issues-list")
        data = {"subject": "test",
                      "project": project.id,
                      "status": f.IssueStatusFactory.create(project=project).id,
                      "severity": f.SeverityFactory.create(project=project).id,
                      "type": f.IssueTypeFactory.create(project=project).id,
                      "priority": f.PriorityFactory.create(project=project).id}
        response = client.json.post(url, json.dumps(data))
        assert response.status_code == 201, response.content

        issue_id = json.loads(response.content)["id"]
        url = reverse("issues-detail", args=(issue_id,))
        data = {"version":1, "subject": "test 1"}
        response = client.patch(url, json.dumps(data), content_type="application/json")
        assert response.status_code == 200

        data = {"version":2, "subject": "test 2"}
        response = client.patch(url, json.dumps(data), content_type="application/json")
        assert response.status_code == 200

def test_invalid_concurrent_save_for_us(client):
    user = f.UserFactory.create()
    project = f.ProjectFactory.create(owner=user)
    membership = f.MembershipFactory.create(project=project, user=user, is_owner=True)
    userstory = f.UserStoryFactory.create(version=10, project=project)
    client.login(user)

    mock_path = "taiga.projects.userstories.api.UserStoryViewSet.pre_conditions_on_save"
    with patch(mock_path) as m:
        url = reverse("userstories-list")
        data = {"subject": "test",
                      "project": project.id,
                      "status": f.UserStoryStatusFactory.create(project=project).id}
        response = client.json.post(url, json.dumps(data))
        assert response.status_code == 201

        userstory_id = json.loads(response.content)["id"]
        url = reverse("userstories-detail", args=(userstory_id,))
        data = {"version":1, "subject": "test 1"}
        response = client.patch(url, json.dumps(data), content_type="application/json")
        assert response.status_code == 200

        data = {"version":1, "subject": "test 2"}
        response = client.patch(url, json.dumps(data), content_type="application/json")
        assert response.status_code == 400

    def handle(self, *args, **options):
        data = json.loads(open(args[0], 'r').read())
        try:
            with transaction.atomic():
                if options["overwrite"]:
                    receivers_back = signals.post_delete.receivers
                    signals.post_delete.receivers = []
                    try:
                        proj = Project.objects.get(slug=data.get("slug", "not a slug"))
                        proj.tasks.all().delete()
                        proj.user_stories.all().delete()
                        proj.issues.all().delete()
                        proj.memberships.all().delete()
                        proj.roles.all().delete()
                        proj.delete()
                    except Project.DoesNotExist:
                        pass
                    signals.post_delete.receivers = receivers_back

                user = User.objects.get(email=args[1])
                dict_to_project(data, user)
        except TaigaImportError as e:
            print("ERROR:", end=" ")
            print(e.message)
            print(get_errors())

def test_export_user_story_finish_date(client):
    user_story = f.UserStoryFactory.create(finish_date="2014-10-22")
    output = io.StringIO()
    render_project(user_story.project, output)
    project_data = json.loads(output.getvalue())
    finish_date = project_data["user_stories"][0]["finish_date"]
    assert finish_date == "2014-10-22T00:00:00+0000"

def test_valid_milestone_import(client):
    user = f.UserFactory.create()
    project = f.ProjectFactory.create(owner=user)
    f.MembershipFactory(project=project, user=user, is_owner=True)
    client.login(user)

    url = reverse("importer-milestone", args=[project.pk])
    data = {
        "name": "Imported milestone",
        "estimated_start": "2014-10-10",
        "estimated_finish": "2014-10-20",
    }

    response = client.post(url, json.dumps(data), content_type="application/json")
    assert response.status_code == 201
    json.loads(response.content.decode("utf-8"))

def test_valid_task_import_with_extra_data(client):
    user = f.UserFactory.create()
    project = f.ProjectFactory.create(owner=user)
    f.MembershipFactory(project=project, user=user, is_owner=True)
    project.default_task_status = f.TaskStatusFactory.create(project=project)
    project.save()
    client.login(user)

    url = reverse("importer-task", args=[project.pk])
    data = {
        "subject": "Imported task",
        "description": "Imported task",
        "attachments": [{
            "owner": user.email,
            "attached_file": {
                "name": "imported attachment",
                "data": base64.b64encode(b"TEST").decode("utf-8")
            }
        }]
    }

    response = client.post(url, json.dumps(data), content_type="application/json")
    assert response.status_code == 201
    response_data = json.loads(response.content.decode("utf-8"))
    assert len(response_data["attachments"]) == 1
    assert response_data["owner"] == user.email
    assert response_data["ref"] is not None

def test_invalid_project_import_with_extra_data(client):
    user = f.UserFactory.create()
    client.login(user)

    url = reverse("importer-list")
    data = {
        "name": "Imported project",
        "description": "Imported project",
        "roles": [{
            "permissions": [],
            "name": "Test"
        }],
        "us_statuses": [{}],
        "severities": [{}],
        "priorities": [{}],
        "points": [{}],
        "issue_types": [{}],
        "task_statuses": [{}],
        "issue_statuses": [{}],
    }

    response = client.post(url, json.dumps(data), content_type="application/json")
    assert response.status_code == 400
    response_data = json.loads(response.content.decode("utf-8"))
    assert len(response_data) == 7
    assert Project.objects.filter(slug="imported-project").count() == 0

def test_retrieve_notify_policies_by_anonymous_user(client):
    project = f.ProjectFactory.create()

    policy = services.get_notify_policy(project, project.owner)

    url = reverse("notifications-detail", args=[policy.pk])
    response = client.get(url, content_type="application/json")
    assert response.status_code == 404, response.status_code
    assert json.loads(response.content.decode("utf-8"))["_error_message"] == "No NotifyPolicy matches the given query.", response.content