def test_task(incomplete_task, weekly_recurring_task):
# test initial attrs
t = models.Task()
assert t.id is None
assert t.name == ''
assert t.due is None
assert t.schedule is None
assert not t.completed
assert not t.recurs
# test initial attr override
t = models.Task(id=123, name='foobar', recurs=True)
assert t.id == 123
assert t.name == 'foobar'
assert t.recurs
# test due date scheduling property
t.due = 'today'
assert t.due == datetime.date.today()
# test display_id property
t.id = 56
assert t.display_id == '1k'
# test to_json props
j = t.to_json()
assert 'id' in j
assert j['id'] == t.id
assert 'name' in j
assert j['name'] == t.name
assert 'recurs' in j
assert j['recurs'] == t.recurs
assert 'completed' in j
assert j['completed'] == t.completed
assert 'due' in j
assert j['due'] == datetime.date.today()
# schedule not set so it shouldn't even be in the attrs
assert 'schedule' not in j
# test complete() - non-recurring task should be completed
assert not incomplete_task.completed
incomplete_task.complete()
assert incomplete_task.completed
# recurring task should be rescheduled - it is never complete
assert not weekly_recurring_task.completed
weekly_recurring_task.complete()
assert not weekly_recurring_task.completed
assert weekly_recurring_task.due == datetime.date(2017, 1, 10)
def routines():
try:
controller = request.args.get('controller')
except Exception:
return 'ERROR REPORT'
try:
query = models.Device.query(models.Device.name == controller)
if query.count() > 0:
for dev in query.fetch():
dev.lastseen = datetime.datetime.now()
dev.put()
else:
return '0'
except Exception as e:
print 'Caught exp at get_routines: ' + str(e)
return 'ERROR CHECK'
try:
tasken = models.Task.query(models.Task.controller == controller,
models.Task.done == False).order(
models.Task.timestamp)
dev = models.Server.query(
models.Server.lastseen <
datetime.datetime.now() - datetime.timedelta(minutes=4),
models.Server.controller == controller,
models.Server.enabled == True)
device = models.Device.query(
models.Device.lastseen < datetime.datetime.now() -
datetime.timedelta(minutes=4)).count()
if dev.count() > 0 and tasken.count() < 1 and device < 1:
for de in dev.fetch():
models.Task(controller=de.controller,
target=de.pin,
action='stop').put()
models.Task(controller=de.controller,
target=de.pin,
action='start').put()
models.Visit(user_ip=request.remote_addr,
action='ADD TASK TO START ' + de.name).put()
tasken = tasken.fetch()
except Exception as e:
print 'Caught exp at get_routines: ' + str(e)
return 'ERROR DATABASE'
ret = str(len(tasken)) + '\n'
for task in tasken:
mmm = str(task.key.integer_id()) + '; '
mmm += str(task.target) + '; '
mmm += str(task.action) + '; '
mmm += '\n'
ret += mmm
return ret
def create_task(db: Session, task: schemas.TaskCreate):
db_task = models.Task(task_name=task.task_name,
task_description=task.task_description)
db.add(db_task)
db.commit()
db.refresh(db_task)
return db_task
def _():
archive_entity = archive_key.get()
if not archive_entity:
archive_entity = models.Archive(
key=archive_key, initial_request=swarming_request)
archive_entity.put()
# Insert all of the tasks as entities under our parent.
for json_task_name, json_task in swarming_request[
'tasks'].iteritems():
# The id for this key is auto generated (thus why we specify 0).
task_key = ndb.Key(models.Task, 0, parent=archive_key)
task = models.Task(key=task_key,
task_id=json_task['task_id'],
task_name=json_task_name)
task.put()
# Only poll the archive if this commit succeeds.
deferred.defer(
PollArchive,
archive_key=archive_key,
_transactional=True,
_retry_options=taskqueue.TaskRetryOptions(
max_backoff_seconds=6.0,
min_backoff_seconds=3.0,
task_age_limit=60 * 60, # 1 hour
))
return archive_entity
def create_task():
data = utils.get_request_data()
task = models.Task()
task.title = data['title']
task.content = data['content']
task.manager = models.User.objects.get(username=data['manager'])
for assign in data['assignee']:
task.assignee.append(models.User.objects.get(username=assign))
task.status = data['status']
task.tags = data['tags']
task.due_time = datetime.datetime.strptime(data['due_time'],
'%b %d %Y %I:%M%p')
task.pub_time = datetime.datetime.now()
task.update_time = datetime.datetime.now()
if task.pub_time < task.due_time:
task.save()
return utils.make_json_response(200, task.to_dict())
else:
raise exception_handler.BadRequest(
'due time %s is earlier than pub time %s' %
(data['due_time'], datetime.datetime.now()))
def store_task(taskID):
if taskID == -1:
task = models.Task("")
else:
task = models.Task.query.filter_by(id=int(taskID)).first()
pattern = r"<script.*?</script>"
data = flask.request.get_json()
content = data.get('html')
courseID = data.get('course_id')
course = models.Course.query.filter_by(id=courseID).first()
if course.teacher_id != current_user.id and current_user.permissions < 100:
return "Permission Denied", 401
taskTitle = data.get('taskTitle')
taskDueDate = data.get('taskDue')
task.title = taskTitle
task.content = re.sub(pattern, "", content, flags=re.DOTALL)
task.questions = json.dumps(data.get('questions'))
task.course = models.Course.query.filter_by(id=courseID).first()
task.duedate = datetime.datetime.fromtimestamp(taskDueDate/1000.0)
task.supplementary = json.dumps(data.get('supplementary'))
task.xml_data = json.dumps(data['xmlData']);
models.db.session.add(task)
models.db.session.commit()
print "Stored task " + str(task.id) + " into db."
return "Stored task " + str(task.id) + " into db."
def init():
print('init: Initializing database')
db.create_all()
task = models.Task(title='title', date=datetime.utcnow())
db.session.add(task)
db.session.commit()
flash('init DB')
return redirect(url_for('index'))
def add_task():
"""
Saves a new task to the db and returns new task object.
"""
description = request.form.get('task')
new_task = models.Task()
new_task.description = description
new_task.save()
return jsonify(new_task.serialize())
def create_todo():
taskname = request.form.get('taskname')
description = request.form.get('description')
task = models.Task(taskname, description)
db.session.add(task)
db.session.commit()
return redirect(url_for("index_todo"))
def add():
form = forms.AddTaskForm()
if form.validate_on_submit():
task = models.Task(title=form.title.data, date=datetime.utcnow())
db.session.add(task)
db.session.commit()
flash('Task added')
return redirect(url_for('index'))
return render_template('add.html', form=form)
def add_task(week, order, name, contest, review):
if find_task(week, order):
return False
task = m.Task(name=name,
week=week,
order=order,
contest=contest,
review=review)
task.save()
return True
def update_task():
"""
Updates a task's description and is_done attributes.
Returns a JSON task object.
"""
task_to_update = models.Task(request.form.get('task_id'))
task_to_update.description = request.form.get('description')
task_to_update.is_done = request.form.get('is_done')
task_to_update.save()
return jsonify(task_to_update.serialize())
def post(self):
body = request.get_json()
task = models.Task(**body).save()
serialized_data = {
'id': str(task.id),
'message': 'Comment {0} successfully created.'.format(task.id)
}
return Response(json.dumps(serialized_data),
mimetype="application/json",
status=201)
def create_task(self, task_values):
values = copy.deepcopy(task_values)
values['id2'] = uuidutils.generate_uuid()
task = models.Task()
params = task.generate_param()
for k, v in params.items():
params[k] = values.get(k)
task.update(params)
self.add(task)
return self.get_task_by_id2(params['id2'])
def add_task():
form = forms.Task(request.form)
if request.method == 'POST' and form.validate():
task = models.Task()
form.populate_obj(task)
task.user_id = g.user.id
task.insert(g.cursor)
return redirect(url_for('index'))
def add_task():
description = request.form.get("task")
goal_id = request.form.get("goal_id")
try:
task = models.Task(description=description, goal_id=goal_id)
db.session.add(task)
db.session.commit()
return "Successfully added task"
except IntegrityError:
return "Bad request bruh. Are you sure this goal exists?", 400
def add():
form = forms.AddTaskForm() # instance of our form class
if form.validate_on_submit(): # when post is a success we do stuff
t = models.Task(title=form.title.data, date=datetime.utcnow())
db.session.add(t)
db.session.commit()
flash('Task added to the database')
return redirect(
url_for('index')
) # if success we redirect on index where all tasks are shown
return render_template('add.html',
form=form) # in the render we call it form
def delete_tasks():
"""
Endpoint that allows setting delete property of a list of tasks.
Returns a list of task objects that were set to deleted.
"""
tasks_to_delete = request.form.getlist("task_ids[]")
deleted_tasks_list = []
for task_id in tasks_to_delete:
task_to_delete = models.Task(int(task_id))
task_to_delete.delete()
deleted_tasks_list.append(task_to_delete.serialize())
return jsonify(deleted_tasks_list)
def addtask():
form = forms.AddTask()
if form.validate_on_submit():
mom = models.Task(controller=request.form['controller'],
target=request.form['target'],
action=request.form['action'])
mom.put()
models.Visit(user_ip=request.remote_addr,
action='PUT TASK ' + str(mom.key.integer_id())).put()
flash('added ' + str(mom.key.integer_id()))
return redirect('/admin/tasks')
return render_template('addtask.html', form=form)
def post(self):
try:
try:
req = taskParser.parse_args()
except Exception as e:
return {"error": e}, 403
current_user = get_jwt_identity()
task = models.Task(task=req.task, user_id=int(current_user))
models.Task.save_task(task)
return {"ok": "ok"}, 200
except Exception as e:
return {"error": e}, 403
def create_task(db):
response.content_type = 'application/json'
try:
jsonschema.validate(request.json, schemas.task_schema)
task = models.Task(title=request.json['title'])
db.add(task)
db.commit() # ここでコミットしないとidとかdefault値を返せない
return json.dumps(task.serialize)
except jsonschema.ValidationError:
response.status_code = 400
return json.dumps({
'error': {'message': 'Validation is failed...'}
})
def post(self, project_id):
args = self.post_reqparse.parse_args()
new_task = models.Task(
project_id,
current_user.id,
args['task_status_id'],
args['title'],
args['text'],
args['assigned']
)
models.db.session.add(new_task)
models.db.session.commit()
return self.full_schema.dump(new_task).data
def add(name, due, recurs):
"""Add a new task."""
t = models.Task(name=name)
if due is not None:
t.due = due
if recurs is not None:
t.recurs = True
t.schedule = recurs
tasks.add(t)
tasks.save(settings.data_file)
click.echo(f'Added task {t.name} (id {t.display_id}).')
def test_code_create_task_for_service():
list_nodes = session.query(models.Node).all()
for node in list_nodes:
print(node.node_display_name)
service_setups = get_service_setups_from_deployment(node.deployment)
#service = service_setups[0]
for service in service_setups:
list_tasks = load_yml_file(CONST.role_dir + '/' +
service.service_name +
'/tasks/main.yml')
list_task_info = []
for index, task in enumerate(list_tasks, start=0):
task_info = {}
for command in task.get('block'):
if command.get('name') is not None:
task_info['name'] = command.get('name')
elif command.get('include') is None:
setup_data = str(json.dumps(command))
task_info['setup_data'] = setup_data[:250] + (
setup_data[250:] and '..')
task_info['task_type'] = command.keys()
if 'register' in task_info['task_type']:
task_info['task_type'].remove('register')
list_task_info.append(task_info)
for index, task in enumerate(list_task_info, start=1):
task_data = models.Task(created_at=datetime.now(),
task_display_name=task.get('name'),
setup_data=task.get('setup_data'),
task_type=str(task.get('task_type')),
task_index=index)
service.tasks.append(task_data)
session.add(node)
session.commit()
session.close()
return {
"respone": "Done Create Tasks in Database. Check in /api/v1/tasks"
}, 202
def post(self):
if (self.request.get('id')):
task = models.Task.get_by_id(int(self.request.get('id')))
else:
task = models.Task()
task.start_day = ParseDate(self.request.get('start_day'))
task.owner = self.request.get('owner')
task.description = self.request.get('description')
task.long_description = self.request.get('long_description')
task.length = self.request.get('length')
task.dependent_tasks = self.request.get('dependent_tasks')
# Keep a history of 'days remaining' estimates.
now = str(int(time.time()))
if task.remaining:
remaining = task.remaining.split(',')
if remaining[-1] != self.request.get('remaining'):
task.remaining += "," + self.request.get('remaining')
task.remaining_updates += "," + now
else:
task.remaining = self.request.get('remaining')
task.remaining_updates = now
# Special case - A task with a length, and a date, but no days remaining
# is assumed to have ocurred in the past.
#if self.request.get('start_day') and not self.request.get('remaining'):
# update_time = task.start_day * 86400
# task.remaining = self.request.get('length')
# task.remaining_updates = str(update_time)
task.put()
output = {}
output["id"] = str(task.key().id())
output["owner"] = task.owner
output["long_description"] = task.long_description
output["description"] = task.description
output["start_day"] = task.start_day
output["remaining"] = task.remaining.split(",")
output["remaining_updates"] = task.remaining_updates.split(",")
output["length"] = task.length
output["dependent_tasks"] = task.dependent_tasks.split(",")
self.response.out.write(json.dumps(output))
def post(self):
""" Process the new Task data, to store in the database """
task_name = cgi.escape(self.request.get('task_name'))
due_date = datetime.strptime(self.request.get('due_date'), '%Y-%m-%d')
start_date = datetime.strptime(self.request.get('start_date'), '%Y-%m-%d')
task_list = db.Key(self.request.get('task_list'))
percent_complete = int(self.request.get('complete'))
# Save the data to the database
task = models.Task()
task.owner = common.get_current_user()
task.name = task_name
task.task_list = task_list
task.due_date = due_date
task.start_date = start_date
task.percent_complete = percent_complete
task.put()
# Redirect the user to the task view page after saving the new task
self.redirect('/tasks/task/view/%s' % (task.key()))
def post(self, request, format=None):
if request.POST.get("description") is None:
print request.POST.get("title")
category = models.Category(title=request.POST.get("title"))
category.save()
else:
print request.POST.get("category_id")
category_id = request.POST.get("category_id")
category_found = models.Category.objects.get(id=category_id)
task = models.Task(title=request.POST.get("title"),
description=request.POST.get("description"),
category=category_found)
task.save()
categories = models.Category.objects.all()
tasks = models.Task.objects.all()
return render(request, 'app/home.html', {
'categories': categories,
'tasks': tasks
})
def post(self):
args, tk = self.parser.parse_args(), request.headers.get('Authorization')
uid = token.check_token(tk)
date = time.strftime("%Y-%m-%d %H:%M", time.localtime())
new_task = md.Task(uid=uid, tname=args['tname'], date=date, status=0)
db.session.add(new_task)
db.session.commit()
host_list = json.loads(args['hosts']) # convert pure json to python list
for host in host_list:
if dns.valid_host(host['target']):
new_host = md.Host(tid=new_task.id, hname=new_task.tname, target=host['target'], policy=host['policy'])
db.session.add(new_host)
db.session.commit()
return msg.success_msg
def addtask(list_id):
"""
Esta funcion nos permite agregar nuevas tareas a la lista
mediante el models y con un if validando el forms
y el metodo
"""
form = forms.taskForm(request.form)
task_list = models.TaskList.query.get(list_id)
if request.method == 'POST' and form.validate():
if task_list:
new_task = models.Task(
task=form.task.data,
task_id=task_list.id
)
models.db.session.add(new_task)
models.db.session.commit()
return redirect(url_for('tarea', list_id=task_list.id))
else:
return 'La lista no existe, debe crearla para continuar.'
return render_template('addtask.html', form=form)
def save_task(request):
data = json.loads(request.body)
id = data.get("id")
if id:
task = models.Task.objects.get(id=id)
else:
task = models.Task()
task.name = data.get("name")
task.module_id = data.get("module_id")
task.desc = data.get("desc")
task.type = data.get("type")
task.user = public.get_user_mail(request)
task.save()
svn_list = data.get("svn_list") if data.get("svn_list") else []
if not isinstance(svn_list, list):
svn_list = [svn_list]
param = {}
param["task_id"] = task.id
param["svn_list"] = svn_list
param["timer"] = data.get("timer")
param["user"] = public.get_user_mail(request)
save_task_trigger_job(param)
