def setUp(self):
self.client = app.test_client()
db.drop_all()
db.create_all()
c1 = Category(
category_id=0,
category_label="Technical Issue"
)
p1 = Priority(
priority_id=1,
priority_label="Medium"
)
s1 = Status(
status_id=0,
status_label="Submitted"
)
ro1 = Role(
role_id=0,
role_label="user"
)
ro2 = Role(
role_id=1,
role_label="assignee"
)
ro3 = Role(
role_id=2,
role_label="admin"
)
db.session.add_all([c1,p1,s1,ro1,ro2,ro3])
db.session.commit()
User.query.delete()
Issue.query.delete()
user1 = User.register(**TEST_USER1)
user2 = User.register(**TEST_USER2)
user1.role = 2
db.session.add_all([user1,user2])
db.session.commit()
issue1 = Issue(title="Test Issue 1", text="Issue 1 description", reporter=user1.id)
issue2 = Issue(title="Test Issue 2", text="Issue 2 description", reporter=user2.id)
db.session.add_all([issue1,issue2])
db.session.commit()
comment1 = Comment(comment_text="This is a comment", comment_user=2, comment_issue=2)
db.session.add(comment1)
db.session.commit()
def test_m2m_and_m2o(self):
r = User.objects.create(username="******")
g = User.objects.create(username="******")
i1 = Issue(num=1)
i1.client = r
i1.save()
i2 = Issue(num=2)
i2.client = r
i2.save()
i2.cc.add(r)
i3 = Issue(num=3)
i3.client = g
i3.save()
i3.cc.add(r)
self.assertQuerysetEqual(Issue.objects.filter(client=r.id), [
1,
2,
], lambda i: i.num)
self.assertQuerysetEqual(Issue.objects.filter(client=g.id), [
3,
], lambda i: i.num)
self.assertQuerysetEqual(Issue.objects.filter(cc__id__exact=g.id), [])
self.assertQuerysetEqual(Issue.objects.filter(cc__id__exact=r.id), [
2,
3,
], lambda i: i.num)
# These queries combine results from the m2m and the m2o relationships.
# They're three ways of saying the same thing.
self.assertQuerysetEqual(
Issue.objects.filter(Q(cc__id__exact=r.id) | Q(client=r.id)), [
1,
2,
3,
], lambda i: i.num)
self.assertQuerysetEqual(
Issue.objects.filter(cc__id__exact=r.id)
| Issue.objects.filter(client=r.id), [
1,
2,
3,
], lambda i: i.num)
self.assertQuerysetEqual(
Issue.objects.filter(Q(client=r.id) | Q(cc__id__exact=r.id)), [
1,
2,
3,
], lambda i: i.num)
def post(self):
user = users.get_current_user()
if not user:
self.redirect(users.create_login_url(self.request.uri))
return
duration_amount = int(self.request.get('duration_amount'))
multiplier = int(self.request.get('duration_multiplier'))
issue = Issue(
title=cgi.escape(self.request.get('title')),
description=cgi.escape(self.request.get('description')),
duration=duration_amount * multiplier,
)
issue.put()
if self.request.get('option1'):
issue.add_choice(cgi.escape(self.request.get('option1')))
if self.request.get('option2'):
issue.add_choice(cgi.escape(self.request.get('option2')))
if self.request.get('option3'):
issue.add_choice(cgi.escape(self.request.get('option3')))
if self.request.get('option4'):
issue.add_choice(cgi.escape(self.request.get('option4')))
if self.request.get('option5'):
issue.add_choice(cgi.escape(self.request.get('option5')))
self.redirect('/issue/%s' % (issue.key().id()))
def index(request):
if request.POST:
issue = Issue()
form = IssueForm(request.POST, instance=issue)
if (form.is_valid()):
#send issue to GitHub
title = form.cleaned_data.get('title')
body = form.cleaned_data.get('body')
url = 'https://api.github.com/repos/mcdermott-scholars/mcdermott/issues'
auth = (settings.GITHUB_USERNAME, settings.GITHUB_PASSWORD)
data = {'title': title, 'body': body}
r = requests.post(url, auth=auth, data=json.dumps(data))
messages.add_message(
request,
messages.SUCCESS if r.status_code == 201 else messages.ERROR,
'Issue submitted'
if r.status_code == 201 else 'Error submitting issue',
)
return redirect(reverse('issues:index'))
else:
form = IssueForm(request.POST, instance=issue)
else:
form = IssueForm()
context = {
'form': form,
}
return render(request, 'issues/index.html', context)
def create_issue(customer_id, body):
issue_schema = IssueSchema()
issue_data = issue_schema.load(body).data
new_issue = Issue(**issue_data)
if customers.get(customer_id):
new_issue.customer_id = customer_id
else:
response = {
'message': 'Customer with id {id} not exists'.format(id=customer_id)
}
return response, 409
db.session.add(new_issue)
db.session.commit()
issue_history = IssueHistory(
issue_id=new_issue.id,
status_id=1,
)
db.session.add(issue_history)
db.session.commit()
issue_data = issue_schema.dump(new_issue).data
return issue_data, 201
def post(self, slug):
"Create an issue against this project"
project = Project.all().filter('slug =', slug).fetch(1)[0]
# get details from the form
name = self.request.get("name")
description = self.request.get("description")
email = self.request.get("email")
try:
if Issue.all().filter('name =', name).filter('project =',
project).count() == 0:
issue = Issue(
name=name,
description=description,
project=project,
)
if email:
issue.email = email
issue.put()
mail.send_mail(
sender="*****@*****.**",
to=project.user.email(),
subject="[GitBug] New bug added to %s" % project.name,
body=
"""You requested to be emailed when a bug on GitBug was added:
Issue name: %s
Description: %s
Thanks for using GitBug <http://gitbug.appspot.com>. A very simple issue tracker.
""" % (issue.name, issue.description))
logging.info("issue created: %s in %s" % (name, project.name))
except Exception, e:
logging.error("error adding issue: %s" % e)
def new_issue():
"""New issue form and handler."""
categories = Category.query.all()
categories_list = [(c.category_id, c.category_label) for c in categories]
priorities = Priority.query.all()
priorities_list = [(p.priority_id, p.priority_label) for p in priorities]
# import pdb; pdb.set_trace()
form = NewIssueForm(category=0, priority=1)
form.category.choices = categories_list
form.priority.choices = priorities_list
if form.validate_on_submit():
title = form.title.data
text = form.text.data
category = form.category.data
priority = form.priority.data
issue = Issue(title=title,
text=text,
category=category,
priority=priority,
reporter=current_user.id)
db.session.add(issue)
db.session.commit()
flash("Issue submitted", "success")
return redirect("/")
return render_template('issues/new.html', form=form)
def create_issue(self, data):
session = self.session_maker()
try:
pollution_category_id = session.query(PollutionCategory).filter(
PollutionCategory.category == data.get(
'pollution_category')).one_or_none().id
data['pollution_category'] = pollution_category_id
unapproved_issue_id = session.query(IssueState).filter(
IssueState.state == 'new').one_or_none().id
data['state_id'] = unapproved_issue_id
new_issue = Issue(data)
session.add(new_issue)
session.commit()
issue_fields = [
'id', 'title', 'description', 'location', 'date',
'pollution_rating', 'pollution_category', 'creator'
]
result = to_dict(new_issue, [i for i in issue_fields])
point = wkb.loads(bytes(new_issue.location.data))
result['location'] = {'x': point.x, 'y': point.y}
result[
'pollution_category'] = new_issue.pollution_category.category
result['creator'] = new_issue.creator.username
return (result, True)
except Exception as e:
return (e.args, False)
def __load(self):
try:
handle = open(os.path.join(self.__base, "namespaces.txt"), mode='r', encoding='utf-8')
content = handle.read()
handle.close()
self.__ns = []
self.__data = {}
namespaces = content.split("\n")
for namespace in namespaces:
ns = Namespace.fromstr(namespace)
if ns is not None:
self.__ns.append(ns)
self.__data[ns.key] = []
for namespace in self.__ns:
key = namespace.key
handle = open(os.path.join(self.__base, key), 'rb')
entries = struct.unpack('>h', handle.read(2))[0]
issues = []
for entry in range(0, entries):
issue_no = struct.unpack('>h', handle.read(2))[0]
desc_len = struct.unpack('>h', handle.read(2))[0]
desc = handle.read(desc_len).decode('utf-8')
issues.append(Issue(issue_no, desc))
self.__data[key] = issues
return True
except Exception as e:
print(e)
return False
def parse_issue(ctxt, hook):
issue = hook["issue"]
return Issue(user=ctxt.user,
project=ctxt.project,
id=issue["id"],
title=issue["title"],
action=hook["action"],
url=issue["url"])
def parse_issue(ctxt, hook):
attrs = hook["object_attributes"]
return Issue(user=ctxt.user,
project=ctxt.project,
id=attrs["iid"],
title=attrs["title"],
action=_preterit(attrs["action"]),
url=attrs["url"])
def read_issues(file_name):
items = []
with gzip.open(f'{file_name}.gz', 'rb') as f:
reader = Reader(f)
# with jsonlines.open(file_name) as reader:
for obj in reader:
pr = create_obj(obj, Issue())
items.append(pr)
return items
def add_issue():
""" Create an issue """
data = request.get_json()
if 'title' in data and 'description' in data and data['title'].strip():
issue = Issue(data['title'].strip(), data['description'].strip(), current_user.id)
db.session.add(issue)
db.session.commit()
return jsonify(issue.to_dict()), 201
return 'Invalid title or description', 422
def create_issue():
data = json.loads(request.data)
issue = Issue(data["description"], data["lat"], data["lng"], data["kind"])
db.session.add(issue)
db.session.commit()
fh = open("issue_pics/{}.png".format(issue.id), "wb")
fh.write(data["image"].decode('base64'))
fh.close()
return json.dumps({"result": True})
def test_issue(self):
issue = Issue(user=self.user,
project=self.project,
id=42,
title="Wrong encoding",
action="opened",
url="http://bugtracker.example.com/issue/42")
self.assertEqual(
issue.render_simple(),
"[My Project] Mrs Foobar opened issue #42: Wrong encoding. "
"(http://bugtracker.example.com/issue/42)")
def project_issue_new(slug):
form = IssueForm()
project = Project.query.filter_by(slug=slug).first_or_404()
if form.validate_on_submit():
issue = Issue(project, current_user, form.urgency.data,
form.title.data, form.text.data)
db.session.add(issue)
db.session.commit()
flash("Created issue <a href=\"%s\">#%s</a>" %
(url_for('project_issue', slug=project.slug, iid=issue.id), issue.id))
return redirect(url_for('project_issue_new', slug=slug))
return render_template('issue_new.html', project=project, form=form)
async def api_upload(*, name, crashDoc, appDetail):
crash = await Crash.find(name)
if crash:
raise APIValueError('upload', '重复导入:%s' % name)
jsonCrashDoc = json.loads(crashDoc)
crashMap = jsonCrashDoc.get('crashMap', None)
if not crashMap:
raise APIValueError('upload', '找不到crashMap:%s' % name)
version = crashMap.get('productVersion', None)
if not version:
raise APIValueError('upload', '找不到productVersion:%s' % name)
content = crashMap.get('expMessage', None)
if not content:
raise APIValueError('upload', '找不到expMessage:%s' % name)
content = content.replace('\\"', '\"')
content = content.replace('\\n', '\n')
content = content.replace('\\t', '\t')
content_md5 = hashlib.md5(content.encode('utf-8')).hexdigest()
length = content.find('\n')
if length >= 0:
title = content[:length]
else:
title = content[:]
issues = await Issue.findAll(
where=r"`content_md5` = '%s' AND `version` = '%s'" %
(content_md5, version))
if (len(issues) == 1):
issue_id = issues[0].id
elif (len(issues) == 0):
issue_id = await Issue.findNumber('count(id)') + 1
issue = Issue(id=issue_id,
title=title,
content=content,
content_md5=content_md5,
version=version,
user_id=None,
status=0)
await issue.save()
else:
raise APIValueError('upload', '数据库存储错误%s' % name)
crash = Crash(id=name,
issue_id=issue_id,
crash_doc=crashDoc,
app_detail=appDetail)
await crash.save()
return "success"
def _ok(self, _=None):
f = None
try:
f = int(self.__iss.get())
except ValueError:
messagebox.showerror("Invalid Issue",
"Please input a valid issue number.")
return
if callable(self.__cbk):
self.__cbk(Issue(f, self.__desc.get()))
self.destroy()
def add_issue_by_form():
data = request.json
video_url = (data["video_url"]).replace("watch?v=", "embed/")
subcategory = Subcategory.query.filter(
Subcategory.name == data["subcategory"]).first()
new_issue = Issue(name=data["name"].title(),
video_url=video_url,
subcategory_id=subcategory.id,
num_hours=data["num_hours"],
difficulty=data["difficulty"])
db.session.add(new_issue)
db.session.commit()
return data
def issue_add(request):
if request.method == 'POST':
form = IssueForm(request.POST)
if form.is_valid():
form.save()
return render_to_response('common/success.html')
else:
issue = Issue(issue_out=date.today(),
issue_in=date.today() + timedelta(days=10))
form = IssueForm(instance=issue)
variables = RequestContext(request, {'form': form})
return render_to_response('crud/issues/issue_add.html', variables)
def createIssues():
title = request.json.get('title')
description = request.json.get('description')
user_assigned_to = request.json.get('user_assigned_to')
user_assigned_to_id = getID(user_assigned_to)
user = g.user
user_assigned_by_id = user.id
status = 'open'
newIssue = Issue(title=title,
description=description,
user_assigned_to_id=user_assigned_to_id,
user_assigned_by_id=user_assigned_by_id,
status=status)
session.add(newIssue)
session.commit()
return jsonify(newIssue.serialize)
def paynow(request):
languages = []
for lang in Issue.LANGUAGES:
languages.append(lang[0])
issuetracker = request.POST.get('issuetracker')
issueurl = request.POST.get('issueUrl')
issuetitle = request.POST.get('title')
issuesummary = request.POST.get('summary')
language = request.POST.get('language')
bounty = request.POST.get('bounty')
message = ''
if not bounty:
message = "Bounty is required."
if not issuesummary:
message = "Summary is required."
if not issuetitle:
message = "Title is required."
if not issueurl:
message = "Issue URL is required."
if not message:
userprofile = UserProfile()
issuesaver = Issue()
issuesaver.title = issuetitle
issuesaver.content = issuesummary
issuesaver.language = language
issuesaver.notified_user = False
issuesaver.status = "open"
issuesaver.user = request.user
issuesaver.save()
bountysaver = Bounty()
bountysaver.price = bounty
bountysaver.issue = issuesaver
bountysaver.user = request.user
bountysaver.save()
return render(request, 'post.html', {
'languages': languages,
'message': 'Successfully registered on DB.'
})
else:
return render(request, 'post.html', {
'languages': languages,
'message': message
})
def add_edit_issue(request, *args, **kwargs):
"""Adds/Edits issues"""
project_name = kwargs['project_name']
project = get_object_or_404(CollabProject, slug=project_name)
project_id = project.id
issueset_id = kwargs['issueset_id']
issueset = get_object_or_404(IssueSet, id__exact=issueset_id)
if not is_allowed(request, project_id, Issue._meta.verbose_name, 'Editable'):
return handle_privilege(request, "You do not have privileges to edit issues!", issueset.get_absolute_url())
if 'issue_id' in kwargs:
issue_id = kwargs['issue_id']
issue = get_object_or_404(Issue, id=issue_id)
# Check if the issue exists in that project AND issue set!
if issue.issueset.project.id != project.id or issue.issueset.id != issueset.id:
return handle_privilege(request, "The issue does not match the project or issue list!", project.get_absolute_url())
edit = True
instance=issue
else:
edit = False
instance=None
if request.method == 'POST':
form = IssueForm(request.POST, instance=instance, issueset=issueset)
if form.is_valid():
if not edit:
issue = Issue()
message = "The issue was added."
else:
message = "The issue was modified."
issue = form.save(commit=False)
if not edit:
issue.reporter = request.user
# issue.issueset = issueset
issue.save()
request.user.message_set.create(message=message)
return HttpResponseRedirect(issue.get_absolute_url())
else:
form = IssueForm(initial={'issueset': issueset.pk}, instance=instance, issueset=issueset)
return render_to_response('issues/add_edit_issue.html', {'form': form, 'edit': edit, 'project': project, 'issueset': issueset, 'issue': instance}, context_instance=RequestContext(request))
def add_issue(user_id, house_name, card_key_str, content):
pigeon_key = ndb.Key(Pigeon, user_id)
house_list = House.query(House.name == house_name).fetch()
house_key = house_list[0].key
card_key = ndb.Key(Card, card_key_str, parent=house_key)
issue = Issue(pigeon_key=pigeon_key,
house_key=house_key,
card_key=card_key,
comment=content,
date_str='')
issue.put()
date2str = str(issue.date)
str_list = date2str.split('.')
issue.date_str = str_list[0]
issue.put()
return
def add_issue_to_database(request):
issue = request.session.get('issue', False)
service = Service.objects.get(name=issue['service'])
try:
db_issue = Issue.objects.get(service=service,
number=issue['number'],
project=issue['project'])
if db_issue.status == "paid":
error = "I see that issue has been closed and paid already."
messages.error(request, error)
return False
except:
db_issue = Issue(service=service,
number=issue['number'],
project=issue['project'],
user=issue.has_key('user') and issue['user'] or '',
title=issue['title'],
content=issue['content'][:350],
status=issue['status'])
filename, file = get_image_for_issue(service, issue)
if filename:
db_issue.image.save(filename, file)
db_issue.save()
if not settings.DEBUG:
create_comment(db_issue)
ends = issue['limit']
hour_day = ends[-1]
number = ends.rstrip(hour_day)
if hour_day == "h":
limit = datetime.timedelta(hours=int(number))
else:
limit = datetime.timedelta(days=int(number))
bounty = Bounty(user=request.user,
issue=db_issue,
price=issue['bounty'],
ends=datetime.datetime.now() + limit)
bounty.save()
alert_watchers_increase(db_issue, int(request.GET.get('bounty', 0)))
del request.session['issue']
return True
def create_new(board, issue, user):
saved = Issue()
saved.board = board
saved.repository = issue['repository']
saved.issueid = str(issue['number'])
saved.title = str(issue['title'].encode('utf-8'))
saved.url = "https://github.com/" + issue['repository'] + "/issues/" + str(
issue['number'])
saved.created = issue['created_at'].split("T")[0]
saved.updated = issue['updated_at'].split("T")[0]
if "assignee" not in issue or not issue["assignee"]:
saved.assigned = "None"
else:
print issue['assignee']
saved.assigned = issue['assignee']['login']
saved.status = issue['state']
saved.changed = False
saved.release = "New"
saved.comments = "None"
saved.save()
def get_issue(self, issue_id):
return Issue(self.database.get_issue(issue_id))
def get_taiga_status(request, nomeProjeto):
try:
# Linka o projeto do Taiga com o projeto Knowleds
projeto_knowleds = ProjetoKnowLeds.objects.get(nome_webhook=nomeProjeto)
except:
pass
if request.method == 'POST':
print ('POST')
r = json.load(request)
if r['action'] == 'create' :
# Se for SPRINT
if r['type'] == 'milestone':
projeto = projeto_save(r['data']['project'], projeto_knowleds)
sprint_save(r['data'], projeto)
# Se for USER HISTORY
elif r['type'] == 'userstory':
projeto = projeto_save(r['data']['project'], projeto_knowleds)
print('ALGO MUDOU: ' + str(r))
userstory_save(r['data'],projeto)
# Se for TASK
elif r['type'] == 'task':
projeto = projeto_save( r['data']['project'], projeto_knowleds)
userStory = userstory_save(r['data']['user_story'], projeto)
task = Task()
# Atributos para salvar
task.ident = r['data']['id']
task.titulo = r['data']['subject']
task.descricao = r['data']['description']
task.userStory = userStory
task.tags = r['data']['tags']
task.is_closed = r['data']['status']['is_closed']
try:
##identificar qual user
task.user = r['data']['assigned_to']['username']
except:
pass
textoTag = task.titulo + ' precisa de ajuda, voce sabe a solucao'
for tag in task.getTags():
if tag == 'ajuda' or tag == 'Ajuda' or tag == 'AJUDA':
print('Mandando o email...')
send_mail('Ajuda em UserStory', textoTag, '*****@*****.**', ['*****@*****.**'], fail_silently=False)
task.save()
# Se for ISSUE
elif r['type'] == 'issue':
projeto = projeto_save(r['data']['project'], projeto_knowleds)
issue = Issue()
# Atributos para salvar
issue.ident = r['data']['id']
issue.titulo = r['data']['subject']
issue.descricao = r['data']['description']
issue.setTags(r['data']['tags'])
issue.is_closed = r['data']['status']['is_closed']
issue.projeto = projeto
issue.save()
textoTag = issue.titulo + ' precisa de ajuda, voce sabe a solucao'
for tag in issue.getTags():
if tag == 'ajuda' or tag == 'Ajuda' or tag == 'AJUDA':
print('Mandando o email...')
send_mail('Ajuda em UserStory', textoTag, '*****@*****.**', ['*****@*****.**'], fail_silently=False)
elif r['action'] == 'change':
# Se for USER HISTORY
if r['type'] == 'userstory':
projeto = projeto_save(r['data']['project'], projeto_knowleds)
userstory_save(r['data'],projeto)
# Se for TASK
elif r['type'] == 'task':
if Task.objects.filter(ident=r['data']['id']):
task = Task.objects.filter(ident=r['data']['id'])[0]
else:
task = Task()
projeto = projeto_save( r['data']['project'], projeto_knowleds)
userStory = userstory_save(r['data']['user_story'], projeto)
print("\n\nOlha aqui o user story: " + str(userStory))
# Atributos para salvar
task.ident = r['data']['id']
task.titulo = r['data']['subject']
task.descricao = r['data']['description']
task.userStory = userStory
task.tags = r['data']['tags']
task.is_closed = r['data']['status']['is_closed']
try:
##identificar qual user
task.user = r['data']['assigned_to']['username']
except:
pass
task.save()
"""
texto = ''
for t in Task.objects.all().filter(sprint_id=r['data']['milestone']['id']):
texto += 'Tarefa: ' + t.titulo + ': \n' + 'Descricao: '+ t.descricao + '\n \n \n'
# Se a tarefa encerrar o Sprint entra aqui
# para ENVIAR o EMAIL
email = Projeto.objects.get(nomeFantasia = 'Teste').email
print('Olha como esta o status: ' + str(r['data']['milestone']['closed']))
if r['data']['milestone']['closed']:
sprint = 'O Sprint: ' + r['data']['milestone']['name'] + ' foi encerrado'
send_mail(sprint, texto, '[email protected], [email protected],', [email], fail_silently=False)
textoTag = task.titulo + ' precisa de ajuda, voce sabe a solucao'
for tag in task.getTags():
if tag == 'ajuda' or tag == 'Ajuda' or tag == 'AJUDA':
print('Mandando o email...')
send_mail('Ajuda em UserStory', textoTag, '*****@*****.**', ['*****@*****.**'], fail_silently=False)
"""
# Se for ISSUE
elif r['type'] == 'issue':
projeto = projeto_save(r['data']['project'], projeto_knowleds)
try:
issue = Issue.objects.get(ident=r['data']['id'])
except:
issue = Issue()
pass
issue.ident = r['data']['id']
issue.titulo = r['data']['subject']
issue.descricao = r['data']['description']
issue.setTags(r['data']['tags'])
issue.is_closed = r['data']['status']['is_closed']
issue.projeto = projeto
issue.save()
textoTag = issue.titulo + ' precisa de ajuda, voce sabe a solucao'
for tag in issue.getTags():
if tag == 'ajuda' or tag == 'Ajuda' or tag == 'AJUDA':
print('Mandando o email...')
send_mail('Ajuda em UserStory', textoTag, '*****@*****.**', ['*****@*****.**'], fail_silently=False)
#Se for SPRINT
elif r['type'] == 'milestone':
projeto = projeto_save(r['data']['project'], projeto_knowleds)
sprint_save(r['data'], projeto)
return Response("POST", status=status.HTTP_201_CREATED)
elif request.method == 'GET':
return Response("GET")
# (c) Facebook, Inc. and its affiliates. Confidential and proprietary.
import os
if __name__ == "__main__":
try:
os.remove("database.sqlite3")
except IOError:
pass
from models import engine, session, Base, Run, Issue
Base.metadata.create_all(bind=engine)
session.add(Run(run_id=0))
session.add(Run(run_id=1))
session.add(
Issue(issue_id=0, source="UserControlled", sink="RemoteCodeExecution", run=1)
)
session.add(Issue(issue_id=1, source="UserControlled", sink="Logging", run=1))
session.add(Issue(issue_id=2, source="UserControlled", sink="SqlInjection", run=1))
session.add(Issue(issue_id=3, source="Filesystem", sink="ReturnedToUser", run=0))
session.commit()
def create_issue_and_bounty(request):
languages = []
for lang in Issue.LANGUAGES:
languages.append(lang[0])
user = request.user
if request.method == 'GET':
url = request.GET.get('url')
if url:
helper = get_issue_helper(request, url)
issue_data = helper.get_issue(request, url)
if not "title" in issue_data:
messages.error(request, 'Please provide an valid issue url')
return redirect('/post')
form = IssueCreateForm(
initial={
'issueUrl': request.GET.get('url'),
'title': issue_data['title'],
'content': issue_data['content'] or "Added from Github"
})
else:
form = IssueCreateForm()
return render(request, 'post.html', {
'languages': languages,
'form': form,
})
if request.method == 'POST':
url = request.POST.get('issueUrl', '')
if not url:
messages.error(request, 'Please provide an issue url')
return render(request, 'post.html', {'languages': languages})
try:
helper = get_issue_helper(request, url)
issue_data = helper.get_issue(request, url)
if issue_data and "service" in issue_data:
service = Service.objects.get(name=issue_data['service'])
instance = Issue(number=issue_data['number'],
project=issue_data['project'],
user=issue_data['user'],
service=service)
except:
return render(
request, 'post.html', {
'languages':
languages,
'message':
'Please provide a propper issue url like \
- https://github.com/CoderBounty/coderbounty/issues/83',
})
try:
form = IssueCreateForm(request.POST, instance=instance)
except:
helper = get_issue_helper(request, url)
issue_data = helper.get_issue(request, url)
if issue_data and "service" in issue_data:
service = Service.objects.get(name=issue_data['service'])
instance = Issue(number=issue_data['number'],
project=issue_data['project'],
user=issue_data['user'],
service=service)
bounty_form = BountyCreateForm(request.POST)
bounty_form_is_valid = bounty_form.is_valid()
if form.is_valid() and bounty_form_is_valid:
price = bounty_form.cleaned_data['price']
if int(price) < 5:
return render(
request, 'post.html', {
'languages': languages,
'message': 'Bounty must be greater than $5',
})
try:
issue = form.save()
except:
issue = Issue.objects.get(number=issue_data['number'],
project=issue_data['project'],
user=issue_data['user'],
service=service)
bounty_instance = Bounty(user=user, issue=issue, price=price)
if int(request.user.userprofile.balance or 0) >= int(
request.POST.get('grand_total')):
profile = request.user.userprofile
profile.balance = int(request.user.userprofile.balance) - int(
request.POST.get('grand_total'))
profile.save()
bounty_instance.save()
if not settings.DEBUG:
create_comment(issue)
return redirect(issue.get_absolute_url())
else:
data = serializers.serialize('json', [
bounty_instance,
])
# https://devtools-paypal.com/guide/pay_paypal/python?env=sandbox
import paypalrestsdk
paypalrestsdk.configure({
'mode': settings.MODE,
'client_id': settings.CLIENT_ID,
'client_secret': settings.CLIENT_SECRET
})
payment = paypalrestsdk.Payment({
"intent":
"sale",
"payer": {
"payment_method": "paypal"
},
"redirect_urls": {
"return_url":
request.build_absolute_uri(issue.get_absolute_url()),
"cancel_url":
"https://coderbounty.com/post"
},
"transactions": [{
"amount": {
"total": request.POST.get('grand_total'),
"currency": "USD"
},
"description":
"Coderbounty #" + str(issue.id),
"custom":
data
}]
})
if payment.create():
for link in payment.links:
if link.method == "REDIRECT":
redirect_url = link.href
return redirect(redirect_url)
else:
messages.error(request, payment.error)
return render(request, 'post.html',
{'languages': languages})
# wepay = WePay(settings.WEPAY_IN_PRODUCTION, settings.WEPAY_ACCESS_TOKEN)
# wepay_data = wepay.call('/checkout/create', {
# 'account_id': settings.WEPAY_ACCOUNT_ID,
# 'amount': request.POST.get('grand_total'),
# 'short_description': 'CoderBounty',
# 'long_description': data,
# 'type': 'service',
# 'redirect_uri': request.build_absolute_uri(issue.get_absolute_url()),
# 'currency': 'USD'
# })
# if "error_code" in wepay_data:
# messages.error(request, wepay_data['error_description'])
# return render(request, 'post.html', {
# 'languages': languages
# })
#
else:
return render(
request, 'post.html', {
'languages': languages,
'message': form.errors,
'errors': form.errors,
'form': form,
'bounty_errors': bounty_form.errors,
})
