def test_tasks(self):
     s = Supplier()
     s.name = 'Joe'
     s.save()
     
     p = Property()
     p.save()
     l = Location(property = p)
     l.save()
     a = Asset(location = l)
     a.save()         
     t = Task(asset = a)
     t.name = 'Mop floors'
     t.frequency = 1
     t.save()
      
     q = Quote(supplier = s)
     q.amount = 4
     q.save()
     
     self.assertEqual(0, len(q.tasks.all()))
     
     q.tasks.add(t)
     self.assertEqual(1, len(q.tasks.all()))
       
     self.assertEqual
     self.assertEqual("$4.00 to Mop floors (Joe)", str(q))

def create(request):
    if request.method == 'POST':
        form = NewTaskForm(request.POST)
        if form.is_valid():
            data = form.cleaned_data
            if len(data['title']) > 500:
                return returnErrors(request, 'Task title too long')
            
            elif len(data['description']) > 5000:
                return returnErrors(request, 'Task description too long')
            
            else:
                # makes a task with the submitted information and the current user
                task = Task(owner=request.user, title=data['title'], description=data['description'])
                task.save()
    
                # adds collaborators 1, 2 and 3 by finding the user associated with the submitted email
                for x in range(1, 4):
                    if User.objects.filter(username=data['collaborator' + str(x)]).exists():
                        task.collaborators.add(User.objects.get(username=data['collaborator' + str(x)]))
        
        else:
            return returnErrors(request, 'Fill out all task information')
            
    return HttpResponseRedirect('/')

def create_task(request):
    
    created_by = request.user
    assignable_users = User.objects.filter(is_active=True).order_by(User.USERNAME_FIELD)

    if request.method == 'POST':
        title = request.POST.get('task')
        submitter_mail = request.POST.get('submitter_mail')
        status = request.POST.get('status')
        priority = request.POST.get('priority')
        project_agreement = request.POST.get('project_agreement')
        table = request.POST.get('table')
        due_date = datetime.strptime(request.POST.get('due_date'), "%Y-%m-%d")
        created_date = datetime.strptime(request.POST.get('created_date'),"%Y-%m-%d")
        created_by = request.POST.get('created_by')
        assigned_to = request.POST.get('assigned_to')
        note = request.POST.get('note')

        task = Task(task=title, submitter_email=submitter_mail, status=status, priority=priority, 
            due_date=due_date, created_date=created_date,created_by_id=created_by, assigned_to_id=assigned_to, 
            project_agreement=project_agreement, table=table, note=note)
        task.save()
    form = form_data(request)

    tasks = Task.objects.all()
    return render_to_response('tasks/task_index.html',
        RequestContext(request, {
        	'tasks':Task.objects.all().order_by('created_date').reverse,
            'assignable_users': assignable_users,
            'created_by': created_by,
            'form': form
            
        }))

