def main(request, rest_of_address):
	address = Address(rest_of_address)
	#import pdb; pdb.set_trace()
	if not address.folder:
		return render_to_response('documents_folders/error.html', {'error':'no_folder', 'current_folder_path': address.folder_path})
	if address.file_path and not address.file:
		return render_to_response('documents_folders/error.html', {'error':'no_file', 'current_folder': address.folder_path, 'open_file':address.file_path})
	if 'submit_comment' in request.POST: 
		add_comment(request, address)
	#Create new folder
	if 'file' in request.FILES:
		upload_file(request, address.folder.id)
	if 'new_folder_name' in request.POST:
		folder_name = str(request.POST.get('new_folder_name'))
		if folder_name.strip():
			p = Folder(name = folder_name, parent_folder = address.folder.id, folder_path = address.folder_path+'/'+folder_name)
			p.save()
	#Remove folder and all sub-folders of that folder
	for folder_id in [a for a, b in request.POST.iteritems() if b == 'Delete']:
		remove_folder(folder_id)
	sub_folders = Folder.objects.filter(parent_folder=address.folder.id)
	sub_files = File.objects.filter(parent_folder = address.folder.id)
	relevant_comments = Comment.objects.filter(attached_to_type = address.type, attached_to_id = address.id)
	try:
		parent_folder = Folder.objects.get(id = address.folder.parent_folder)
	except:
		parent_folder = None
	return render_to_response('documents_folders/blah.html', {'relevant_comments':relevant_comments, 'sub_folders': sub_folders, 'current_folder_path': address.folder.folder_path, 'parent_folder': parent_folder, 'sub_files':sub_files, 'open_file':address.file_path, 'current_path': '/documents/'+rest_of_address}, context_instance=RequestContext(request))

 def test_model_folder(self):
     """Test Folder Model"""
     obj = Folder(name='test')
     obj.save()
     self.assertEquals('test', obj.name)
     self.assertNotEquals(obj.id, None)
     obj.delete()

def create_vin(request):
	topics = ['NBA']
	for fld in topics:
		logging.info('Entra en bucle para %s' % fld)
		directory = "media/%s" % fld
		root = Folder.create(fld,request.user.profile,None,'/media/example_folder.png')
		root.save()
		for serie in os.listdir(directory):
			logging.info('Entra en bucle series para %s' % serie)
			if not serie.startswith('.'):
				s = Folder.create(serie,request.user.profile,root,None)
				s.pic = None #TODO revisar codigo inutil
				for season in os.listdir(directory+'/'+serie):
					if not season.startswith('.'):
						if fld == 'NBA':
							pic = '/media/example_folder.png'
						else:
							pic = '/'+directory+'/'+serie+'/'+season+'/season.jpeg'
						if s.pic == None:
							s.pic = pic
							s.save()
						ss = Folder.create(season,request.user.profile,s,pic)
						ss.save()
						for episode in os.listdir(directory+'/'+serie+'/'+season+'/'):
							if not episode.startswith('.') and '.jpeg' not in episode:
								# if fld == 'NBA':
								# 	pic = '/media/example_folder.png'
								# else:
								# 	pic = '/'+directory+'/'+serie+'/'+season+'/season.jpeg'
								url = open(directory+'/'+serie+'/'+season+'/'+episode,'r').readline()
								if url.__len__ > 0:
									c = Card.create(episode,url,ss)
									if fld == 'NBA':
										c.pic = fld+'/'+serie+'/'+season +'/'+ episode+'.jpeg'
									c.save()

    def test_get(self):
        """A logged in user ask to move a valid favorite."""
        godzilla = self.user('godzilla')
        self.client.login(username='godzilla', password='godzilla')
        dummy = DummyModel()
        dummy.save()
        favorite = Favorite.objects.create_favorite(dummy, godzilla)
        folders = []
        for i in range(10):
            folder = Folder(name="folder-%s" % i, user=godzilla)
            folder.save()
            folders.append(folder)
        target_url = reverse('favorites:favorite_move',
                             kwargs = {
    'object_id': favorite.pk,
})
        response = self.client.get(target_url)
        self.assertEquals(response.status_code, 200)

        instance = response.context['favorite']
        self.assertEquals(instance.pk, favorite.pk)
        favorite.delete()
        godzilla.delete()
        for folder in folders:
            folder.delete()
        dummy.delete()

