def AddTasks(request):
page_data = {"AddTask_form": AddTask}
if request.method == 'POST':
AddTask_form = AddTask(request.POST)
if (AddTask_form.is_valid()):
desc = AddTask_form.cleaned_data["Description"]
chois = AddTask_form.cleaned_data["Category"]
task = Tasks()
task.username = request.user
task.description = desc
task.completed = False
sel_category = TaskCategory.objects.filter(id=str(int(chois) +
10)).get()
task.category = sel_category
task.save()
status_object = HiddenStatus.objects.get(id=4)
if status_object.status:
page_data = fillpagedata(request.user, True)
enable = True
else:
page_data = fillpagedata(request.user, False)
enable = False
return render(request, 'tasks/tasks.html', {
"dat": page_data,
"enabled": enable
})
return render(request, 'tasks/AddTasks.html', context=page_data)
def test_update_quality_game_with_new_violation(self):
"""Test update quality game with new violation"""
project = factories.ProjectFactory()
Tasks.save({
'project': project.name,
'success_percent': 10,
'status': STATUS_SUCCESS,
'created': datetime.now() - timedelta(hours=5),
'commit': {
'branch': 'test',
'author': 'test',
'inner': [{'author': {'url': 'test'}}]
},
'violations': [],
})
project.update_quality_game({
'project': project.name,
'success_percent': 15,
'status': STATUS_SUCCESS,
'created': datetime.now(),
'commit': {
'branch': 'test',
'author': 'test',
'inner': [{'author': {'url': 'test'}}]
},
'violations': [
{'name': 'cat', 'success_percent': 15},
],
})
project.quality_game['violations']['cat']['test']['value']\
.should.be.equal(1)
def test_task_creation(self):
task = Tasks(**TASK)
task.priority = self.priority
task.user = self.user
task.save()
self.assertEqual(task.name, 'ver el partido')
def test_get_neutral_trend(self):
"""Test get neutral trend"""
project = factories.ProjectFactory()
Tasks.save({
'project': project.name,
'commit': {'branch': 'branch'},
'success_percent': 0,
})
project.get_trend().should.be.equal(0)
def test_get_success_percents(self):
"""Test get success percents"""
project = factories.ProjectFactory()
Tasks.save({
'project': project.name,
'commit': {'branch': 'branch'},
'success_percent': 92,
})
project.get_success_percents(10).should.be.equal([92])
def test_get_badge_with_filtering(self):
"""Test get badge with filtering"""
project = factories.ProjectFactory.create()
Tasks.save({
'status': const.STATUS_SUCCESS,
'project': project.name,
'commit': {'branch': 'test'}
})
self._get_and_assert(project.name, 'success', '?branch=test')
def test_get_neutral_trend(self):
"""Test get neutral trend"""
project = factories.ProjectFactory()
Tasks.save({
'project': project.name,
'commit': {
'branch': 'branch'
},
'success_percent': 0,
})
project.get_trend().should.be.equal(0)
def test_get_success_percents(self):
"""Test get success percents"""
project = factories.ProjectFactory()
Tasks.save({
'project': project.name,
'commit': {
'branch': 'branch'
},
'success_percent': 92,
})
project.get_success_percents(10).should.be.equal([92])
def create_task(request):
user = request.user
response = Response(data={'status': 'error'}, status=status.HTTP_200_OK)
request_data = json.loads(request.body)
if request_data.get('title') and request_data.get('description'):
task = Tasks(title=request_data.get('title'),
description=request_data.get('description'),
owner=user)
task.save()
response.data = {'status': 'success'}
return response
def test_get_badge_with_filtering(self):
"""Test get badge with filtering"""
project = factories.ProjectFactory.create()
Tasks.save({
'status': const.STATUS_SUCCESS,
'project': project.name,
'commit': {
'branch': 'test'
}
})
self._get_and_assert(project.name, 'success', '?branch=test')
def test_update_quality_game_with_violations(self):
"""Test update quality game with violations"""
project = factories.ProjectFactory()
Tasks.save({
'project': project.name,
'success_percent': 10,
'status': STATUS_SUCCESS,
'created': datetime.now() - timedelta(hours=5),
'commit': {
'branch': 'test',
'author': 'test',
'inner': [{
'author': {
'url': 'test'
}
}]
},
'violations': [
{
'name': 'cat',
'success_percent': 10
},
],
})
project.update_quality_game({
'project':
project.name,
'success_percent':
15,
'status':
STATUS_SUCCESS,
'created':
datetime.now(),
'commit': {
'branch': 'test',
'author': 'test',
'inner': [{
'author': {
'url': 'test'
}
}]
},
'violations': [
{
'name': 'cat',
'success_percent': 15
},
],
})
project.quality_game['violations']['cat']['test']['value']\
.should.be.equal(1)
def topJobs():
images = ("/mowing.jpg", "/grocery.jpg", "/cleaning.jpg", "/shoveling.jpg",
"/moving.jpg", "/plumbing.jpg")
tasks = ('Mow Lawn', 'Groceries', 'Clean House', 'Snow Shoveling',
'Moving', 'Plumbing')
links = ('mowing/', 'grocery/', 'cleaning/', 'shoveling/', 'moving/',
'plumbing/')
p = zip(tasks, images, links)
for t in p:
q = Tasks(Task=t[0], Photo=t[1], Link=t[2])
q.save()
def travis_ci_service(data):
"""Create tasks from data received from travis-c
:param data: Data received from service
:type data: dict
:returns: bson.ObjectId or None -- pk of created task
"""
try:
assert Tasks.find({
'service.name': 'travis_ci',
'service.job_id': data['service']['job_id'],
}).count() <= 1
job = requests.get(
'https://api.travis-ci.org/jobs/{}'.format(
data['service']['job_id'], ), ).json()
repo = requests.get(
'https://api.travis-ci.org/repos/{}'.format(
job['repository_id'], ), ).json()
# TODO: add pull request support
assert data['project'] == repo['slug']
if data['service'].get('pull_request_id'):
pull_request = data['service']['pull_request_id']
if pull_request != 'false':
data['pull_request_id'] = int(
data['service']['pull_request_id'], )
return Tasks.save(data)
except Exception as e:
# remove task on error
Tasks.remove(data['_id'])
logger.exception('Travis-ci service fail: {}'.format(e))
def _create_task(self, **kwargs):
defaults = {
'project': self.project.name,
'status': STATUS_SUCCESS,
}
defaults.update(kwargs)
return Tasks.save(defaults)
def test_get_last_task(self):
"""Test get last task"""
project = factories.ProjectFactory()
task_id = Tasks.save({
'project': project.name,
'commit': {'branch': 'branch'},
})
project.get_last_task()['_id'].should.be.equal(task_id)
def dummy_service(data):
"""Create task from data dict
:param data: Data received from service
:type data: dict
:returns: bson.ObjectId -- pk of created task
"""
task_id = Tasks.save(data)
return task_id
def create_task(request):
response = json.loads(request.body)
title = response['title']
description = response['description']
task_date = response['date']
token = response['token']
print(token)
user_id = jwt.decode(token, 'secret', algorithm='HS256')['user_id']
u = User.objects.get(id=user_id)
t = Tasks(title=title,
description=description,
task_date=task_date,
owner=u)
t.save()
newTask = Tasks.objects.filter(id=t.id)
serialized_queryset = serializers.serialize('python', newTask)
return JsonResponse(serialized_queryset, safe=False)
def test_attach_last_task(self):
"""Test attach last task"""
project = factories.ProjectFactory(owner=self.user)
task_id = Tasks.save({
'project': project.name,
})
response = self.api_client.get(
'{}{}/?with_last_task=true'.format(self.url, project.name), )
self.deserialize(response)['last_task']['_id'].should.be\
.equal(str(task_id))
def _create_task(self):
"""Create task"""
task_id = Tasks.save({
'project': 'test',
'service': {
'name': 'travis_ci',
'job_id': 15,
}
})
return Tasks.find_one(task_id)
def _create_task(self):
"""Create task"""
task_id = Tasks.save({
'project': 'test',
'service': {
'name': 'travis_ci',
'job_id': 15,
}
})
return Tasks.find_one(task_id)
def test_get_last_task(self):
"""Test get last task"""
project = factories.ProjectFactory()
task_id = Tasks.save({
'project': project.name,
'commit': {
'branch': 'branch'
},
})
project.get_last_task()['_id'].should.be.equal(task_id)
def test_attach_last_task(self):
"""Test attach last task"""
project = factories.ProjectFactory(owner=self.user)
task_id = Tasks.save({
'project': project.name,
})
response = self.api_client.get(
'{}{}/?with_last_task=true'.format(self.url, project.name),
)
self.deserialize(response)['last_task']['_id'].should.be\
.equal(str(task_id))
def test_success(self):
"""Test success"""
task_id = Tasks.save({
'project': 'test',
'service': {
'name': 'token',
'token': self.project.token,
}
})
data = Tasks.find_one(task_id)
task_id.should.be.equal(token_service(data))
def create_task(request):
json_value = {}
module_code = "04"
module_status = ""
if request.method == 'POST':
if request.user.is_authenticated():
if all(key in request.POST for key in ('name', 'description', 'priority', 'state', 'due_date')):
name = request.POST['name']
description = request.POST['description']
priority = request.POST['priority']
state = request.POST['state']
due_date = request.POST['due_date']
if priority and state and name and description and due_date:
if 1 <= int(priority) <= 5 and 1 <= int(state) <= 3:
task_object = Tasks()
task_object.name = name
task_object.description = description
task_object.priority = priority
task_object.state = state
task_object.due_date = due_date
task_object.user = request.user
try:
task_object.save()
module_status = "01" # success
except ValidationError:
module_status = "00" # post data; date field format not correct yyyy-mm-dd
else:
module_status = "00" # post data error
else:
module_status = "00" # post data error
else:
module_status = "00" # post data error
else:
module_status = "02" # user not logged in
else:
module_status = "00" # method not post
json_value['status_code'] = module_code + module_status
return_value = json.dumps(json_value)
return HttpResponse(return_value)
def test_fail_with_wrong_project(self):
"""Test fail with wrong project"""
task_id = Tasks.save({
'project': 'test',
'service': {
'name': 'token',
'token': ProjectFactory().token,
}
})
data = Tasks.find_one(task_id)
with LogCapture() as log_capture:
token_service(data).should.be.none
list(log_capture.actual())[0].should.contain('ERROR')
Tasks.find({}).count().should.be.equal(0)
def token_service(data):
"""Find project by token and create task
:param data: Data received from service
:type data: dict
:returns: bson.ObjectId or None -- pk of created task
"""
try:
project = Project.objects.get(token=data['service']['token'])
assert data['project'] == project.name
return Tasks.save(data)
except Exception as e:
# remove task on error
Tasks.remove(data['_id'])
logger.exception('Token service fail: {}'.format(e))
def travis_ci_service(data):
"""Create tasks from data received from travis-c
:param data: Data received from service
:type data: dict
:returns: bson.ObjectId or None -- pk of created task
"""
try:
assert Tasks.find({
'service.name': 'travis_ci',
'service.job_id': data['service']['job_id'],
}).count() <= 1
job = requests.get(
'https://api.travis-ci.org/jobs/{}'.format(
data['service']['job_id'],
),
).json()
repo = requests.get(
'https://api.travis-ci.org/repos/{}'.format(
job['repository_id'],
),
).json()
# TODO: add pull request support
assert data['project'] == repo['slug']
if data['service'].get('pull_request_id'):
pull_request = data['service']['pull_request_id']
if pull_request != 'false':
data['pull_request_id'] = int(
data['service']['pull_request_id'],
)
return Tasks.save(data)
except Exception as e:
# remove task on error
Tasks.remove(data['_id'])
logger.exception('Travis-ci service fail: {}'.format(e))
def coviolations_service(data):
"""Find project by token and create task
:param data: Data received from service
:type data: dict
:returns: bson.ObjectId or None -- pk of created task
"""
try:
project = Project.objects.get(token=data['service']['token'])
node_task = NodeTask.objects.get(
id=data['service']['task_id'],
project=project,
)
data['commit']['branch'] = node_task.branch
assert data['project'] == project.name
return Tasks.save(data)
except Exception as e:
# remove task on error
Tasks.remove(data['_id'])
logger.exception('Token service fail: {}'.format(e))
def create(request):
if request.method == 'POST':
form = CreateForm(request.POST)
if form.is_valid() :
startYear = form.cleaned_data['startYear']
startMonth = form.cleaned_data['startMonth']
startDay = form.cleaned_data['startDay']
startHour = form.cleaned_data['startHour']
startMinute = form.cleaned_data['startMinute']
toursNumber = form.cleaned_data['toursNumber']
lenWriteWords = form.cleaned_data['lenWriteWords']
lenWatchResult = form.cleaned_data['lenWatchResult']
lenChecking = form.cleaned_data['lenChecking']
lenWaitWords = form.cleaned_data['lenWaitWords']
lenCountStatisticsWords = 10
lenCountResult = 10
lenGame = lenWriteWords + lenWaitWords + lenCountStatisticsWords + lenChecking + lenCountResult + lenWatchResult
info = form.cleaned_data['info']
start = datetime.datetime(startYear, startMonth, startDay, startHour, startMinute)
newGame = DataGame(start = start, toursNumber = toursNumber, lenWriteWords = lenWriteWords, lenWatchResult = lenWatchResult, lenChecking = lenChecking, lenWaitWords = lenWaitWords)
newGame.save()
delta = datetime.timedelta(minutes=info)
action = Tasks(taskTime = start - delta, action = "info", gameID = newGame, tourID = -1)
action.save()
listToChain = []
for i in range(toursNumber):
delta = datetime.timedelta(seconds = i*(lenGame))
countdownTime = start + delta - datetime.datetime.today() - datetime.timedelta(seconds = 1)
task_choice_titles.apply_async((Tasks(gameID = newGame, tourID = i),), countdown = countdownTime.seconds)
#listToChain.append(task_choice_titles.subtask((Tasks(gameID = newGame, tourID = i),), countdown = countdownTime.seconds))
action = Tasks(taskTime = start + delta, action = "tour", gameID = newGame, tourID = i)
action.save()
delta = datetime.timedelta(seconds = i*(lenGame) + lenWriteWords)
action = Tasks(taskTime = start + delta, action = "sendWords", gameID = newGame, tourID = i)
action.save()
delta = datetime.timedelta(seconds = i*(lenGame) + lenWriteWords + lenWaitWords)
countdownTime = start + delta - datetime.datetime.today()
task_count_statistics_words.apply_async((Tasks(gameID = newGame, tourID = i),), countdown = countdownTime.seconds)
action = Tasks(taskTime = start + delta, action = "countStatisticsWords", gameID = newGame, tourID = i)
action.save()
delta = datetime.timedelta(seconds = i*(lenGame) + lenWriteWords + lenWaitWords + lenCountStatisticsWords)
action = Tasks(taskTime = start + delta, action = "check", gameID = newGame, tourID = i)
action.save()
delta = datetime.timedelta(seconds = i*(lenGame) + lenWriteWords + lenWaitWords + lenCountStatisticsWords + lenChecking)
countdownTime = start + delta - datetime.datetime.today()
task_count_result.apply_async((Tasks(gameID = newGame, tourID = i),), countdown = countdownTime.seconds)
action = Tasks(taskTime = start + delta, action = "countResult", gameID = newGame, tourID = i)
action.save()
delta = datetime.timedelta(seconds = i*(lenGame) + lenWriteWords + lenWaitWords + lenCountStatisticsWords +lenChecking + lenCountResult)
action = Tasks(taskTime = start + delta, action = "watchResult", gameID = newGame, tourID = i)
action.save()
delta = datetime.timedelta(seconds = toursNumber*(lenGame))
countdownTime = start + delta - datetime.datetime.today() - datetime.timedelta(seconds = 1)
task_count_final_result.apply_async((Tasks(gameID = newGame, tourID = toursNumber),), countdown = countdownTime.seconds)
action = Tasks(taskTime = start + delta, action = "endGame", gameID = newGame, tourID = toursNumber)
action.save()
return render_to_response('ok_create.html', locals(), context_instance=RequestContext(request))
error = u"Не удалось создать игру. Произошла ошибка."
return render_to_response('error.html', locals(), context_instance=RequestContext(request))