def assign_tasks(review_milestone, reviewer, routing_algorithm='random', tasks_to_assign=None, simulate=False, chunk_id_task_map={}):
	# if tasks_to_assign == None, set tasks_to_assign equal to number required by the milestone for the reviewer's role
	if tasks_to_assign == None:
		tasks_to_assign = get_num_tasks_for_user(review_milestone, reviewer, simulate=simulate)
	reviewer_role = None
	if simulate:
		reviewer_role = reviewer['membership__role']
	else:
		reviewer_role = reviewer.membership.get(semester=review_milestone.assignment.semester).role
	# get all the chunks that the reviewer can review in the order they should be assigned
	reviewable_chunks = get_reviewable_chunks(review_milestone, reviewer, reviewer_role, simulate=simulate, chunk_id_task_map=chunk_id_task_map)
	chunks_to_assign = apply_routing_algorithm(reviewable_chunks, tasks_to_assign, routing_algorithm=routing_algorithm)
	# if len(chunks_to_assign) < num_tasks_for_user, the reviewer will be assigned fewer
	# tasks than they should be and they will be assigned more tasks the next time they
	# log in if there are more tasks they can be assigned

	# create and save tasks if it's NOT a simulation
	if not simulate:
		# create tasks for the chunks in chunks_to_assign and save them
		for chunk in chunks_to_assign:
			# create a ChunkReview if one doesn't already exist
			chunk_review, created = ChunkReview.objects.get_or_create(chunk=chunk)
			# update the ChunkReview
			if reviewer_role == Member.STUDENT or reviewer_role == Member.VOLUNTEER:
				chunk_review.student_or_alum_reviewers += 1
			elif reviewer_role == Member.TEACHER:
				chunk_review.staff_reviewers += 1
			chunk_review.save()
			# create a task
			task = Task(reviewer=reviewer, chunk=chunk, milestone=review_milestone, submission=chunk.file.submission, chunk_review=chunk_review)
			task.save()
	return len(chunks_to_assign)

    def test_missing_contacts(self):
        person = models.Person(
            legal_name = "Test Person",
            slug       = 'test-person'
        )
        person.save()
        
        self.assertItemsEqual(
            [ i.category.slug for i in Task.objects_for(person) ],
            ['find-missing-phone', 'find-missing-email', 'find-missing-address'],
        )

        # add a phone number and check that the tasks get updated
        phone = models.ContactKind(
            slug='phone', name='Phone',
        )
        phone.save()

        contact = models.Contact(
            content_type = ContentType.objects.get_for_model(person),
            object_id    = person.id,
            kind         = phone,
            value        = '07891 234 567',
        )
        contact.save()

        self.assertItemsEqual(
            [ i.category.slug for i in Task.objects_for(person) ],
            ['find-missing-email', 'find-missing-address'],
        )

 def test_frequency_object(self):
     """
     Ensure that the .frequency setter works with Frequency objects, too.
     """
     t = Task()
     for value in [0, 1, 6, 12]:
         t.frequency = Frequency(value)
         self.assertEqual(value, t._frequency)

 def setUp(self):
     self.tasks_url = reverse('tasks')
     self.user = User.objects.create(username='user',
                                     email='[email protected]',
                                     is_staff=True, is_active=True)
     task = Task(title='task-1', description='description-of-task-1',
                 created_by=self.user)
     task.save()

	def handle(self, *args, **options):
		Task.objects.all().delete()
		for i in range(100):
			task = Task()
			task.title = 'Task-%d'%i
			task.text = 'Text %d'%i
			task.save()

				

 def post(request):
     task = request.POST.get('task')
     new = Task()
     new.name = task
     new.status = Status.objects.get(name='New')
     new.save()
     response = HttpResponse()
     response.status_code = 201
     return response

def add_project_task(request,slug):
    if request.user.is_authenticated():
        project = Project.objects.get(slug = slug)
        if request.POST:
            form = TaskForm(request.POST)
            if form.is_valid():
                data = form.cleaned_data
                td = data['end_date'] - data['start_date']
                if td.total_seconds()>0:
                    task = Task()
                    task.name = data['name']
                    task.description = data['description']
                    task.start_date = data['start_date']
                    task.end_date = data['end_date']
                    task.user = data['user']
                    task.project = project
                    task.save()
                else:
                    messages.add_message(request, messages.ERROR,
                        " end date is less than start date!")
                    return (redirect(reverse('Task:add_task')))
                return (redirect(reverse('Home:manager')))
            else:
                messages.add_message(request, messages.ERROR, 
                    "invalid form")
                return (redirect(reverse('Task:add_task')))
        else:
            form = TaskForm()
            send_dict={}
            context_instance=RequestContext(request)
            send_dict['project'] = project
            send_dict['form'] = form
            return render_to_response('tasks/add_task.html',send_dict,context_instance)
    else:
        return redirect(reverse('Login:login'))

def create_analysis_tasks(analysis_id):
    print('analysis_id', analysis_id)
    # samples = []
    # print('hello!')
    #create analysis tasks
    # analysis = Analysis.objects.()
    analysis = Analysis.objects.get(pk=analysis_id)
    print(dir(analysis))
    params = analysis.params
    files = params['files']
    for file in files:
        task = Task(user=analysis.user)
        task.manifest = {}
        task.manifest['files'] = [file]
        task.manifest['analysis_types'] = params['analysis_types']
        task.status = 'new'
        task.analysis = analysis
        task.action = 'analysis'
        task.save()
        analysis.tasks.add(task)

    # if 'sample_groups' in  params:
    #     samples = Sample.objects.filter(samplegroup_members__in=params['sample_groups'])
    #     # sample = Sample.objects.first()
    #     # print(dir(sample))
    # for sample in samples:      
    #     print(sample)
    #     for file in sample.files.all():
    #         bam_size = 9223372036854775807
    #         if file.extension == 'bam':
    #             if file.size < bam_size:
    #                 bamfile = file
    #                 bam_size = file.size
    #     print('small bam', bamfile.size)
    # get smallest bam file

	def update(self, pk):
		try:
			task = Task.objects.get(pk=pk)
		except Task.DoesNotExist:
			task = Task()

		task.title = self.data['title']
		task.description = self.data['description']
		task.save()

		return task

