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 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"