def folders(request):
    folders = Folder.objects.filter(user=request.user)
    context = {'folders':folders}
    if request.method == 'POST':
        # changing to a different folder
        if "change_folder" in request.POST:
            request.session['notes_folder'] = request.POST['folder']
            # If we are changing folders we don't 
            # want to keep to what page we were on in
            # the other folder.
            if 'page' in request.session:
                del request.session['page']
            return redirect('cloud_notes.views.list')
        if "create_folder" in request.POST:
            form = NewFolderForm(request.POST)
            if form.is_valid():
                folder_name = form.cleaned_data['folder']
                folder = Folder(name = folder_name)
                folder.save()
                return redirect('cloud_notes.views.list')
            else:
                context['form'] = form
                return render(request, 'cloud_notes/folders.html', context)
    else:
        return render(request, 'cloud_notes/folders.html', context)

def folder_add_typed(request, folder_id=None, response_format='html'):
    "Folder add to preselected folder"

    folder = None
    if folder_id:
        folder = get_object_or_404(Folder, pk=folder_id)
        if not request.user.profile.has_permission(folder, mode='x'):
            folder = None

    if request.POST:
        if 'cancel' not in request.POST:
            folder = Folder()
            form = FolderForm(
                request.user.profile, folder_id, request.POST, instance=folder)
            if form.is_valid():
                folder = form.save()
                folder.set_user_from_request(request)
                return HttpResponseRedirect(reverse('documents_folder_view', args=[folder.id]))
        else:
            return HttpResponseRedirect(reverse('document_index'))
    else:
        form = FolderForm(request.user.profile, folder_id)

    context = _get_default_context(request)
    context.update({'form': form,
                    'folder': folder})

    return render_to_response('documents/folder_add_typed', context,
                              context_instance=RequestContext(request),
                              response_format=response_format)

 def post(self):
     user = get_user_from_id(session['user_id'])
     name = request.json['name']
     new_folder = Folder(name=name)
     new_folder.user_id = user.id
     db.session.add(new_folder)
     db.session.commit()
     return {'folder': new_folder.as_json()}, 201

def handle_uploaded_json_file(f, user):
    
    def convert_date(str_date):
        new_str = str_date.replace('+00:00','')
        try:
            new_dt = datetime.strptime(new_str, '%Y-%m-%d %H:%M:%S.%f')
        except ValueError:
            new_dt = datetime.strptime(new_str, '%Y-%m-%d %H:%M:%S')
        return new_dt
    
    with open('notes.json', 'wb+') as destination:
        for chunk in f.chunks():
            destination.write(chunk)
        f.close()
    with open('notes.json', 'r') as fh:
        json_data = json.load(fh)
        fh.close()
    
    version, notes = json_data
    
    # for user in User.objects.all():
        # if not Folder.)objects.filter(user = user, name = "Main").exists():
            # folder = Folder(name="Main", user = user)
            # folder.save()
        # if not Folder.objects.filter(user = user, name = ")Trash").exists():
            # folder = Folder(name="Trash", user = u)ser)
            # folder.save()  
          
    for note in notes:
        created_at = convert_date(note['created_at'])
        title = note['title']
        username = note['user']

        # TODO: If user is blank we need to assign to a default user.  For now just skip.
        # Its technically a database integrity violation anyway.
        if username is None: continue

        user = User.objects.get(username = username)        

        if not Note.objects.filter(title = title, 
                               created_at = created_at).exists():
            new_note = Note()
            new_note.title =  title
            new_note.created_at = created_at
            new_note.modified_at = convert_date(note['modified_at'])
            new_note.note_type = note['post_type'] 
            new_note.note = note['note']
            foldr = note['folder']
            
            
            try:
                folder = Folder.objects.get(name = foldr, user = user)
            except Folder.DoesNotExist:
                folder = Folder(name = foldr, user = user)
                folder.save()
            new_note.folder = folder
            new_note.user = user
            new_note.save()

 def test_model_document(self):
     """Test Document Model"""
     folder = Folder(name='test')
     folder.save()
     obj = Document(title='test', folder=folder)
     obj.save()
     self.assertEquals(folder, obj.folder)
     self.assertNotEquals(obj.id, None)
     obj.delete()

 def test_login_required(self):
     """User should be logged it to delete an object."""
     godzilla = self.user('godzilla')
     folder = Folder(name='japan', user=godzilla)
     folder.save()
     response = self.client.get(reverse('favorites:folder_update', args=(folder.pk,)))
     self.assertEquals(response.status_code, 302)
     folder.delete()
     godzilla.delete()

    def RPC__Folder__getRoot(self):
        """Return the main folder for the current user ("My folders"). """
        try:
            folder = Folder.objects.get(user=self.user, parent=None)
        except Folder.DoesNotExist:
            folder = Folder(user=self.user, name="My folders")
            folder.save()

        self.return_api_result({'uuid': folder.uuid, 'name': folder.name})

 def test_model_weblink(self):
     """Test WebLink Model"""
     folder = Folder(name='test')
     folder.save()
     obj = WebLink(title='test', folder=folder, url='test')
     obj.save()
     self.assertEquals(folder, obj.folder)
     self.assertNotEquals(obj.id, None)
     obj.delete()

 def test_model_file(self):
     """Test File Model"""
     folder = Folder(name='test')
     folder.save()
     obj = File(name='test', folder=folder)
     obj.save()
     self.assertEquals(folder, obj.folder)
     self.assertNotEquals(obj.id, None)
     obj.delete()

 def test_post(self):
     """Submit a delete form with good credentials. Returns a redirect."""
     godzilla = self.user('godzilla')
     folder = Folder(name='japan', user=godzilla)
     folder.save()
     self.client.login(username='godzilla', password='godzilla')
     response = self.client.post(reverse('favorites:folder_delete', args=(folder.pk,)), {'object_id': folder.pk})
     self.assertEquals(response.status_code, 302)
     self.assertEquals(Folder.objects.filter(user=godzilla).count(), 0)
     godzilla.delete()