def add_task(request, group, meeting):
    """
    Adds a task to a minutes item.
    """
    item_number = request.POST['ajax_button'][9:]
    item_number = int(item_number)
    predecessors = Task.objects.filter(item_id=item_number)
    no_of_precessors = predecessors.count()
    new_task_number = no_of_precessors + 1
    new_task = Task(item_id=int(item_number), group=group, meeting=meeting,
                    task_no=new_task_number, status = 'Draft')
    new_task.save(group)

def task_set_view(request, pk):  # zobrazenie sady ako zoznam
    task_set = get_object_or_404(TaskSet, pk=pk)

    if not TaskSet.can_see(task_set, request.user):
        raise Http404

    # vytvori sa alebo updatne aktualna sada
    act = Active.objects.get_or_create(user=request.user)
    a = act[0]
    a.task_set = task_set
    a.save()

    # zoznam uloh v sade; iba tie, ktorym moze vidiet zadania v zozname
    q = Task.objects.filter(task_set=task_set)
    q_ids = [o.id for o in q if Task.can_see(o, request.user, "t")]
    tasks = q.filter(id__in=q_ids)

    # zoznam sad do horneho menu; iba tie, ktore user moze vidiet
    q = TaskSet.objects.order_by("title")
    q_ids = [o.id for o in q if TaskSet.can_see(o, request.user)]
    sets = q.filter(id__in=q_ids)

    # roztriedenie uloh na kategorie (ci su vyriesene/precitane)
    # v tomto poradi sa mu aj zobrazuju
    task_cat = []
    task_cat.append({"tasks": [], "type": "act_sub"})  # 0
    task_cat.append({"tasks": [], "type": "act_read"})  # 1
    task_cat.append({"tasks": [], "type": "sol_sub"})  # 2
    task_cat.append({"tasks": [], "type": "sol_read"})  # 3
    for task in tasks:
        if Task.is_solved(task, request.user):
            if task.type == Task.SUBMIT:
                task_cat[2]["tasks"].append(task)
            elif task.type == Task.READ:
                task_cat[3]["tasks"].append(task)
        elif Task.is_enabled(task, request.user):
            if task.type == Task.SUBMIT:
                task_cat[0]["tasks"].append(task)
            elif task.type == Task.READ:
                task_cat[1]["tasks"].append(task)

    return render_to_response(
        "tasks/task_set.html",
        {
            "active_app": "tasks",  # kvoli havnemu menu
            "task_set": task_set,  # aktualna sada
            "sets": sets,  # viditelne sady v taboch
            "style": "list",  # styl zobrazovania sady
            "categories": task_cat,  # ulohy podla kategorii
            "tasks": tasks,  # danej sady
        },
        context_instance=RequestContext(request),
    )

def import_tasks(request):
	""" View in the admin """
	if request.method == 'POST': 
		form = ImportForm(request.POST, request.FILES)
		if form.is_valid(): 
			try:
				Task.import_Tasks(form.files['file'], request.user)
                                messages.success(request, "The import was successfull.")
				return HttpResponseRedirect(urlresolvers.reverse('admin:tasks_task_changelist'))
			except Exception, e:
				from django.forms.utils import ErrorList
                                msg = "An Error occured. The import file was propably malformed.: %s" % str(e)
				form._errors["file"] = ErrorList([msg]) 			

def create_task(task_title, user):
    """
    Creates the task with the `task_title` and assigns the `user` to
    `assigned_users` if `assigned_users` is empty.
    """
    task = Task()
    task.save_from_re(task_title)

    # If user was not yet assigned use the email user.
    if len(task.assigned_users.all()) == 0:
        task.assigned_users.add(user)

    return task

