Esempio n. 1
0
 def show(self, id):
     try:
         task = Session.query(Task).filter_by(id=id).one()
     except:
         abort(404)
     notes = Session.query(Note).filter_by(task=id).all()
     return render("tasks/show.html", {"task": task, "notes": notes})
Esempio n. 2
0
 def create(self):
     note_dict = {}
     for param in request.params:
         note_dict[param] = request.params[param]
     note_dict["author"] = session["user"]["id"]
     new_note = Note(**note_dict)
     Session.add(new_note)
     Session.commit()
     return redirect("/tasks/show/%s" % note_dict["task"])
Esempio n. 3
0
 def newuser(self, id):
     try:
         project = Session.query(Project).filter_by(id=id).one()
         user = Session.query(User).filter_by(username=request.params["username"]).one()
     except:
         abort(404)
     project.users.append(user)
     Session.commit()
     user_info = dict(id=user.id, firstname=user.firstname, lastname=user.lastname)
     return json.dumps(user_info)
Esempio n. 4
0
    def create(self):
        tasklist_args = {
            "name": request.params["tasklist_name"],
            "project_id": request.params["project_id"]
        }
        tasklist = TaskList(**tasklist_args)
        Session.add(tasklist)
        Session.commit()

        return redirect("/projects/show/%s" % tasklist.project.id)
Esempio n. 5
0
 def delete(self, id):
     try:
         project = Session.query(Project).filter_by(id=id).one()
     except:
         abort(404)
     if "_method" in request.params and request.params["_method"] == "DELETE":
         Session.delete(project)
         Session.commit()
         # TODO flash a message saying the project was deleted
         return redirect("/projects")
     return render("projects/delete.html", {"project": project})
Esempio n. 6
0
 def delete(self, id):
     try:
         tasklist = Session.query(TaskList).filter_by(id=id).one()
     except:
         abort(404)
     if "_method" in request.params and request.params["_method"] == "DELETE":
         Session.delete(tasklist)
         Session.commit()
         # TODO flash a message
         return redirect("/projects/show/%s" % tasklist.project.id)
     return render("tasklists/delete.html", {"tasklist": tasklist})
Esempio n. 7
0
 def deluser(self, id, userid):
     try:
         project = Session.query(Project).filter_by(id=id).one()
         user = Session.query(User).filter_by(id=userid).one()
     except:
         abort(404)
     if hasattr(project, "users"):
         if user in project.users:
             project.users.remove(user)
             Session.commit()
     return redirect("/projects/show/%s" % id)
Esempio n. 8
0
 def complete(self, id):
     try:
         task = Session.query(Task).filter_by(id=id).one()
     except:
         abort(404)
     completed = True if request.params["completed"] == "true" else False
     completed_at = datetime.now() if completed else None
     change_status = Session.query(Task).filter_by(id=id).update({
         "completed": completed,
         "completed_at": completed_at
     })
     Session.commit()
Esempio n. 9
0
    def edit(self, id=None):
        if id is not None:
            tasklist = Session.query(TaskList).filter_by(id=id).first()
            if tasklist is None:
                abort(404)

            edit_form = tasklist_form.bind(tasklist, data=request.POST or None)
            if request.POST and edit_form.validate():
                edit_form.sync()
                Session.commit()
                # TODO left off here
                #redirect("/projects/show/%s" % id)
            #context = {
            #    "project": project,
            #    "project_form": edit_form.render(),
            #}
            #return render("projects/edit.html", context)
        else:
            return redirect("/projects/new")
Esempio n. 10
0
 def show(self, id):
     try:
         project = Session.query(Project).filter_by(id=id).one()
     except:
         abort(404)
     tasks = Session.query(Task).filter_by(project_id=id).all()
     completed_tasks = 0
     uncompleted_tasks = 0
     for task in tasks:
         if task.completed:
             completed_tasks = completed_tasks + 1
         else:
             uncompleted_tasks = uncompleted_tasks + 1
     context = {
         "project": project,
         "tasklists": project.tasklists,
         "completed_tasks": completed_tasks,
         "uncompleted_tasks": uncompleted_tasks
     }
     return render("projects/show.html", context)
Esempio n. 11
0
 def edit(self, id=None):
     if id is not None:
         project = Session.query(Project).filter_by(id=id).first()
         if project is None:
             abort(404)
     else:
         return redirect("/projects/new")
     edit_form = project_form.bind(project, data=request.POST or None)
     if request.POST and edit_form.validate():
         edit_form.sync()
         # NOTE id is probably never none, consider removing
         if id is None:
             Session.add(project)
         Session.commit()
         redirect("/projects/show/%s" % id)
     context = {
         "project": project,
         "project_form": edit_form.render(),
     }
     return render("projects/edit.html", context)
Esempio n. 12
0
    def create(self):
        create_form = project_form.bind(Project, data=request.params)
        if request.POST and create_form.validate():
            project_args = {
                "name": create_form.name.value,
                "description": create_form.description.value,
                "author_id": 1, # TODO set this based on logged-in user
            }
            project = Project(**project_args)

            tasklist_args = {
                "name": "Tasks",
                "project_id": project.id
            }
            project.tasklists = [TaskList(**tasklist_args)]

            Session.add(project)
            Session.commit()
            return redirect("/projects/show/%s" % project.id)
        return render("/projects/new.html", {"project_form": create_form.render()})