def create_folder(user, folder_name):
    """
    Args:
        user: django.contrib.auth.models.User
    returns:
        models.Folder
    """
    f = Folder(name=folder_name, user=user, times_used=0)
    f.save()
    return f

def create_folder(request, internal=False):
    folder_form = FolderForm(request.POST or None)
    if folder_form is not None and folder_form.is_valid():
        title = folder_form.cleaned_data['title']
        owner = Searcher.objects.filter(user_profile=request.user)[0]
        new_folder = Folder(title=title, owner=owner)
        new_folder.save()
    else:
        print "error"
    if internal:
        return new_folder

 def test_invalid_permission(self):
     """Try to delete a folder owned by someone else. Returns a 403."""
     godzilla = self.user('godzilla')
     folder = Folder(name='japan', user=godzilla)
     folder.save()
     leviathan = self.user('leviathan')
     self.client.login(username='leviathan', password='leviathan')
     response = self.client.post(reverse('favorites:folder_delete', args=(folder.pk,)), {'object_id': folder.pk})
     self.assertEquals(response.status_code, 403)
     godzilla.delete()
     leviathan.delete()

 def test_invalid_permission_on_favorite(self):
     """User should own the folder to delete it. Returns a 403."""
     godzilla = self.user('godzilla')
     leviathan = self.user('leviathan')
     self.client.login(username='godzilla', password='godzilla')
     folder = Folder(name='japan', user=leviathan)
     folder.save()
     response = self.client.get(reverse('favorites:folder_update', args=(folder.pk,)))
     self.assertEquals(response.status_code, 403)
     godzilla.delete()
     leviathan.delete()
     folder.delete()

    def RPC__Folder__create(self, name, uuid=None):
        """Create a new folder and add it to a parent with the given ``uuid``. """
        try:
            if uuid is not None:
                parent = Folder.objects.get(user=self.user, uuid=uuid)
            else:
                parent = None
        except Folder.DoesNotExist:
            self.return_api_error('does-not-exist')
        else:
            folder = Folder(user=self.user, parent=parent, name=name)
            folder.save()

            self.return_api_result({'uuid': folder.uuid})

def folders():
    if request.method == 'POST':
        req = request.get_json()
        try:
            f = Folder.create(name=req['name'])
            f.save()
            return jsonify(message='OK'), 201
        except peewee.IntegrityError as e:
            print e
            return jsonify(message='error'), 409

    if request.method == 'GET':
        folders = Folder.select()
        items = [x.name for x in folders]
        return jsonify(message='OK', items=items)