def addTask(request):
    if request.method == 'POST':
        form = AddTask(request.POST)
        if form.is_valid():
            name = request.POST.get('name', '')
            description = request.POST.get('description', '')
            date = request.POST.get('date', '')
            completed = request.POST.get('completed', False)
            task = Task(name=name, description=description, date=date, completed=completed)
            task.save()
            return render(request, 'app/thanks.html', {'title':'Thanks', 'year':datetime.now().year, 'message': 'task added',})
    else:
        form = AddTask()
    return render(request, 'app/addtask.html', {'form': form, 'title':'AddTask', 'year':datetime.now().year, 'massage': 'addtask',})

 def test_frequency(self):
     t = Task()
     tests = {
          0: "once",
          1: "every month",
          2: "every 2 months",
          12: "every year",
          13: "every 13 months",
          24: "every 2 years"
     }
     
     for value, expected in tests.items():
         t.frequency = value
         self.assertEqual(expected, str(t.frequency))

def task_view(request, pk):  # zadanie ulohy
    task = get_object_or_404(Task, pk=pk)

    if not Task.can_see(task, request.user, 't'):
        raise Http404

    # vytvorime alebo updatneme aktivnu ulohu
    act = Active.objects.get_or_create(user=request.user)
    if task.type == task.SUBMIT:
        a = act[0]
        a.task = task
        a.save()

    # ak sa submitovalo
    error = False
    if request.method == 'POST':
        form = TaskSubmitForm(request.POST, request.FILES)
        if form.is_valid():
            submit_id = helpers.process_submit(
                request.FILES['submit_file'],
                task,
                form.cleaned_data['language'],
                request.user)
            if submit_id[0]:
                return HttpResponseRedirect(reverse('submit:protocol', args=(submit_id[1],)) + '#protocol')
            else:
                error = submit_id[1]
        else:
            error = 'file-error'

    # pridame seen
    stalker = Stalker(user=request.user, task=task, seen=datetime.now())
    stalker.save()

    form = TaskSubmitForm()
    submits = Submit.objects.filter(task=pk, user=request.user).order_by('-timestamp')
    is_solved = Task.is_solved(task, request.user)

    return render(request, 'tasks/task.html',
                  {
                      'active_app': 'tasks',  # hlavne menu
                      'active': 'text',  # ci si pozerame zadanie alebo vzorak
                      'is_solved': is_solved,  # kvoli linku v taboch
                      'task': task,
                      'form': form,  # submitovaci formular
                      'submits': submits,  # doterajsie submity v ulohe
                      'error': error,  # chyba suboru / nepodarene pripojenie na testovac
                      'req_user': request.user,  # momentalne lognuty (kvoli odkazu na riesenie pre adminov)
                  },
                  )

def task_set_graph_view(request, pk=False):  # zobrazenie sady ako graf

    # ak sme nespecifikovali sadu (menu->Ulohy), zobrazi sa/vytvori sa aktivna
    if not pk:
        act = Active.objects.get_or_create(user=request.user)
        pk = act[0].task_set.id

    task_set = get_object_or_404(TaskSet, pk=pk)

    if not TaskSet.can_see(task_set, request.user):
        raise Http404

    # vytvori sa alebo updatne aktualna sada
    act = Active.objects.get_or_create(user=request.user)
    a = act[0]
    a.task_set = task_set
    a.save()

    # zoznam uloh v sade; iba tie, o ktorych moze vediet
    q = Task.objects.filter(task_set=task_set)
    q_ids = [o.id for o in q if Task.can_see(o, request.user, "g")]
    tasks = q.filter(id__in=q_ids)

    # zoznam sad do horneho menu; iba tie, ktore user moze vidiet
    q = TaskSet.objects.order_by("title")
    q_ids = [o.id for o in q if TaskSet.can_see(o, request.user)]
    sets = q.filter(id__in=q_ids)

    # roztriedime kvoli vykreslovaniu v grafe
    solved_tasks = []
    actual_tasks = []
    invis_tasks = []
    for task in tasks:
        if Task.is_solved(task, request.user):
            solved_tasks.append(task)
        elif Task.is_enabled(task, request.user):
            actual_tasks.append(task)
        else:
            invis_tasks.append(task)

    return render_to_response(
        "tasks/task_set_graph.html",
        {
            "active_app": "tasks",  # hlavne menu
            "task_set": task_set,  # aktualna sada
            "sets": sets,  # vsetky sady
            "style": "graph",  # styl zobrazovania sady
        },
        context_instance=RequestContext(request),
    )