Esempio n. 13
0
 def edit(self, id):
     if id is not None:
         user = Session.query(User).filter_by(id = id).first()
         if user is None:
             #TODO something better than 404
             abort(404)
         edit_form = user_form.bind(user, data=request.POST or None)
         if request.POST and edit_form.validate():
             edit_form.sync()
             # NOTE id is probably never none, consider removing
             if id is None:
                 Session.add(user)
             Session.commit()
             #redirect("/projects/show/%s" % id)
             session['flash'] = 'User updated'
         return render('users/edit.html', {
             'user': user,
             'user_form': edit_form.render()
         })
     else:
         return redirect('/users/new')
Esempio n. 14
0
 def dologin(self):
     if request.params['email'] and request.params['password']:
         password = User.hash(request.params['password'])
         try:
             user = Session.query(User).filter(User.email==request.params['email']).\
                 filter(User.password==password).one()
         except:
             return render('users/login.html')
         session['user'] = {'id': user.id, 'name': '%s %s' % (user.firstname, user.lastname)}
         session.save()
         return redirect('/projects')
     else:
         return redirect('/users/login')
Esempio n. 15
0
    def edit(self, id=None):
        try:
            task = Session.query(Task).filter_by(id=id).one()
        except:
            abort(404)

        edit_form = task_form.bind(task, data=request.POST or None)
        tasklist = Field('tasklist_id').dropdown(
            options=[(tasklist.name, tasklist.id) for tasklist in Session.query(TaskList).\
                        filter_by(project_id=task.project_id).all()]).\
            required().label('Task List')
        edit_form.append(tasklist)

        if request.POST and edit_form.validate():
            task.tasklist = Session.query(TaskList).filter_by(id=request.POST.values()[-1]).one()
            edit_form.sync()
            Session.commit()
            return redirect("/projects/show/%s" % task.project_id)

        return render("tasks/edit.html", {
            "task": task,
            "task_form": edit_form.render()
        })
Esempio n. 16
0
 def create(self):
     password = request.POST.pop('password')
     password_conf = request.POST.pop('password2')
     create_form = user_form.bind(User, data=request.POST)
     if request.POST and create_form.validate():
         user_dict = {
             'firstname': create_form.firstname.value,
             'lastname': create_form.lastname.value,
             'username': create_form.username.value.strip(),
             'email': create_form.email.value.strip(),
         }
         if password == password_conf:
             user_dict['password'] = password
             user = User(**user_dict)
             Session.add(user)
             Session.commit()
             session['user'] = {'id': user.id, 'name': '%s %s' % (user.firstname, user.lastname)}
             session.save()
             return redirect('/projects')
         else:
             session['flash'] = 'Passwords did not match'
             session.save()
     return render('users/new.html', {'user_form': create_form.render()})
Esempio n. 17
0
    def create(self):
        create_form = task_form.bind(Task, data=request.params)

        if request.POST and create_form.validate():
            task_args = {
                "task": create_form.task.value,
                "tasklist_id": request.params["tasklist_id"], #create_form.tasklist_id.value,
                "project_id": request.params["project_id"], #create_form.project_id.value,
                "user_id": 1, # TODO fix this
                "assigned_to": create_form.assigned_to.value,
                "deadline": create_form.deadline.value
            }
            task = Task(**task_args)
            Session.add(task)
            Session.commit()
            return redirect("/projects/show/%s" % task_args["project_id"])

        context = {
        }
        return render("tasks/new.html", {
            "task_form": create_form.render(),
            "tasklist_id": request.params["tasklist"],
            "project_id": request.params["project"],
        })
Esempio n. 18
0
 def find(self):
     users = Session.query(User).filter(User.username.like(request.params['q']+'%')).all()
     for user in users:
         yield user.username
Esempio n. 19
0
log = logging.getLogger(__name__)

class DatePickerFieldRenderer(FieldRenderer):
    def render(self):
        value = self.value and self.value or ''
        vars = dict(name=self.name, value=value)
        return """
            <input id="%(name)s" class="widthAuto" name="%(name)s" type="text" value="%(value)s" />
        """ % vars

task_form = FieldSet(Task)
task_form.configure(include=[
    task_form.task.textarea(),
    task_form.assigned_to.dropdown(
        options=[(user.username, user.id) for user in Session.query(User).all()]
    ).required(),
    task_form.deadline.with_renderer(DatePickerFieldRenderer),
    #task_form.tasklist_id,
    #task_form.project_id.hidden(),
])

class TasksController(BaseController):

    def __before__(self, action, **params):
        filter_actions = ["new", "edit", "create", "update", "delete"]
        if "user" not in session and action in filter_actions:
            redirect("/users/login")


    def new(self):
Esempio n. 20
0
 def delete(self, id):
     try:
         note = Session.query(Note).filter_by(id=id).delete()
     except:
         abort(404)
     return redirect("/Notes")
Esempio n. 21
0
 def users(self, id):
     try:
         project = Session.query(Project).filter_by(id=id).one()
     except:
         abort(404)
     return render("projects/users.html", {"project": project})
Esempio n. 22
0
 def index(self):
     projects = Session.query(Project).all()
     return render("projects/index.html", {"projects": projects})