def setUp(self):
self.client = Client()
self.user = User.objects.create_user('testuser', '*****@*****.**',
'testpassword')
self.client.login(username='******', password='******')
self.open_bug = Issue(issue_type='bug',
title='testbug1',
description='testdescription1',
author=self.user)
self.open_bug.save()
self.open_feature = Issue(issue_type='feature',
title='testfeature1',
description='testdescription1',
author=self.user)
self.open_feature.save()
self.closed_bug = Issue(issue_type='bug',
title='testbug2',
description='testdescription2',
author=self.user,
status='closed')
self.closed_bug.save()
self.closed_bug.date_complete = timezone.now()
self.closed_bug.save()
self.closed_feature = Issue(issue_type='feature',
title='testfeature2',
description='testdescription2',
author=self.user,
status='closed')
self.closed_feature.save()
self.closed_feature.date_complete = timezone.now()
self.closed_feature.save()
def test_create_proposal(self):
i = Issue(community=self.community, title="Issue ABC",
created_by=self.chairmen[0])
i.full_clean()
i.save()
title = 'Proposal XYZ'
content = 'hellow world'
self.assertEquals(0, Proposal.objects.count())
self.login_chairmen()
url = reverse('proposal_create', args=(self.community.id, i.id))
response = self.client.get(url)
self.assertEquals(200, response.status_code)
response = self.client.post(url, {
'proposal-type': ProposalType.RULE,
'proposal-title': title,
'proposal-content': content,
'proposal-tags': 'tag1,tag2,tag3',
})
self.assertEquals(200, response.status_code)
# Ajax call returns a partial html
self.assertEquals(1, Proposal.objects.count())
p = Proposal.objects.all()[0]
assert isinstance(p, Proposal)
self.assertContains(response, p.get_absolute_url())
self.assertEquals(title, p.title)
self.assertEquals(content, p.content)
def create_issue(request):
return Issue(title=request.POST['title'],
description=request.POST['description'],
latitude=request.POST['latitude'],
longitude=request.POST['longitude'],
tags=request.POST['tags'],
reporter=request.user)
def setUp(self):
self.year = Year.objects.create(start_year=2016)
self.group = Group.objects.create(name='name_groups', year=self.year)
self.course = Course.objects.create(name='course_name', year=self.year)
self.course.groups = [self.group]
self.course.save()
self.task = Task.objects.create(title='task',
course=self.course,
problem_id="A")
self.student = User.objects.create_user(username='******',
password='******')
self.responsible = User.objects.create_user(username='******',
password='******')
status = IssueStatus.objects.get(tag=Issue.STATUS_ACCEPTED)
self.issue = Issue()
self.issue.student = self.student
self.issue.task = self.task
self.issue.responsible = self.responsible
self.issue.status_field = status
self.issue.save()
self.issue.save()
self.issue_id = self.issue.id
def testIssueNotification(self):
user = create_user()
issue = Issue()
issue.description = "This is a test"
issue.save()
assert Issue.all().count() == 1
def setUp(self) -> None:
self.issue = Issue(
number=1,
name='any title',
body='any body',
main_language=ProgrammingLanguage.get_other_default_language(),
repository=Repository.objects.create(
name='iwannacontrib-issues-test-integration-test',
owner=Owner.objects.create(owner='carlosmaniero')))
self.issue.save()
def testIssueURL(self):
self._setup()
self.issue = Issue()
self.issue.description = "This is a test"
self.issue.project = self.project
self.issue.save()
assert self.issue.issueprojecturl_set.count() == 2
assert self.issue.issueprojecturl_set[0].status == "not_fixed"
def test_get_add_vote_to_cart(self):
feature = Issue(
issue_type='feature',
title='new feature 1',
description='this will be great',
author=self.user,
)
feature.save()
response = self.client.get(
reverse('add_vote_to_cart', args=[feature.id]))
self.assertEqual(response.status_code, 302)
self.assertRedirects(response, reverse('view_cart'))
def create_issue(request, issue_state):
data=None
if issue_state =='create':
data={
'issue_form': IssueForm(),
'issue_create':'active',
'page_title':'Create Issue',
'system_name':'Create Issue',
}
elif issue_state =='save':
if request.method == 'POST':
iss_form = IssueForm(request.POST, request.FILES)
if iss_form.is_valid():
dt = datetime.datetime.now()
curr=request.user
if not Issue.objects.filter(title__iexact=iss_form.cleaned_data['title'] ).exists():
issue_meta = Issue(
issue_volume = int(iss_form.cleaned_data['issue_volume']),
issue_number = int(iss_form.cleaned_data['issue_number']),
issue_year = iss_form.cleaned_data['issue_year'],
title = iss_form.cleaned_data['title'],
description = iss_form.cleaned_data['description'],
printIssn = iss_form.cleaned_data['printIssn'],
is_published = False,
# special_issue = models.BooleanField(default = False)
)
issue_meta.save()
if 'cover_photo' in request.FILES:
# print(request.FILES['image_path'])
issue_meta.cover_photo = request.FILES['cover_photo']
issue_meta.save()
request.session['issue_saved'] = issue_meta.id
else:
request.session['issue_saved'] = 0
return HttpResponseRedirect('/joumsy/issues_view/not_published')
else:
print('not post')
# json_response = json.dumps(data)
# return HttpResponse(json_response, content_type="application/json")
return render(request,'journals/index_issue.html', data)
def update_local_issue(
gr_issue,
id_namespace='',
service_namespace='',
):
"""
:param gr_issue: GeoReportv2 Issue structure (as a dict)
:param id_namespace: String to prepend to request identifiers
:param service_namespace: String to prepend to service codes
:return: The created/updated Issue and a `created` flag
"""
gr_issue = deepcopy(gr_issue)
identifier = gr_issue.pop('service_request_id')
if id_namespace:
identifier = '%s:%s' % (id_namespace, identifier)
issue = Issue.objects.filter(identifier=identifier).first()
if not issue:
issue = Issue(identifier=identifier)
created = True
else:
created = False
for field in Issue._meta.get_fields():
if field.name in gr_issue:
value = gr_issue.pop(field.name)
if isinstance(field, DateTimeField):
value = parse_date(value)
setattr(issue, field.attname, value)
if "long" in gr_issue and "lat" in gr_issue:
issue.location = GEOSGeometry(
'SRID=4326;POINT(%s %s)' %
(gr_issue.pop('long'), gr_issue.pop('lat')))
if 'service_code' in gr_issue:
gr_issue['service_code'] = '%s%s' % (service_namespace,
gr_issue['service_code'])
# This has no direct mapping in our schema, but it can be used by implicit autocreation of services
issue.service_name = gr_issue.pop('service_name', None)
issue._cache_data()
issue.full_clean()
issue.save()
extended_attributes = gr_issue.pop('extended_attributes', {})
for ex_class in get_extensions():
ex = ex_class()
ex.parse_extended_attributes(issue, extended_attributes)
if gr_issue:
print(gr_issue)
issue.source = gr_issue
return (issue, created)
def testIssueNumber(self):
issue = Issue()
issue.description = "This is a test"
issue.save()
assert issue.number == 1
issue = Issue()
issue.description = "This is a test"
issue.save()
assert issue.number == 2
old_issue = issue
issue = Issue()
issue.description = "This is a test"
issue.save()
assert issue.number == 3, issue.number
old_issue.delete()
issue = Issue()
issue.description = "This is a test"
issue.save()
assert issue.number == 4
def resource_report(request,
object_id,
template_name='depot/resource_report.html'):
"""
View for reporting a report when a user finds a problem with it.
"""
resource = get_one_or_404(Resource, id=ObjectId(object_id))
reporter = get_account(request.user.id)
# if 'next' in request.GET:
# url = request.GET['next']
# else:
# url = None
# url = url or reverse('resource', args=[resource.id])
if Issue.objects(reporter=reporter, related_document=resource).count():
messages.warning(request, 'You have already reported this resource.')
return HttpResponseRedirect(reverse('resource', args=[resource.id]))
if request.method == 'POST':
form = ResourceReportForm(request.POST)
if form.is_valid():
severity = int(form.cleaned_data['severity'])
message = form.cleaned_data['message']
issue = Issue(message=message,
severity=severity,
reporter=reporter)
issue.related_document = resource
issue.save()
issue.notify_created()
# only moderate as STATUS_BAD if SEVERITY_CRITICAL
if severity == SEVERITY_CRITICAL:
resource.moderate_as_bad(reporter)
return HttpResponseRedirect(
reverse('issue_detail', args=[issue.id]))
else:
form = ResourceReportForm()
return render_to_response(
template_name, {
'next': urlquote_plus(request.GET.get('next', '')),
'form': form,
'object': resource,
}, RequestContext(request))
def testIssueAndErrorNotification(self):
user = create_user()
issue = Issue()
issue.description = "This is a test"
issue.save()
assert Issue.all().count() == 1
c = Client()
c.post(reverse("error-post"), test_data)
#assert Notification.all().count() == 2
# this would be 2 when issues are turned on
assert Notification.all().count() == 1
c = Client()
res = c.get(reverse("notification-send"))
self.assertEquals(len(mail.outbox), 1)
def test_it_throws_an_exception_given_issue_already_exists(self) -> None:
issue = Issue(
number=1,
name='any title',
body='any body',
main_language=ProgrammingLanguage.get_other_default_language(),
repository=Repository.objects.create(
name='iwannacontrib-issues-test-integration-test',
owner=Owner.objects.create(owner='carlosmaniero')))
issue.save()
issues_url = "https://github.com/carlosmaniero/iwannacontrib-issues-test-integration-test/issues/1"
issue_to_be_created = IssueToBeCreated(issues_url)
service = CreateIssueService()
with self.assertRaises(IssueAlreadyExists) as context:
service.create_issue(self.github, issue_to_be_created)
self.assertEquals(context.exception.url, issues_url)
def add(self, language_name='Python', **rewrite):
self.issue_number += 1
data = dict(number=self.issue_number,
name=f'any title {self.issue_number}',
body='any body',
main_language=ProgrammingLanguage.objects.get_or_create(
name=language_name)[0],
repository=Repository.objects.get_or_create(
name='iwannacontrib-issues-test-integration-test',
owner=Owner.objects.get_or_create(
owner='carlosmaniero')[0])[0])
data.update(**rewrite)
issue = Issue(**data)
issue.save()
return issue
def create_issue(self, github: Github,
issue_to_be_created: IssueToBeCreated) -> Issue:
github_issue = self._get_github_issue(github, issue_to_be_created)
repository = Repository.objects.get_or_create(
name=issue_to_be_created.repository,
owner=Owner.objects.get_or_create(
owner=issue_to_be_created.owner)[0])[0]
if len(repository.issue_set.filter(
number=issue_to_be_created.number)) != 0:
raise IssueAlreadyExists(issue_to_be_created.url)
issue = Issue(number=issue_to_be_created.number,
name=github_issue.title,
body=github_issue.body,
repository=repository,
main_language=self._get_main_language(github_issue))
issue.save()
return issue
def test_vote_proposal(self):
# p = self.test_create_proposal()
######################################
i = Issue(community=self.community,
title="Issue ABC",
created_by=self.chairmen[0])
i.full_clean()
i.save()
title = 'Proposal XYZ'
content = 'hellow world'
p = Proposal.objects.create(type=ProposalType.RULE,
issue=i,
created_by=self.chairmen[0],
title=title,
content=content)
######################################
#TODO: create this via HTML request
pv = ProposalVote(proposal=p,
user=self.members[0],
value=ProposalVoteValue.CON)
pv.full_clean()
pv.save()
return pv
def handle(self,
count,
service,
min_lat=None,
max_lat=None,
min_lon=None,
max_lon=None,
**options):
service = Service.objects.get(service_code=service)
for i in range(count):
lat = long = None
if min_lat and max_lat and min_lon and max_lon:
lat = random.uniform(min_lat, max_lat)
long = random.uniform(min_lon, max_lon)
issue = Issue(
service=service,
lat=lat,
long=long,
submitter_email='*****@*****.**',
description=generate_description(),
)
issue.save()
self.stdout.write('{} issues created'.format(count))
def create(request):
errors = []
if 'submit' in request.POST:
issue = Issue()
issue.title = request.POST['title']
issue.content = request.POST['content']
issue.creator = request.user
due_time = request.POST.get('due_time', '').strip()
if len(due_time):
try:
due_time = parse_date(due_time)
if due_time:
issue.due_time = due_time
else:
errors.append('date-misformed')
except ValueError:
errors.append('date-invalid')
assignee = request.POST.get('assignee')
if assignee: # Empty value => not assigned, no need to set
try:
issue.assignee = User.objects.get(id=assignee)
except User.DoesNotExist:
assignee = None # Just in case we're under attack...
labels = []
for label_id in request.POST.getlist('labels'):
try:
labels.append(Label.objects.get(id=label_id))
except Label.DoesNotExist:
pass
if not errors:
issue.save(
) # Need to save before we can enforce N to N relationship
issue.starring.add(request.user) # Auto watch
# Add or remove labels has history so we don't worry on history creation
issue.labels.add(*labels)
mentions, _ = filter_mentions(issue.content)
if assignee:
mentions.add(issue.assignee)
mentions.discard(request.user)
for user in mentions:
issue.starring.add(user) # Auto watch
send_mail(request.user, user, 'mail/issue_created.html',
{'issue': issue})
# Broadcast new issues automatically
send_mail(request.user, settings.BROADCAST_EMAIL,
'mail/issue_created.html', {'issue': issue})
if assignee:
IssueHistory.objects.create(issue=issue,
user=request.user,
mode=IssueHistory.ASSIGN,
content=assignee)
if due_time:
IssueHistory.objects.create(issue=issue,
user=request.user,
mode=IssueHistory.SET_DUE,
content=due_time)
return redirect('issues:detail', issue.id)
return render(
request, 'issues/create.html', {
'labels': Label.objects.all(),
'users': sorted_users(User.objects.filter(is_active=True)),
'errors': errors,
})
def setUp(self):
order = Order(full_name="Name", date="2019-04-08")
order.save()
issue = Issue(title="Test Issue")
issue.save()
def test_add_to_cart(self):
issue = Issue(title="Test Issue")
issue.save()
page = self.client.get("/cart/add/{0}".format(issue.id))
self.assertEqual(page.status_code, 302)
def _issue(self):
self.issue = Issue()
self.issue.description = "This is a test"
self.issue.save()
def checkout(request):
if request.method == 'POST':
order_form = OrderForm(request.POST)
payment_form = MakePaymentForm(request.POST)
if order_form.is_valid() and payment_form.is_valid():
cart_items = Cart.objects.filter(user=request.user)
payment_total = 0
for item in cart_items:
payment_total += item.amount
try:
customer = stripe.Charge.create(
amount = int(payment_total * 100),
currency = 'EUR',
description = request.user.email,
card = payment_form.cleaned_data['stripe_id']
)
except stripe.error.CardError:
messages.error(request, 'Your card was declined.')
if customer.paid:
messages.success(request, 'You have successfully paid.')
order_instance = order_form.save(commit=False)
order_instance.date = timezone.now()
order_instance.user = request.user
order_instance.save()
for item in cart_items:
if item.request_type == 'new feature':
new_feature = Issue(
issue_type = 'feature',
title = item.title,
description = item.description,
date_created = timezone.now(),
author = request.user,
total_paid = item.amount
)
new_feature.save()
order_line_item = OrderLineItem(
order = order_instance,
issue = new_feature,
request_type = item.request_type,
amount_paid = item.amount
)
order_line_item.save()
elif item.request_type == 'feature vote':
this_feature = Issue.objects.get(pk=item.feature_id)
current_amount = this_feature.total_paid
new_amount = current_amount + item.amount
Issue.objects.filter(pk=item.feature_id).update(total_paid=new_amount)
new_vote = IssueVote()
current_user = User.objects.get(username=request.user)
new_vote.issue = this_feature
new_vote.user = current_user
new_vote.save()
order_line_item = OrderLineItem(
order = order_instance,
issue = this_feature,
request_type = item.request_type,
amount_paid = item.amount
)
order_line_item.save()
Cart.objects.filter(user=request.user).delete()
return redirect(reverse('tracker'))
else:
message.error(request, 'Unable to take payment.')
else:
messages.error(request, 'We were unable to take a payment with that card.')
cart = Cart.objects.all().filter(user=request.user)
cart = Cart.objects.filter(user=request.user)
cart_count = Cart.objects.filter(user=request.user).count()
cart_total = 0
for item in cart:
cart_total += item.amount
else:
payment_form = MakePaymentForm()
order_form = OrderForm()
cart = Cart.objects.filter(user=request.user)
cart_count = Cart.objects.filter(user=request.user).count()
cart_total = 0
for item in cart:
cart_total += item.amount
return render(request, 'checkout.html', {
'payment_form': payment_form,
'order_form': order_form,
'publishable': settings.STRIPE_PUBLISHABLE,
'cart': cart,
'cart_total': cart_total,
'cart_count': cart_count
})
def testLogAdded(self):
issue = Issue()
issue.description = "This is a test"
issue.save()
assert issue.log_set[0]
