def handle(self): # check if user has admin permissions if not is_admin(self.user_entity): return self.abort(401, detail="Admin permissions required") # populate form with POST data (if available) form = TaskForm(self.request.POST) # check if form was POSTed and that user input validates if self.request.method == 'POST' and form.validate(): # create new project task = Task() # populate task from form form.populate_obj(task) # add user to project's user list and assign to self task.users.append(self.user_entity.key) task.assigned_to = self.user_entity.key # store task in datastore task.put() # record history item history_text = 'Project added' add_to_history(task, self.user_entity, history_text) self.session.add_flash(history_text) # redirect to task view on succesful save redirect_url = self.uri_for('task-view', task_id=task.key.urlsafe()) return self.redirect(redirect_url) # render form and display context = {'form': form, 'task_or_project': 'project', 'add_or_edit': 'Add new'} return self.render_response('task_form.html', context)
class TestTask(unittest.TestCase): def setUp(self): self.task = Task("Walk Dog", "Ada Lovelace", 60) def test_task_has_description(self): self.assertEqual("Walk Dog", self.task.description) def test_task_has_assignee(self): self.assertEqual("Ada Lovelace", self.task.assignee) def test_task_has_duration(self): self.assertEqual(60, self.task.duration) def test_task_completed_starts_false(self): self.assertEqual(False, self.task.completed) def test_can_mark_test_complete(self): self.task.mark_complete() self.assertEqual(True, self.task.completed)
def test_updated_task_after_cpu_udpate(self): cpu_a = Cpu('Cpu A') deadline = period = 10 cpu_time = 5 Task('A', cpu_a, deadline, period, cpu_time) Task('B', cpu_a, deadline, period, cpu_time) cpu_a.update()
def test_fail_having_more_than_one_task_overlapping(self): cpu = Cpu('Cpu A') Task('A', cpu, deadline=5, period=5, cpu_time=5) Task('B', cpu, deadline=5, period=5, cpu_time=5) with self.assertRaises(Exception): for x in range(20): cpu.update()
def new(following_id): follower = User.get_by_id(current_user.id) following = User.get_by_id(following_id) if following.is_public: r = Relationship(follower=follower, following=following, is_approved=True) else: r = Relationship(follower=follower, following=following, is_approved=False) if r.save(): if following.is_public: flash(f"You are now following {following.name}.") return redirect(url_for('users.show', username=following.username)) else: flash(f"A follow request has been sent to {following.name}.") rq_job = app.task_queue.enqueue( 'tasks.' + 'send_follow_request_email', following, follower, url_for('relationships.index')) task = Task(redis_job_id=rq_job.get_id(), name='send_follow_request_email', description='Send user a follow request email.', relationship=r) task.save() return redirect(url_for('users.show', username=following.username)) else: return render_template( 'users/show.html', user=following, photos=Image.select().where(Image.user_id == following.id), errors=r.errors)
def handle(self, task_id): # create new task (with parent) parent_task_key = ndb.Key(urlsafe=task_id) task = Task(parent=parent_task_key) # check if user is authed to add task if not authed_for_task(parent_task_key.get(), self.user_entity): return self.abort(401) # init form object with POST data form = TaskForm(self.request.POST) # if form was posted and it validates if self.request.method == 'POST' and form.validate(): # build task from form and save form.populate_obj(task) task.put() # add history record for this task history_text = 'Task added' add_to_history(task, self.user_entity, history_text) self.session.add_flash(history_text) # build url to redirect to and issue 302 to browser redirect_url = self.uri_for('task-view', task_id=task.key.urlsafe()) return self.redirect(redirect_url) # render form and return (rendering errors if necessary) context = {'form': form, 'task_or_project': 'task'} return self.render_response('task_form.html', context)
def setUp(self): self.service = KanbanBoardService() with patch('sqlalchemy.orm.query.Query') as MockQuery: self.mock_query = MockQuery.return_value self.mock_query.all.return_value = [ Task(**{ 'id': 1, 'title': 'mock-title-1', 'start_time': None, 'end_time': None, 'status': 0, 'payment': 0 }), Task(**{ 'id': 2, 'title': 'mock-title-2', 'start_time': None, 'end_time': None, 'status': 0, 'payment': 0 }) ] with patch('sqlalchemy.orm.session.Session') as MockSession: self.mock_session = MockSession.return_value self.mock_session.add.return_value = None self.mock_session.commit.return_value = None self.mock_session.close.return_value = None self.mock_session.query.return_value = self.mock_query with patch('utils.DBDriver.DBDriver') as MockDBDriver: self.service.dbms = MockDBDriver.return_value self.service.dbms.get_session.return_value = self.mock_session
def put(self, *args, **kwargs): if 'user' not in kwargs or not args: self.raise401() update = {} user = kwargs['user'] task_id = parse_path(args[0])[0] task = Task.objects(id=task_id).first() project = task.project if not project or user not in project.members: self.raise401() category = self.get_argument('category', None) description = self.get_argument('description', None) project_name = self.get_argument('project', None) status = self.get_argument('status', None) priority = self.get_argument('priority', None) assign_to = self.get_argument('assign_to', None) due = self.get_argument('due', None) tags = self.get_argument('tags', None) if category: update['set__category'] = category if description: update['set__description'] = description if project_name: project = Project.objects(name=project_name).first() if not project or user not in project.members: self.raise401() update['set__project'] = project if assign_to: assign_to_list = [] for member in parse_listed_strs(assign_to): u = User.objects(username=member).first() if not u: continue assign_to_list.append(u) update['set__assign_to'] = assign_to_list if status: update['set__status'] = status if priority: update['set__priority'] = priority if due: try: due_day = int(due) except ValueError: due_day = 0 due_time = get_utc_time(due_day * 24 * 3600) update['set__due'] = due_time if tags: tags_list = parse_listed_strs(tags) update['set__tags'] = tags_list try: Task.objects(id=task_id).update_one(**update) task = Task.objects(id=task_id).first() task_data = document_to_json(task, filter_set=_FILTER) self.set_status(201) self.write(task_data) except Exception as e: reason = e.message self.raise400(reason=reason)
def create(task, completed, task_due_date, task_goal, user_first_name): user = UserRepository.read(first_name=user_first_name) task = Task(task=task, completed=completed, task_goal=task_goal, task_due_date=task_due_date, assigne=user) return task.put()
def test_correct_simulation_1(self): cpu = Cpu('Cpu A') Task('A', cpu, deadline=10, period=10, cpu_time=5) Task('B', cpu, deadline=10, period=10, cpu_time=3) Task('C', cpu, deadline=10, period=20, cpu_time=1) Task('D', cpu, deadline=10, period=20, cpu_time=1) for x in range(40): cpu.update()
def delete(self, task_id): task = Task.get_by_id(task_id) if task is None: return {'message': 'task not found'}, HTTPStatus.NOT_FOUND dumped = task_schema.dump(task) Task.delete(task_id) return dumped, HTTPStatus.OK
def create_task(self, task, headers): try: # Checking if the token is valid or not payload = JwtHandler.decode_auth_token(headers['Authorization']) if (payload): # Creating a task object task_obj = Task() task_obj.title = task['title'] task_obj.laneId = task['laneId'] task_obj.description = task['description'] task_obj.userId = payload['sub'] task_obj.position = task['position'] task_obj.notificationTimeMinutes = task[ 'notificationTimeMinutes'] # Storing the task in tasks collection task_collection = self.__get_task_collection() saved_task = task_collection.insert_one(task_obj.__dict__) # Storing the task_id in the object and returning task_obj.id = str(saved_task.inserted_id) # Closing the DB connection self.mongo_db.disconnect() return task_obj else: return "Invalid Authorization" except Exception as exception: raise exception
def update(id): if request.method == 'POST': task = Task(description=task_description) try: description = request.form['description'] Task.update(id, task) return redirect('/') except: return 'There was an issue deleting your task' else: return render_teamplte('update.html', task=task_to_update)
def home(): if request.method == 'POST': task_description = request.form['description'] task = Task(description=task_description) try: Task.add(task) return redirect('/') except: return 'There was an issue adding your task' else: tasks = Task.findAll() return render_template('index.html', tasks=tasks)
def addtache(): tache = request.form['task'] id_col = request.form['colid'] id_ta = request.form['idt'] task = Task(content=tache, column_id=id_col, author_id=flask_login.current_user.get_id()) db = get_db() cur = db.cursor() task.insert(cur) db.commit() return redirect(url_for('home'))
def show_checkout(transaction_id, image_id): image = Image.get_by_id(image_id) transaction = find_transaction(transaction_id) user = User.get_by_id(current_user.id) photographer = image.user result = {} if transaction.status in TRANSACTION_SUCCESS_STATUSES: result = { 'header': 'Sweet Success!', 'icon': url_for('static', filename="images/ok_icon.png"), 'message': 'Your test transaction has been successfully processed. You will receive a payment receipt via email shortly.' } t = Transaction(amount=transaction.amount, braintree_id=transaction.id, user=user, image=image) if t.save(): flash(f"Transaction successfully created.") rq_job = app.task_queue.enqueue( 'tasks.' + 'send_transaction_email', user, transaction.amount, transaction.credit_card_details.card_type, transaction.credit_card_details.last_4, photographer, transaction.id) task = Task(redis_job_id=rq_job.get_id(), name='send_transaction_email', description='Send user a donation receipt.', transaction=t) task.save() else: return render_template('transactions/show.html', transaction=transaction, result=result, errors=t.errors) else: result = { 'header': 'Transaction Failed', 'icon': url_for('static', filename="images/fail_icon.png"), 'message': 'Your test transaction has a status of ' + transaction.status + '. See the Braintree API response and try again.' } return render_template('transactions/show.html', transaction=transaction, result=result)
def posts_task(): content = request.json["content"] task = Task(content=content, author_id=flask_login.current_user.get_id(), column_id="ToDO", status="ToDO") #TODO modify this shit print(content) db = get_db() cur = db.cursor() task.insert(cur) db.commit() return "ok", 201
def get(self, *args, **kwargs): if 'user' not in kwargs: self.raise401() user = kwargs['user'] if args: path = parse_path(args[0]) task = Task.objects(id=path[0]).first() if not task: self.raise404() if user not in task.project.members: self.raise401() task_data = document_to_json(task, filter_set=_FILTER) else: project_name = self.get_argument('project', None) limit = self.get_argument('limit', None) start = self.get_argument('start', None) try: limit = int(limit) except: limit = None try: start = int(start) except: start = None try: project_name = parse_path(project_name)[0] except IndexError: project_name = None if project_name: project = Project.objects(name=project_name).first() if not project: self.raise404() if user not in project.members: self.raise403() tasks = Task.objects(project=project) else: projects = Project.objects(members__in=[user]).all() tasks = [] for project in projects: ts = Task.objects(project=project).all() tasks += list(ts) if limit and start: tasks = tasks[start: start+limit] elif limit: tasks = tasks[:limit] elif start: tasks = tasks[start:] task_data = query_to_json(tasks, filter_set=_FILTER) self.write(task_data)
def get(self, *args, **kwargs): if 'user' not in kwargs: self.raise401() user = kwargs['user'] if args: path = parse_path(args[0]) task = Task.objects(id=path[0]).first() if not task: self.raise404() if user not in task.project.members: self.raise401() task_data = document_to_json(task, filter_set=_FILTER) else: project_name = self.get_argument('project', None) limit = self.get_argument('limit', None) start = self.get_argument('start', None) try: limit = int(limit) except: limit = None try: start = int(start) except: start = None try: project_name = parse_path(project_name)[0] except IndexError: project_name = None if project_name: project = Project.objects(name=project_name).first() if not project: self.raise404() if user not in project.members: self.raise403() tasks = Task.objects(project=project) else: projects = Project.objects(members__in=[user]).all() tasks = [] for project in projects: ts = Task.objects(project=project).all() tasks += list(ts) if limit and start: tasks = tasks[start:start + limit] elif limit: tasks = tasks[:limit] elif start: tasks = tasks[start:] task_data = query_to_json(tasks, filter_set=_FILTER) self.write(task_data)
def terminate(self, code: str, traceback, description): self.worker.terminated_code = code traceback_list = [] for item in traceback: traceback_list.append({ "filename": item.filename, "line_number": item.lineno, "method_name": item.name, "string": item.line }) self.worker.terminated_traceback = json.dumps(traceback_list) self.worker.terminated_description = description Task.terminate_on_emergency_exit(self.worker.id) self.worker.terminate()
def add_task_post(): description = request.form.get('description') task = Task(description=description) db = get_db() cur = db.cursor() try: task.insert(cur) except sqlite3.IntegrityError: return render_template( 'index.html', error_msg="This task already exist.", ) db.commit()
def reject(user_id): follower = User.get_by_id(user_id) r = Relationship.get(Relationship.follower_id == user_id, Relationship.following_id == current_user.id) try: if Task.get(Task.relationship_id == r.id): t = Task.get(Task.relationship_id == r.id) t.delete_instance() except: pass r.delete_instance() flash(f"You have rejected {follower.name}'s follow request.") return redirect(url_for('users.show', username=current_user.username))
async def update_task(task: Task, *, slug: str = Body(...), current_user: User = Depends(get_current_active_user)): db = await get_database() poll = await crud.poll.get_poll(db, slug=slug) if not poll: raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="Poll does not exist!") poll.current_task = Task(**task.dict()) await crud.poll.update_poll(db, poll=poll) return {"status": "success", "message": "Task Updated"}
def get(self, id=None): task = Task.find_by_id(self, 1) newGrabber = task.getGrabber() newGrabber.login(newGrabber) if task: return task.json() return {'message': 'Task not found'}, 404
def delete(self, *args, **kwargs): if 'user' not in kwargs or not args: self.raise401() user = kwargs['user'] task_id = parse_path(args[0])[0] task = Task.objects(id=task_id).first() project = task.project if not project or user not in project.members: self.raise401() try: Task.objects(id=task_id).delete() self.set_status(204) self.finish() except Exception as e: reason = e.message self.raise400(reason=reason)
def add_task(): task_title = request.form['title'] task_desc = request.form['description'] new_task = Task(task_title, task_desc, False) print(request.form) add_new_task(new_task) return render_template('index.html', title="Home", tasks=tasks)
def get(self, *args, **kwargs): if 'user' not in kwargs: self.raise401() if not args: self.raise404() path = parse_path(args[0]) task = Task.objects(id=path[0]).first() if not task: self.raise404() user = kwargs['user'] if user not in task.project.members: self.raise401() limit = self.get_argument('limit', None) start = self.get_argument('start', None) try: limit = int(limit) except: limit = None try: start = int(start) except: start = None comments = task.comments if limit and start: comments = task.comments[start:start+limit] elif limit: comments = task.comments[:limit] elif start: comments = task.comments[start:] else: comments = task.comments comment_data = query_to_json(comments, filter_set=_COMMENT_FILTER) self.write(comment_data)
def test_update_task_exception(self): """Test: update_task(self, event) session.query(Task).all() throws Exception""" self.mock_query.get.return_value = Task(**{ 'id': 3, 'title': 'mock-title-3', 'start_time': None, 'end_time': None, 'status': 0, 'payment': 0 }) status = Task.Statuses.IN_PROGRESS.value event = { 'body': f'{{"status": {status}}}', 'pathParameters': { 'id': '3' } } self.mock_session.commit.side_effect = Mock(side_effect=Exception()) actual = self.service.update_task(event) self.assertEqual(500, actual['status']) self.assertEqual( 'session.commit error', actual['data']['errors']['db'] )
def test_update_task_error_status_is_incorrect(self): """Test: update_task(self, event). Error: status is incorrect.""" status = Task.Statuses.IN_PROGRESS.value self.mock_query.get.return_value = Task(**{ 'id': 3, 'title': 'mock-title-3', 'start_time': None, 'end_time': None, 'status': status, 'payment': 0 }) status = Task.Statuses.TODO.value event = { 'body': f'{{"status": {status}}}', 'pathParameters': { 'id': '3' } } actual = self.service.update_task(event) self.assertEqual(409, actual['status']) self.assertEqual( 'status is incorrect', actual['data']['errors']['status'] )
def create_task(): description = request.form["description"] user_id = request.form["user_id"] duration = request.form["duration"] completed = request.form["completed"] user = user_repository.select(user_id) task = Task(description, user, duration, completed) task_repository.save(task) return redirect('/tasks') # SHOW # for showing one thing in detail. {{task.description}} in the html can be placed inside an <a></a> tag # GET '/tasks/<id>' # EDIT # slightly harder code # GET '/tasks/<id>/edit' # UPDATE # slightly harder code # PUT '/tasks/<id>' # DELETE # DELETE '/tasks/<id>'
def process(cls): task_model = Task.get_task(cls.robot_model.WxAccount) if task_model is None: return ret = True if task_model.TaskType == Task.TASK_TYPE_SEND_MSG: cls.process_send_msg(task_model.ToUserName, task_model.Content) elif task_model.TaskType == Task.TASK_TYPE_REFRESH_GROUP: cls.process_refresh_chatrooms() else: ret = False Task.delete(task_model, True) logger.debug('process task ret:{0}'.format('成功' if ret else '失败'))
def get_tasks(self, project, limit=5): """ Arbitrarily narrow down to only one workspace :param project_id: PHID of Phabricator project """ task_list = [] tasks = self.client.maniphest.search( queryKey="open", constraints={"projects": [project.id]}, limit=limit )["data"] # Parse JSON into Task objects for task in tasks: task_list.append( Task( id=task["id"], title=task["fields"]["name"], link="{}".format(Config.PHABRICATOR_URI.replace("/api/", "")) + "/T" + str(task["id"]), is_completed=("Completed" == task["fields"]["status"]["value"]), created_at=datetime.strftime( datetime.fromtimestamp(task["fields"]["dateCreated"]), "%Y-%m-%d %H:%m:%S", ), priority=task["fields"]["priority"]["value"], project=project, ) ) return task_list
async def get(self, *args, **kwargs): """ --- tags: - Tasks summary: Get special tasks description: get special task with task_id produces: - application/json parameters: - name: task_id in: query description: task_id required: true type: integer responses: 200: description: object of task schema: $ref: '#/definitions/TaskModel' 400: description: task_id is invalid """ pk = self.get_argument('task_id', '') query = Task.select().filter(Task.id == pk) if not query.exists(): raise BadRequestException('task_id: `{}` is invalid'.format(pk)) task = query.dicts().get() task['create_at'] = datetime_fmt(task['create_at']) task['update_at'] = datetime_fmt(task['update_at']) return self.finish_success(task)
def post(self, slug): user = users.get_current_user() if not user: self.redirect('/') tasklist = db.Query(TaskList).filter("slug =", slug).get() key = self.request.get('key') if key: task = Task.get(key) title = self.request.get('title') description = self.request.get('description') complete = self.request.get('complete') remove = self.request.get('remove') if title: task.title = title task.put() self.response.out.write(title) if description: task.description = description task.put() self.response.out.write(description) if complete == 'complete': task.complete = True task.put() self.response.out.write(complete) if complete == 'incomplete': task.complete = False task.put() self.response.out.write(complete) if remove: task.delete() self.response.out.write('Task has been removed.') else: priority = self.request.get_all('priority[]') if priority: for i,k in enumerate(priority): task = Task.get(k) task.priority = int(i) task.put() self.response.out.write('Sorting saved.') else: self.response.out.write('Error')
def post(self, slug): user = users.get_current_user() tasklist = db.Query(TaskList).filter("slug =", slug).get() if not tasklist: self.redirect("/") return if not user: self.redirect("/") return if self.request.get('newtask'): task = Task( owner = user, title = 'New Task', ) task.put() self.response.out.write('Saved Task.') self.redirect("/u/"+slug)
def get_projects_for_user_async(user_key, admin_permissions): # base projects query projects = Task.query().filter(Task.is_top_level == True) # filter projects if user is not an admin if not admin_permissions: projects = projects.filter(Task.users == user_key) # sort projects by creation date projects = projects.order(Task.creation_time) project_list = yield projects.map_async(lambda x: x.key) raise ndb.Return(project_list)
def post(self, *args, **kwargs): if 'user' not in kwargs or args: self.raise401() category = self.get_argument('category', None) description = self.get_argument('description', None) project_name = self.get_argument('project', None) status = self.get_argument('status', None) priority = self.get_argument('priority', None) assign_to = self.get_argument('assign_to', None) due = self.get_argument('due', None) # days or date tags = self.get_argument('tags', None) user = kwargs['user'] project = Project.objects(name=project_name).first() if not project or user not in project.members: self.raise401() try: due_day = int(due) except ValueError: due_day = 0 try: assign_to_list = [] if assign_to: for member in parse_listed_strs(assign_to): u = User.objects(username=member).first() if not u: continue assign_to_list.append(u) due_time = get_utc_time(due_day * 24 * 3600) tags_list = parse_listed_strs(tags) task = Task( category=category, description=description, project=project, status=status, priority=priority, assign_to=assign_to_list, due=due_time, tags=tags_list) task.save() task_data = document_to_json(task, filter_set=_FILTER) self.set_status(201) self.write(task_data) except Exception as e: reason = e.message self.raise400(reason=reason)
def post(self, *args, **kwargs): if 'user' not in kwargs: self.raise401() if not args: self.raise404() path = parse_path(args[0]) task = Task.objects(id=path[0]).first() if not task: self.raise404() user = kwargs['user'] if user not in task.project.members: self.raise401() content = self.get_argument('content', None) try: comment = TaskComment(content=content, author=user) Task.objects(id=path[0]).update_one(push__comments=comment) comment_data = document_to_json( comment, filter_set=_COMMENT_FILTER) self.set_status(201) self.write(comment_data) except Exception as e: reason = e.message self.raise400(reason=reason)
def addjob(jobtype,jobdetail): job=Task(jobtype=jobtype,jobdetail=jobdetail) job.save()
from datetime import datetime def addjob(jobtype,jobdetail): job=Task(jobtype=jobtype,jobdetail=jobdetail) job.save() def send_verify_mail(mail_to=""): #验证地址是邮箱加一个邮箱+一串值 的md5 s='你好,收到这封邮件是因为你的邮箱注册了觅汇.\n' s=s+'点击这里验证你在觅汇的邮箱.' sendmail(u"觅汇邮箱验证",s, mail_to) if __name__=='__main__': while 1: jobs=Task.objects(result__lt=1)# <! and >-2 if len(jobs)>0: for job in jobs: if job.jobtype==1: if job.result<-2: break mail=job.jobdetail try: send_verify_mail(mail_to=mail) job.result=1 job.save() print datetime.now(),"send mail %s job done"%mail except Exception, e: print datetime.now(),"send mail %s failed; %s" % (mail,str(e) ) job.result-=1 job.save()
def GET(self): tasks = Task.getall() users = User.getall() projects = Project.getall() return render().index(tasks, users, projects, priorities=PRIORITIES, statuses=STATUSES)
#coding:utf-8 from models.task import Task jobs=Task.objects(result__lt=1) if len(jobs)>0: print "start job" else: print "no job"