def generate_task(self, sp_id, name):
subprocess = SubProcess.objects.get(id=sp_id)
task = Task(subprocess=subprocess, name=name)
task.save()
return task
def run(self):
prev_time = int(time.time())
cnt = 0
_pid = os.getpid()
while 1:
_task_json = self._task_client.get(self._redis_key_in, block=False)
if _task_json is None:
continue
_task = Task(**_task_json)
_uid = _task.get_id()
_script = _task.get_script()
_script_args = _task.get_script_args()
_ignore_result = _task.is_ignore_result()
_task_args = _task.get_task_args()
_dispatcher = Dispatcher.get(_script)
_result = None
if _dispatcher is None:
continue
try:
_task.set_status(Task.STATUS_RUNNING)
self._execing_client.set(_uid, TaskMapper(_task).as_dict(), self._redis_key_execing)
_result = _dispatcher(**_script_args)
if _ignore_result:
continue
_task.set_result(_result)
self._result_client.set(_uid, TaskMapper(_task).as_dict(), self._redis_key_out)
except BaseException, e:
print e
self._task_client.put(TaskMapper(_task).as_dict(), self._redis_key_in)
finally:
def task_process():
query = Task.gql("WHERE expire = :1 ORDER BY created_at", None)
task_ref = None
task_more = None
for fake_task_ref in query.fetch(1):
task_ref = task_get(fake_task_ref.action, fake_task_ref.action_id)
if not task_ref:
raise exceptions.ApiNoTasks
method_ref = PublicApi.get_method(task_ref.action)
rv = method_ref(*task_ref.args, **task_ref.kw)
task_remove(task_ref.action, task_ref.action_id)
query = Task.gql("WHERE expire < :1", datetime.utcnow())
t_ref = query.fetch(1)
if t_ref:
task_more = True
return task_more
def p_task_def(p):
'''task_def : TASK id IMPLEMENTS id LPAREN impl_params RPAREN
| TASK id task_contents
'''
if p[3] != 'implements':
task = Task(p[2], script_accumulator[:])
task.requirements = requirement_accumulator[:]
task.roles = role_accumulator[:]
if len(description_accumulator) == 1:
task.description = description_accumulator[0]
del(description_accumulator[:])
del(script_accumulator[:])
del(role_accumulator[:])
del(requirement_accumulator[:])
else:
# get the task template from p[4]
template = TaskTemplate.lookup.get(p[4])
param_names = template.template_parameters
implementation_params_accumulator.reverse()
key = 0
for param in param_names:
template.set_parameter(param, implementation_params_accumulator[key])
key += 1
template.render_task(p[2])
del(implementation_params_accumulator[:])
def create_new_task(self, project_id):
Task.create_task(
name=self.task_name_input.get(), external_task_id=self.external_task_id_input.get(), project_id=project_id
)
self.update_tasks_list(project_id)
self.popup.destroy()
self.refresh_project_screen(project_id)
def task_add_to_milestone(request, milestone_id=None, response_format='html'):
"""Task add to preselected project"""
milestone = None
if milestone_id:
milestone = get_object_or_404(Milestone, pk=milestone_id)
if not request.user.profile.has_permission(milestone, mode='x'):
milestone = None
project = milestone.project
project_id = milestone.project.id
if request.POST:
if 'cancel' not in request.POST:
task = Task()
form = TaskForm(request.user.profile, None,
project_id, milestone_id, request.POST, instance=task)
if form.is_valid():
task = form.save()
task.set_user_from_request(request)
return HttpResponseRedirect(reverse('projects_task_view', args=[task.id]))
else:
return HttpResponseRedirect(reverse('projects_milestone_view', args=[milestone.id]))
else:
form = TaskForm(
request.user.profile, None, project_id, milestone_id)
context = _get_default_context(request)
context.update({'form': form,
'project': project,
'milestone': milestone})
return render_to_response('projects/task_add_to_milestone', context,
context_instance=RequestContext(request), response_format=response_format)
def post(self):
try:
naloga = self.request.get('naloga')
prioriteta = self.request.get('prioriteta')
opis = self.request.get('opis')
datum = self.request.get('termin')
izvajalec = self.request.get('izvajalec')
# preveri obliko zapisa datuma ce je prazen doda trenutni datum in cas
if datum == "":
danes = datetime.datetime.now()
termin_d = datetime.datetime.strftime(danes,'%d.%m.%Y %H:%M:%S')
termin = datetime.datetime.strptime(termin_d, '%d.%m.%Y %H:%M:%S')
else:
termin = datetime.datetime.strptime(datum,'%d.%m.%Y %H:%M:%S')
# kreiranje objekta opravilo in shranjevanje v bazo
opravilo = Task(naloga=naloga, prioriteta=prioriteta, opis=opis, termin=termin, izvajalec=izvajalec)
opravilo.put()
# VSE OK vrne na seznam opravil
return self.redirect_to('osnovna-stran')
# V primerru napake javi opozoirilo in uporabnik mora napako odpraviti
except ValueError:
err = "Datum in ura obezno v formatu d.m.YYYY H:M:S Lahko pa je prazno"
params = {'err': err}
return self.render_template('vnos_opravila.html', params=params)
def toggleComplete(self, *args):
user = users.get_current_user()
task = db.GqlQuery('SELECT * FROM Task WHERE ANCESTOR IS :1',db.Key(args[0])).get()
if task and task.who == user:
if task.complete:
task.complete = False
else:
task.complete = True
task.complete_date = datetime.datetime.today()
task.put()
if task.complete == True and task.repeat == True:
# verify that we haven't repeated this already
repeatTask = db.GqlQuery('SELECT * FROM Task WHERE who = :1 AND name = :2 AND complete = False', task.who, task.name)
if hasattr(repeatTask, "name") == False:
repeatTask = Task(name=task.name,
who=task.who,
tags=task.tags,
nudge=task.nudge,
nudge_value=task.nudge_value,
repeat=task.repeat,
last_nudge=task.last_nudge,
last_complete=datetime.datetime.today())
repeatTask.put()
return True
else:
return False
def addTask(request):
"""Add a task"""
d = {}
pagename = request.POST["pagename"]
page = TaskPage.objects.get(name__iexact=pagename)
if "taskid" not in request.POST.keys():
t = Task()
t.text = request.POST["taskcontent"]
t.page = page
t.save()
d["message"] = "Successfully added the task"
d["text"] = t.text
d["taskid"] = t.id
d["update"] = 0
else:
taskid = int(request.POST["taskid"])
giventask = Task.objects.get(pk=taskid)
giventask.text = request.POST["taskcontent"]
giventask.save()
d["message"] = "Successfully updated the task"
d["text"] = urlize(giventask.text)
d["taskid"] = giventask.id
d["update"] = 1
# return all the tasks
d["error"] = "0"
json = simplejson.dumps(d)
return HttpResponse(json)
def test_object_deletion(self):
"""
Test that tasks are created and deleted correctly by being given an object and a list
"""
# test objects
normal_object = self.test_object
deletable_object = test_object = Site(name='foo', domain='foo.com')
deletable_object.save()
# check that there are none at the start
self.assertEqual( Task.objects.count(), 0 )
# create a couple of tasks
for obj in [ normal_object, deletable_object ]:
Task.update_for_object( obj, ['foo'] )
# check that a task exists
self.assertEqual( Task.objects.count(), 2 )
self.assertEqual( Task.objects_for(deletable_object).count(), 1 )
test_object.delete()
# check that a task exists
self.assertEqual( Task.objects.count(), 1 )
self.assertEqual( Task.objects_for(deletable_object).count(), 0 )
def task_add_subtask(request, task_id=None, response_format='html'):
"""New subtask form"""
parent = None
if task_id:
parent = get_object_or_404(Task, pk=task_id)
if not request.user.profile.has_permission(parent, mode='x'):
parent = None
if request.POST:
if 'cancel' not in request.POST:
task = Task()
form = TaskForm(
request.user.profile, parent, None, None, request.POST, instance=task)
if form.is_valid():
task = form.save()
task.set_user_from_request(request)
return HttpResponseRedirect(reverse('projects_task_view', args=[parent.id]))
else:
return HttpResponseRedirect(reverse('projects_task_view', args=[parent.id]))
else:
form = TaskForm(request.user.profile, parent, None, None)
context = _get_default_context(request)
context.update({'form': form,
'task': parent})
return render_to_response('projects/task_add_subtask', context,
context_instance=RequestContext(request), response_format=response_format)
def tasks(request):
# tasks supports GET and POST
if request.method == "GET":
# GET should return all of the tasks
# first, create a list of tasks
raw_tasks = []
for task in Task.objects.all():
raw_tasks.append(task_to_raw(task))
# now, create and return json (remember, front-end wants it in "contents")
return_data = {"content": raw_tasks}
return HttpResponse(json.dumps(return_data), mimetype="application/json")
elif request.method == "POST":
# Create a Task
task = Task()
# Load data
raw = json.loads(request.raw_post_data)
raw_to_task(raw, task)
# attempt to save
task.save()
# return just the plain hash
# returning Location header causes problems
response = HttpResponse(json.dumps({"content": task_to_raw(task)}))
response.status = 201
return response
def test_add_articles():
author_id = 'chenqin'
author_id = 'du-ke'
author_id = 'flood-sung'
author_id = 'hmonkey'
Task.add_articles(author_id=author_id, limit=3000, min_voteup=1,
stop_at_existed=300)
def process(request):
current_epoch = datetime.now().strftime('%s')
request.session['response'] = {'code':integers.CODE_SUCCESS,
'message':strings.MESSAGE_SUCCESS, 'created':current_epoch}
if request.method != 'POST':
request.session['response'] = {'code':integers.CODE_INVALID_REQUEST_METHOD,
'message':strings.MESSAGE_INVALID_REQUEST_METHOD, 'created':current_epoch}
return HttpResponseRedirect('/')
try:
company_name = request.POST['company']
task_description = request.POST['task']
print task_description
company = Company.objects.filter(name=company_name)
if not company.exists():
request.session['response'] = {'code':integers.CODE_INVALID_COMPANY_NAME,
'message':strings.MESSAGE_INVALID_COMPANY_NAME, 'created':current_epoch}
return HttpResponseRedirect('/')
new_task = Task(description=task_description, company_id=company['id'])
new_task_id = new_task.save()
print new_task_id
if not new_task_id:
request.session['response'] = {'code':integers.CODE_SAVE_ERROR_TASK,
'message':strings.MESSAGE_SAVE_ERROR_TASK, 'created':current_epoch}
return HttpResponseRedirect('/')
except Exception, e:
print 'Exception occured: ' + str(e)
def project(request, project_id):
project = get_object_or_404(Project, id=project_id)
if request.method == 'POST':
form = UploadFabFileForm(request.POST, request.FILES)
if form.is_valid():
fabfile = request.FILES['file']
content = fabfile.readlines()
import_block, tasks = get_source(content)
project.import_block = import_block
project.save()
stage = Stage(name="Imported", project=project)
stage.save()
stage_user = StageUser(user=request.user, stage=stage)
stage_user.save()
for task in tasks:
task_obj = Task(name=task['name'], body=task['body'])
task_obj.save()
stage_task = StageTask(task=task_obj, stage=stage)
stage_task.save()
else:
form = UploadFabFileForm()
stages = project.stage_set.order_by('name',)
deployments = Deploy.objects.filter(stage__in=stages).order_by('-finished_at',)[:3]
return {'p': project, 'stages': stages, 'deps': deployments, 'form': form}
def add_task(list_id):
'''Add task for the current user'''
ws = existing_web_session()
dbs = db_session(close=True)
form = forms.AddTask()
post = request.POST.decode()
if not dbs.query(Todo).filter(Todo.id==list_id).all():
return {
'message':'This is not the list you are looking for.',
'ws':ws
}
task_name = cgi.escape(post['task'])
task = Task(name=task_name,description='',todo_list_id=list_id, creator=ws['user_id'],reviewer=ws['user_id'])
dbs.add(task)
try:
dbs.commit()
except:
dbs.rollback()
return "-1"
#tasks = dbs.query(Task).filter(Task.user_created_id == ws['user_id']).all()
return json.dumps(task.get_details())
def addtask(request):
# email = request.POST.get('owner', '')
title = request.POST.get('title', '')
description = request.POST.get('description', '')
collaborator1 = request.POST.get('collaborator1', '')
collaborator2 = request.POST.get('collaborator2', '')
collaborator3 = request.POST.get('collaborator3', '')
uid = request.session['mid']
userobj = User.objects.get(id=uid)
# because collaborators is a multi entry field, you have to add collaborators after creating the new task
# I'm not sure why save goes above adding collaborators, but the code broke when the save was not above
new_Task = Task(owner=userobj, title=title, description=description)
new_Task.save()
if collaborator1 != '':
collaboratored = User.objects.filter(email = collaborator1)
coll = collaboratored[0]
new_Task.collaborators.add(coll)
if collaborator2 != '':
collaboratored = User.objects.filter(email = collaborator2)
coll = collaboratored[0]
new_Task.collaborators.add(coll)
if collaborator3 != '':
collaboratored = User.objects.filter(email = collaborator3)
coll = collaboratored[0]
new_Task.collaborators.add(coll)
# new_Task.save()
return HttpResponseRedirect ('/tasks/')
def make_task(content=None):
from sqlalchemy import func
size = len(Task.query.all())+1
access_token = session['access_token']
content = request.form['content']
if access_token:
me = fb_call('me', args={'access_token': access_token})
user_id = me['id']
task = Task(size,
datetime.datetime.today(),
str(me['id']),
request.form['title'],
content,
False)
assignees = parse_message_content(content)
for assignee_name in assignees:
task.add_assignee(fbuser_from_name(assignee_name))
# task.add_assignee(Fbuser.query.filter_by(
# facebook_id=str(me['id'])).first_or_404())
db.session.add(task)
db.session.commit()
return "Success"
raise Exception
def index(request):
if 'offset' in request.GET:
offset = int(request.GET['offset'])
else:
offset = 0
# use Users API to get current user
user = users.get_current_user()
# if a user is logged in, redirect to their workstack page
if not user:
greeting = ("<a href=\"%s\">Sign in or register</a>." %
users.create_login_url("/"))
return HttpResponse("<html><body><h1>Workstack</h1>%s</body></html>"%greeting)
logout_url = users.create_logout_url("/")
commands = Command.all().filter("user ="******"blocks =",account.task).filter("status =",db.Category("todo"))
slushtasks = Task.all().filter("proposer =", user).filter("blocks =", None).filter("status =",db.Category("todo"))
stack = []
tt = account.task
while tt is not None:
stack.append( tt )
tt = tt.blocks
for i, task in enumerate(reversed(stack)):
task.level = i
return render_to_response( "index.html", {'account':account, 'commands':commands, 'user':user, 'logout_url':logout_url,'todos':todos,'stack':stack,'offset':offset+50,'slushtasks':slushtasks} )
def new_task():
form = TaskForm(request.form)
if request.method == 'POST' and form.validate():
task = Task(form.name.data, form.text.data, form.memory.data, form.time_limit.data, g.user)
task.save()
return redirect(url_for('task', task_id=task.task_id))
return render_template('task_form.html', form=form)
def download_datasets(request):
ds = request.GET.get('dataset')
task_id = str(uuid.uuid4())
job = Task(task_id=task_id, task_type='download_dataset', data_input=ds)
job.save()
download.apply_async(args=(ds, job), task_id=task_id)
context = {'task_id': task_id, 'dataset': ds}
return render_to_response('main/datasets.html', context)
def test_task_should_be_fetchable(self):
"""
A Task should be fetchable via the ORM
"""
task = Task(description="Test")
task.save()
fetched_task = Task.objects.filter(description="Test")[0]
self.assertEqual(fetched_task.id, task.id)
def test_delete_should_delete_task(self):
"""
A DELETE request should result in the task being deleted.
"""
task = Task(description="run")
task.save()
response = Client().delete('/tasks/' + str(task.id))
self.assertFalse(Task.objects.all().exists())
def index():
form = TaskForm()
if form.validate_on_submit(): # if it is a POST request
task = Task(label = form.label.data)
task.save()
return redirect(url_for('index'))
tasks = Task.objects.all()
return render_template('index.html', form = form, tasks = tasks)
def test_description_should_not_allow_blank(self):
"""
Description field should raise exception when value is blank.
"""
task = Task()
# @todo how to validate one field?
with self.assertRaises(ValidationError):
task.full_clean()
def test_task_should_be_deletable(self):
"""
A Task should be deletable via the ORM
"""
task = Task(description="Workout")
task.save()
self.assertTrue(Task.objects.all().exists())
task.delete()
self.assertFalse(Task.objects.all().exists())
def post(self):
naslov = self.request.get("input-naslov")
besedilo = self.request.get("input-besedilo")
pomembnost = int(self.request.get("input-pomembnost"))
task = Task(naslov=naslov, besedilo=besedilo, pomembnost=pomembnost)
task.put()
return self.redirect_to("index")
def create_task():
if not request.json or not 'title' in request.json:
abort(400)
task = Task(title = request.json['title'],description=request.json.get('description', ""),done=False)
db.session.add(task)
db.session.commit()
return jsonify( task = task.to_json() ), 201
def setUp(self):
self.group, created = Group.objects.get_or_create(name='test')
self.user, created = DjangoUser.objects.get_or_create(username=self.username)
self.user.set_password(self.password)
self.user.save()
perspective, created = Perspective.objects.get_or_create(name='default')
perspective.set_default_user()
perspective.save()
ModuleSetting.set('default_perspective', perspective.id)
self.contact_type = ContactType(name='test')
self.contact_type.set_default_user()
self.contact_type.save()
self.contact = Contact(name='test', contact_type=self.contact_type)
self.contact.related_user = self.user.profile
self.contact.set_default_user()
self.contact.save()
self.project = Project(name='test', manager=self.contact, client=self.contact)
self.project.set_default_user()
self.project.save()
self.status = TaskStatus(name='test')
self.status.set_default_user()
self.status.save()
self.milestone = Milestone(name='test', project=self.project, status=self.status)
self.milestone.set_default_user()
self.milestone.save()
self.task = Task(name='test', project=self.project, status=self.status, caller=self.contact)
self.task.set_default_user()
self.task.save()
self.task_assigned = Task(name='test', project=self.project, status=self.status)
self.task_assigned.save()
self.task_assigned.assigned.add(self.user.profile)
self.time_slot = TaskTimeSlot(task=self.task, details='test', time_from=datetime.now(), user=self.user.profile)
self.time_slot.set_default_user()
self.time_slot.save()
self.parent = Project(name='test')
self.parent.set_default_user()
self.parent.save()
self.parent_task = Task(
name='test', project=self.project, status=self.status, priority=3)
self.parent_task.set_default_user()
self.parent_task.save()
self.client = Client()
self.client.login(username=self.username, password=self.password)
def new():
msg = "Capture una tarea: "
if request.method == 'POST':
tsk = Task(description = request.form['description'])
## tsk = Task(author = 'norbux')
tsk.put()
## flash('Tarea registrada')
return redirect(url_for('test'))
## return request.form['description']
return render_template('new.html', msg=msg)
def get(self, task_id):
task = Task.get_by_id(int(task_id))
params = {"task" : task}
return self.render_template("edit_task.html", params=params)
def test_list_creation_and_deletion(self):
"""
Test that tasks are created and deleted correctly by being given an object and a list
"""
initial_list = [
self.high_priority_category.slug,
self.medium_priority_category.slug
]
modified_list = [
self.high_priority_category.slug, self.low_priority_category.slug
]
# check that there are none at the start
self.assertEqual(Task.objects.count(), 0)
# create a couple of tasks
Task.update_for_object(self.test_object, initial_list)
self.assertItemsEqual(
[i.category.slug for i in Task.objects_for(self.test_object)],
initial_list,
)
# modify one of the tasks
for task in Task.objects_for(
self.test_object).filter(category__slug='task-code-1'):
task.note = "test notes"
task.save()
# run again - this time with a new task
Task.update_for_object(self.test_object, modified_list)
self.assertItemsEqual(
[i.category.slug for i in Task.objects_for(self.test_object)],
modified_list,
)
# check previously modified task unchanged
for task in Task.objects_for(
self.test_object).filter(category__slug='task-code-1'):
self.assertEqual(task.note, "test notes")
# run again - with empty list
Task.update_for_object(self.test_object, [])
self.assertItemsEqual(
[i.category.slug for i in Task.objects_for(self.test_object)],
[],
)
# check that all tasks are now deleted
self.assertEqual(Task.objects.count(), 0)
def create_todos(username):
request_data = request.get_json()
task = Task(request_data["label"], request_data["done"], username)
task.save_to_data()
return jsonify({"Message": "Task created"})
def _add_task(self, task_name):
task = Task.Create(self.user, task_name)
task.put()
return self._comply_banter() + ". Task added."
def get_all_tasks():
return [model_to_dict(task) for task in Task.select()]
def create_task():
task = Task(task=request.form['task'])
print(task)
db.session.add(task)
db.session.commit()
return "SUCCESS"
async def create_task(request):
logging.info("Create Task")
data = await request.json()
task_type = data.get('task_type', None)
task_args = data.get('task_args', [])
time_interval = data.get('time_interval', 'week')
time_multiplier = data.get('time_multiplier', 1)
# define job function
job_func = None
# setup for future task types
if task_type == "request":
job_func = send_request
# calculate time
weeks = 0
days = 0
hours = 0
minutes = 0
if time_interval == "month":
weeks = time_multiplier * 4
elif time_interval == "week":
weeks = time_multiplier
elif time_interval == "day":
days = time_multiplier
elif time_interval == "hour":
hours = time_multiplier
elif time_interval == "minute":
minutes = time_multiplier
r_type = data.get('response_type', 'async')
# create task
new_task = Task(description=data.get('description', None),
task_type=task_type,
task_args=task_args,
notification_type=data.get('notification_type', None),
notification_args=data.get('notification_args', None),
response_type=r_type,
response_args=data.get('response_args', None),
time_interval=time_interval,
time_multiplier=time_multiplier,
diff=data.get('diff', None),
status='active',
uuid=data.get('uuid', None))
new_task.save()
comb_task_args = [new_task.id] + task_args
comb_task_args = [r_type] + comb_task_args
# schedule job
scheduler_lock.acquire()
job = scheduler.add_job(func=job_func,
trigger='interval',
args=comb_task_args,
weeks=weeks,
days=days,
hours=hours,
minutes=minutes,
seconds=0,
coalesce=True)
scheduler_lock.release()
new_task.scheduler_id = job.id
new_task.save()
return web.json_response(new_task.to_json(),
dumps=str,
headers=response_headers)
def get(self, task_id):
task = Task.get_by_id(int(task_id))
task.key.delete()
return self.redirect_to("trash")
"id": 1,
"title": "delectus aut autem",
"completed": False
},
{
"userId": 1,
"id": 2,
"title": "quis ut nam facilis et officia quigre "
"fretgrebergregkrenginejignejgnrjegnjrengjrengjirengje",
"completed": False
},
{
"userId": 1,
"id": 3,
"title": "fugiat veniam minus",
"completed": False
},
{
"userId": 1,
"id": 4,
"title": "et porro tempora",
"completed": True
},
]
if __name__ == '__main__':
user = User.from_dict(USER_JSON)
tasks = [Task.from_dict(task_json) for task_json in TASKS_JSON]
print(format_report(user, tasks, datetime.now()))
def get(self):
taskList = Task.query(Task.deleted==False).fetch()
for item in taskList:
item.deleted = True
item.put()
return self.redirect_to("task_list")
def get(self):
taskListDeleted = Task.query(Task.deleted==True).order(Task.title).fetch()
for item in taskListDeleted:
item.key.delete()
return self.redirect_to("trash")
def get(self):
taskListDeleted = Task.query(Task.deleted==True).fetch()
for item in taskListDeleted:
item.deleted = False
item.put()
return self.redirect_to("trash")
def get(self, task_id):
task = Task.get_by_id(int(task_id))
task.deleted = True
task.put()
return self.redirect_to("list")
def get(self):
taskList = Task.query(Task.deleted==False).fetch()
params = {"taskList": taskList}
return self.render_template("task_list.html", params=params)
def _add_task(data, user, id=0):
logger.debug("Task name = %s", data[NAME])
if id:
# get existing task
task = Task.objects.get(pk=id)
if not task.editable:
raise IgniteException(ERR_TASK_NOT_EDITABLE)
else:
# create new task
task = Task()
task.name = data[NAME]
task.handler = data[HANDLER]
task.function = data[FUNCTION]
task.desc = data[DESCRIPTION]
task.location_access_protocol = data[LOC_ACCESS_PROTO]
task.location_server_ip = data[LOC_SERVER_IP]
task.location_server_user = data[LOC_SERVER_USER]
password = encrypt_data(data[LOC_SERVER_PASSWORD])
task.location_server_password = password
task.is_encrypted = True
task.parameters = data[PARAMETERS]
task.updated_by = user
task.save()
return task
# db_create.py
from views import db
from models import Task
from datetime import date
# create the database and the db table
db.create_all()
# insert data
db.session.add(Task("Finish this tutorial", date(2014, 3, 13), 10, 1))
db.session.add(Task("Finish Real Python", date(2014, 3, 13), 10, 1))
db.session.commit()
from views import db
from models import Task
from datetime import date
#creae the database and the db TABLE
db.create_all()
#insert database
db.session.add(Task("Finish this tutorial", date(2016, 9, 22), 10, 1))
db.session.add(Task("Finish Real Python", date(2016, 10, 3), 10, 1))
#commit the changes
db.session.commit()
def seed(db):
persons = [
Person(id=1, name="Joy Ann"),
Person(id=2, name="Michael John"),
Person(id=3, name="Laine Elizabeth"),
]
projects = [
Project(id=1, name="Online Store"),
Project(id=2, name="Christmas Presents"),
]
tasks = [
Task(id=1,
name="Inventory",
description="Upload inventory to database",
due_date=datetime.date(2020, 1, 1),
completed=False,
person_id=1,
project_id=1),
Task(id=2,
name="Web design",
description="Hire web designer",
due_date=datetime.date(2020, 1, 1),
completed=False,
person_id=1,
project_id=1),
Task(id=3,
name="Front end",
description="Build front end",
due_date=datetime.date(2020, 1, 1),
completed=False,
person_id=3,
project_id=1),
Task(id=4,
name="Back end",
description="Build back end",
due_date=datetime.date(2020, 1, 1),
completed=False,
person_id=3,
project_id=1),
Task(id=5,
name="Buy Joy laptop",
description="Macbook Pro 16 inch",
due_date=datetime.date(2020, 1, 1),
completed=False,
person_id=2,
project_id=2),
Task(id=6,
name="Buy Laine coal",
description="Home Depot",
due_date=datetime.date(2020, 1, 1),
completed=False,
person_id=2,
project_id=2),
]
db.session.add_all(persons)
db.session.add_all(tasks)
db.session.add_all(projects)
db.session.commit()
import datetime
from models import Board, List, Task
highest_order = Task.select().where(Task.belongs_to_list == 1).order_by(
Task.task_order.desc()).get()
new_task = Task(
belongs_to_list=List.select().where(List.name == "Important List"),
task_name="Learn Rails",
task_description=
"I am trying to learn rails so I can build complex apps in the future and also my own api someday.",
task_order=(highest_order.task_order + 1))
new_task.save()
def _journal(self, message=""):
DONE_MESSAGES = ["done", "that's all", "exit", "finished", "no"]
MODES = ['questions', 'tasks', 'end']
settings = tools.getJson(self.user.settings, {})
questions = settings.get('journals', {}).get('questions', [])
end_convo = False
if questions:
jrnl = MiniJournal.Get(self.user)
if jrnl:
return (JOURNAL.ALREADY_SUBMITTED_REPLY, True)
else:
if not self.cs:
self.cs = self._create_conversation_state()
self.cs.set_state('mode', 'questions')
mode = self.cs.state.get('mode')
mode_finished = False
save_response = True
last_question = None
# Receive user message
if mode == 'tasks':
is_done = message.lower().strip() in DONE_MESSAGES
mode_finished = is_done
save_response = not is_done
elif mode == 'questions':
last_q_index = self.cs.state.get('last_q_index', -1)
last_question = last_q_index == len(questions) - 1
mode_finished = last_question
save_response = True
if save_response:
successful_add = self.cs.add_message_from_user(message)
if not successful_add:
reply = self.cs.invalid_reply(
) if mode == 'questions' else JOURNAL.INVALID_TASK
return (reply, False)
mode_index = MODES.index(mode)
if mode_finished:
mode = MODES[mode_index + 1]
self.cs.set_state('mode', mode)
reply = None
# Generate next reply
if mode == 'questions':
next_q_index = last_q_index + 1
q = questions[next_q_index]
reply = q.get('text')
name = q.get('name')
response_type = q.get('response_type')
pattern = JOURNAL.PATTERNS.get(response_type)
store_number = response_type in JOURNAL.NUMERIC_RESPONSES
self.cs.expect_reply(
pattern, name,
store_number=store_number) # Store as name
self.cs.set_state('last_q_index', next_q_index)
elif mode == 'tasks':
# Ask to add tasks
tasks = self.cs.response_data.get('tasks', [])
additional = len(tasks) > 0
reply = JOURNAL.TOP_TASK_PROMPT_ADDTL if additional else JOURNAL.TOP_TASK_PROMPT
self.cs.expect_reply(JOURNAL.PTN_TEXT_RESPONSE,
'tasks',
store_array=True) # Store as name
elif mode == 'end':
# Finish and submit
task_names = []
if 'tasks' in self.cs.response_data:
task_names = self.cs.response_data.pop('tasks')
jrnl = MiniJournal.Create(self.user)
jrnl.Update(data=self.cs.response_data)
jrnl.parse_tags()
jrnl.put()
tasks = []
if task_names:
for tn in task_names:
task = Task.Create(self.user, tn)
tasks.append(task)
ndb.put_multi(tasks)
reply = "Report submitted!"
end_convo = True
if reply:
self.cs.set_message_to_user(reply)
if end_convo:
self._expire_conversation()
else:
self._set_conversation_state()
return (reply, end_convo)
else:
return ("Please visit flowdash.co to set up journal questions",
True)
from models import init, engine, Task, TaskLog
from sqlalchemy.orm import sessionmaker
# create a session {this will be used to storing objects onto DB}
Session = sessionmaker(bind=engine)
session = Session()
# initialize the model {this will create DB}
init()
# create an object and persist to DB via session
dummy_task = Task(id=1, title="Some Fancy Task", completed=True)
dummy_task.log = [TaskLog(logged_hours=2)]
session.add(dummy_task)
# add some more data
for i in range(2, 5):
task_title = "Some Fancy Task:%s" % i
dummy_task = Task(id=i, title=task_title, completed=False)
dummy_task.log = [TaskLog(logged_hours=i)]
session.add(dummy_task)
# note without this the persistance won't happen
session.commit()
# To query DB this is how its done
print "Pending Tasks:"
for task in session.query(Task).filter_by(completed=False):
print task
def handle_user_task(username):
headers = {"Content-Type": "application/json"}
#Chequeando si el usuario existe
requesting_user = User.query.filter_by(username=username).all()
if len(requesting_user) > 0:
username_id = requesting_user[0].id
else:
username_id = None
if request.method == 'GET':
print("Hello, GET!")
if username_id is not None:
# Existe el usuario, retornamos la lista de tareas...
print("Usuario Existe")
user_tasks_list = Task.query.filter_by(user_id=username_id).all()
response_body = []
for task in user_tasks_list:
response_body.append(task.serialize())
status_code = 200
else:
print("Usuario No Existe")
response_body = {"status": "HTTP_404_NOT_FOUND. Usuario no existe"}
status_code = 404
elif request.method == 'POST':
print("Creando Usuario con una tarea")
if username_id:
response_body = {
"status": "HTTP_400_BAD_REQUEST. Usuario ya existe..."
}
status_code = 400
elif request.data != []:
response_body = {
"status":
"HTTP_400_BAD_REQUEST. Datos inesperados para crear usuario"
}
status_code = 400
else:
# username not in use, create user with sample task...
print("Creando usuario con una tarea")
new_user = User()
new_user.username = username
db.session.add(new_user)
sample_task = Task("sample task", username_id)
db.session.add(sample_todo)
db.session.commit()
response_body = {"status": "Ok"}
status_code = 200
elif request.method == 'PUT':
# El usuario actualiza la lista completa de tareas, se chequea si existe primerp...
print(f"updating full list for {username}")
if username_id:
# Usuario existe, actualizamos toda la lista...
# Eliminando tareas existentes...
Task.query.filter_by(user_id=username_id).delete()
new_tasks = json.loads(request.data)
for task in new_tasks:
new_task = Task(task["label"], username_id)
db.session.add(new_task)
db.session.commit()
result = f"A list with {len(new_tasks)} todos was succesfully saved"
response_body = {
"result": result,
}
status_code = 200
else:
# Usuario no exite...
response_body = {
"status":
"HTTP_400_BAD_REQUEST. No se puede actualizar la lista de un usario inexistente..."
}
status_code = 400
elif request.method == "DELETE":
# Usuario quiere eliminar si registro y lista...
if username_id:
# Usuario existe, eliminando registros...
Task.query.filter_by(user_id=username_id).delete()
User.get_by_id(int(username_id)).delete()
db.session.commit()
response_body = {
"result": "ok",
"status": "HTTP_204_NO_CONTENT. Usuarios Y Tareas Eliminad@s."
}
status_code = 204
else:
# user does not exist, this is a no go...
response_body = {
"status":
"HTTP_400_BAD_REQUEST. Cannot delete a non existing user..."
}
status_code = 400
else:
response_body = "Metodo no esta listo todavia"
status_code = 501
return make_response(jsonify(response_body), status_code, headers)
def create_task(name):
return Task.create(name=name)
def task(request):
from models import Task
t = Task("url", url=request.param)
return t
def populate():
python = Subject('Python')
web = Subject('Web')
oop = Subject('OOP')
art = Subject('Art')
db.session.add(python)
db.session.add(web)
db.session.add(oop)
db.session.add(art)
km61 = Group('KM-61')
km62 = Group('KM-62')
km63 = Group('LA-73')
km62.subjects.append(web)
km62.subjects.append(oop)
km62.subjects.append(python)
km63.subjects.append(art)
db.session.add(km61)
db.session.add(km62)
db.session.add(km63)
richmound = Student('*****@*****.**', '123456',
'Richmound Tizard', 'KM-62', 1)
torrie = Student('*****@*****.**', '123456', 'Torrie Chinge', 'KM-62', 2)
becca = Student('*****@*****.**', '123456', 'Becca Parell', 'LA-73', 3)
db.session.add(richmound)
db.session.add(torrie)
db.session.add(becca)
python_intro = Lection('Introduction to python', 'Den Mitchel',
'Introduction to python blah blah blah', 'Python')
js_intro = Lection('Introduction to JS', 'Dan Abramov',
'Introduction to JS blah blah blah', 'Web')
js_object = Lection('Objects in JS', 'Dan Abramov',
'Objects in JS blah blah blah', 'Web')
db.session.add(python_intro)
db.session.add(js_intro)
db.session.add(js_object)
python_beginner = Label('Python language for beginners', 0)
js_beginner = Label('JS for beginners', 1)
js_intermediate = Label('JS for intermediate', 2)
db.session.add(python_beginner)
db.session.add(js_beginner)
db.session.add(js_intermediate)
python_docs = Resource('Official doc for python', 'lalala',
'https://docs.python.org/3/', 0,
'Introduction to python',
'*****@*****.**')
js_docs = Resource('Official doc for JS', 'lalala JS',
'https://developer.mozilla.org/ru/docs/Web/JavaScript',
0, 'Introduction to JS', '*****@*****.**')
abramov_blog = Resource('Dan`s Abramov blog', 'lalala blog',
'https://overreacted.io/', 0, 'Objects in JS',
'*****@*****.**')
db.session.add(python_docs)
db.session.add(js_docs)
db.session.add(abramov_blog)
js_lab_1 = Laboratory('Arithmetical operations in JS', 1, 'Manual is here',
'Web')
js_lab_2 = Laboratory('Conditions in JS', 2, 'Manual is here', 'Web')
js_lab_3 = Laboratory('Loops in JS', 3, 'Manual is here', 'Web')
db.session.add(js_lab_1)
db.session.add(js_lab_2)
db.session.add(js_lab_3)
js_lab_1_v1 = Task(1, 'Arithmetical operations in JS',
'Please, add two numbers')
js_lab_1_v2 = Task(2, 'Arithmetical operations in JS',
'Please, multiple two numbers')
js_lab_1_v3 = Task(3, 'Arithmetical operations in JS',
'Please, divide two numbers')
db.session.add(js_lab_1_v1)
db.session.add(js_lab_1_v2)
db.session.add(js_lab_1_v3)
richmound_attempt_1 = Implementation(1, '*****@*****.**',
'Arithmetical operations in JS',
'Tests passed', 'code',
'Data validation failed!',
'IFFOIIFOFDFIO', 20)
richmound_attempt_2 = Implementation(2, '*****@*****.**',
'Arithmetical operations in JS',
'Tests passed', 'code',
'Stack overflow!', 'IFFOIIFFFIO', 36)
richmound_attempt_3 = Implementation(3, '*****@*****.**',
'Arithmetical operations in JS',
'Tests passed', 'code', 'Success!',
'IOIIIIIFOFDFIO', 15)
db.session.add(richmound_attempt_1)
db.session.add(richmound_attempt_2)
db.session.add(richmound_attempt_3)
first_lab_test_1 = Test('Check functionality', 1,
'Arithmetical operations in JS', '{a: 2, b: 2}',
'{return: 4}', 'Arithmetical error!')
first_lab_test_2 = Test('Check validation', 1,
'Arithmetical operations in JS', '{a: "c", b: 2}',
'{return: "Not a number"}',
'Data validation failed!')
first_lab_test_3 = Test('Check small numbers', 1,
'Arithmetical operations in JS',
'{a: 0.333333333, b: 0.2222222222}',
'{return: 0.555555555}', 'Data validation failed!')
db.session.add(first_lab_test_1)
db.session.add(first_lab_test_2)
db.session.add(first_lab_test_3)
db.session.commit()
def DataSearch(search_type):
keyword = request.args.get('keyword')
page_number = int(request.args.get('p'))
result = []
page_result = {}
if search_type == 'script':
lens = len(Script.objects(__raw__={'script_info': re.compile(keyword)}).all())
page_result['total_page'] = str(lens // page_item_number + 1)
if page_number > lens // page_item_number + 1:
return json.dumps(page_result)
if page_number * page_item_number < lens:
scripts = Script.objects(__raw__={'script_info': re.compile(keyword)})[
lens - (page_number * page_item_number):lens - (page_item_number * (page_number - 1))]
else:
scripts = Script.objects(__raw__={'script_info': re.compile(keyword)})[
0:lens - (page_item_number * (page_number - 1))]
for each in scripts:
info = {}
info['id'] = each.script_id
info['detail'] = each.script_info
info['create_time'] = each.script_update_time
info['author'] = each.script_author
info['level'] = each.script_level
info['count'] = Vuln.objects(script=each.script_id).count()
info['title'] = each.script_title
result.append(info)
elif search_type == 'task':
lens = len(Status.objects(__raw__={'task_name': re.compile(keyword)}).all())
page_result['total_page'] = str(lens // page_item_number + 1)
if page_number > lens // page_item_number + 1:
return json.dumps(page_result)
if page_number * page_item_number < lens:
tasks = Status.objects(__raw__={'task_name': re.compile(keyword)})[
lens - (page_number * page_item_number):lens - (page_item_number * (page_number - 1))]
else:
tasks = Status.objects(__raw__={'task_name': re.compile(keyword)})[
0:lens - (page_item_number * (page_number - 1))]
for each in tasks:
info = {}
info['create_time'] = str(each.create_time).split('.')[0]
info['task_name'] = cgi.escape(each.task_name)
info['task_id'] = each.task_id
info['status'] = each.status
info['progress'] = each.progress
result.append(info)
elif search_type == 'vuln':
lens = len(Vuln.objects(__raw__={'target': re.compile(keyword)}).all())
page_result['total_page'] = str(lens // page_item_number + 1)
if page_number > lens // page_item_number + 1:
return json.dumps(page_result)
if page_number * page_item_number < lens:
vulns = Vuln.objects(__raw__={'target': re.compile(keyword)})[lens - (page_number * page_item_number):lens - (page_item_number * (page_number - 1))]
else:
vulns = Vuln.objects(__raw__={'target': re.compile(keyword)})[0:lens - (page_item_number * (page_number - 1))]
for each in vulns:
info = {}
script = Script.objects(script_id=each.script).first()
try:
info['task_name'] = cgi.escape(Task.objects(task_id=each.task_id).first().task_name)
except:
info['task_name'] = u'该任务已删除，无法查看'
info['task_id'] = each.task_id
info['target'] = each.target
info['script_name'] = script.script_name
info['script_id'] = each.script
info['message'] = each.message
info['script_type'] = each.script_type
info['time'] = str(each.create_time).split('.')[0]
info['level'] = script.script_level
result.append(info)
page_result['info'] = result
return json.dumps(page_result)
def delete_todos(id):
task = Task.get_task_by_id(int(id))
if task is None:
raise APIException("Id not found ", 404)
task.delete_from_database()
return jsonify({"Message": "Task deleted"})
def VulnList(show_type):
result = []
page_result = {}
if show_type == 'index':
data = Vuln.objects.item_frequencies('script', normalize=True)
data = OrderedDict(sorted(data.items(), key=lambda x: x[1], reverse=True))
for script_id, percent in data.items():
info = {}
info['script'] = Script.objects(script_id=script_id).first().script_name
info['count'] = str(Vuln.objects(script=script_id).count())
info['percent'] = "%.02f%%" % (percent * 100)
result.append(info)
if len(result) > 10:
result = result[0:10]
elif show_type == 'all':
data = Vuln.objects().all()
for each in data:
info = {}
script = Script.objects(script_id=each.script).first()
try:
info['task_name'] = cgi.escape(Task.objects(task_id=each.task_id).first().task_name)
except:
info['task_name'] = u'该任务已删除，无法查看'
info['task_id'] = each.task_id
info['target'] = each.target
info['script_name'] = script.script_name
info['script_id'] = each.script
info['message'] = each.message
info['script_type'] = each.script_type
info['time'] = str(each.create_time).split('.')[0]
info['level'] = script.script_level
result.append(info)
result.reverse()
elif show_type == 'page':
page_number = int(request.args.get('p'))
lens = len(Vuln.objects)
page_result['total_page'] = str(lens//page_item_number+1)
if page_number > lens//page_item_number+1:
return json.dumps(page_result)
if page_number * page_item_number < lens:
data = Vuln.objects[lens-(page_number*page_item_number):lens-(page_item_number*(page_number-1))]
else:
data = Vuln.objects[0 :lens-(page_item_number*(page_number-1))]
for each in data:
info = {}
script = Script.objects(script_id=each.script).first()
try:
info['task_name'] = cgi.escape(Task.objects(task_id=each.task_id).first().task_name)
except:
info['task_name'] = u'该任务已删除，无法查看'
info['task_id'] = each.task_id
info['target'] = each.target
info['script_name'] = script.script_name
info['script_id'] = each.script
info['message'] = each.message
info['script_type'] = each.script_type
info['time'] = str(each.create_time).split('.')[0]
info['level'] = script.script_level
result.append(info)
result.reverse()
page_result['info'] = result
return json.dumps(page_result)
return json.dumps(result)
def get(self):
taskListDeleted = Task.query(Task.deleted==False).order(-Task.done).fetch()
params = {"taskListDeleted": taskListDeleted}
return self.render_template("deleted_Task_list.html", params=params)
def get_todos(username):
tasks = Task.get_task_by_username(username)
return jsonify({
"message": f"These are the tasks available for user {username}",
"task": tasks
}), 200
