def _process_restfood_account_information(userprofile,request,account_template):
    password = _request_param_post(request, 'password')
    mobile = _request_param_post(request, 'mobile')
    office_place = _request_param_post(request, 'office_place')
    office_landmark = _request_param_post(request, 'office_landmark')
    office_area = _request_param_post(request, 'office_area')
    office_zip = _request_param_post(request, 'office_zip')
    from users.forms import AccountForm
    accountform = AccountForm({'mobile':mobile,'password':password,
                               'home_place':userprofile.source.place,'home_landmark':userprofile.source.landmark,'home_area':userprofile.source.area,'home_zip':userprofile.source.zip,
                               'office_place':office_place,'office_landmark':office_landmark,'office_area':office_area,'office_zip':office_zip})
    if not accountform.is_valid():
        _add_errormsg(request, 'Please valid information in all the required fields')
        return response(account_template,locals(),request)
    password = accountform.cleaned_data.get('password')
    print 'password:%s' % password
    userprofile.set_password(password)
    print 'password reset done'
    mobile = accountform.cleaned_data.get('mobile')
    userprofile.mobile = mobile
    userprofile.save()
    office_place = accountform.cleaned_data.get('office_place')
    office_landmark = accountform.cleaned_data.get('office_landmark')
    office_area = accountform.cleaned_data.get('office_area')
    office_zip = accountform.cleaned_data.get('office_zip')
    userprofile.set_destination_address(destination_place=office_place,destination_area=office_area,destination_landmark=office_landmark,destination_zip=office_zip)
    _add_successmsg(request, 'Account Information saved Successfully')
    return response(account_template,locals(),request)

def view_edit_achievement(request, achievement_id, edit_achievement_template):
    userprofile = loggedin_userprofile(request)
    achievement = get_object_or_404(Achievement, id=int(achievement_id))
    if userprofile.is_my_achievement(achievement):
        achievements = list(userprofile.achievements)
        for achievment_info in achievements:
            if achievment_info['id'] == int(achievement_id):
                achievements.remove({'title':achievement.title,
                                        'id':int(achievement_id),
                                        'description':achievement.description})
                break
        if request.method == 'GET':
            form = AddAchievementForm({'title':achievement.title,
                                       'description':achievement.description})
            return response(request, edit_achievement_template, {'achievement':achievement,
                                                                 'form':form,
                                                                 'previous_achievements':achievements})
        form = AddAchievementForm(post_data(request))
        if form.is_valid():
            achievement.update(title=form.cleaned_data.get('title'),
                               description=form.cleaned_data.get('description'),)
            from users.messages import ACHIEVEMENT_UPDATED_SUCCESSFULLY
            messages.success(request, ACHIEVEMENT_UPDATED_SUCCESSFULLY)
            return HttpResponseRedirect(redirect_to=url_reverse('users.views.view_all_achievements'))
        return response(request, edit_achievement_template, {'achievement':achievement,
                                                             'form':form,
                                                             'previous_achievements':achievements})
    raise Http404

def view_login(request, login_template, next=''):
    from users.forms import UserLoginForm
    if request.method == 'POST':
        data = post_data(request)
        next = data.get('next') if not next else next 
        form = UserLoginForm(data)
        if form.is_valid():
            try:
                userprofile = UserProfile.objects.get(user__email=form.cleaned_data.get('email'), user__is_active=True)
            except UserProfile.DoesNotExist:
                from users.messages import USER_LOGIN_FAILURE
                messages.error(request, USER_LOGIN_FAILURE)
                return response(request, login_template, {'form': form, 'next': next})
            if not userprofile.check_password(form.cleaned_data.get('password')):
                from users.messages import USER_LOGIN_FAILURE
                messages.error(request, USER_LOGIN_FAILURE)
                return response(request, login_template, {'form': form, 'next': next})
            from users.messages import USER_LOGIN_SUCCESSFUL
            messages.success(request, USER_LOGIN_SUCCESSFUL)
            return _let_user_login(request,
                                   userprofile.user,
                                   email=form.cleaned_data.get('email'),
                                   password=form.cleaned_data.get('password'),
                                   next=next)
    else:
        form = UserLoginForm()
    return response(request, login_template, {'form': form, 'next': next})

def view_reset_my_password(request, reset_my_password_template):
    if request.method == 'GET':
        if request.GET.has_key('email') and request.GET.has_key('hash_key'):
            email = request.GET.get('email')
            userprofile = get_object_or_404(UserProfile, user__email=email)
            retrieved_hash_key = request.GET.get('hash_key')
            from django.contrib.auth.models import get_hexdigest
            computed_hash_key = get_hexdigest('md5', '', email)
            if retrieved_hash_key == computed_hash_key:
                form = ResetMyPasswordForm()
                return response(request, reset_my_password_template, {'form':form,
                                                                      'email':email})
            from users.messages import INVALID_PASSWORD_RESET_HASH_KEY
            messages.error(request, INVALID_PASSWORD_RESET_HASH_KEY)
            return HttpResponseRedirect(redirect_to='/')
        else:
            raise Http404
    else:
        data = post_data(request)
        form = ResetMyPasswordForm(data)
        if form.is_valid():
            email = data.get('email')
            userprofile = get_object_or_404(UserProfile, user__email=email)
            password = form.cleaned_data.get('password')
            userprofile.set_password(password)
            from users.messages import PASSWORD_RESET_SUCCESSFULLY
            messages.success(request, PASSWORD_RESET_SUCCESSFULLY)
            return _let_user_login(request,
                                   userprofile.user,
                                   email=email,
                                   password=password)
        return response(request, reset_my_password_template, {'form':form,
                                                              'email':data.get('email')})

def view_modify_snippet(request, snippet_id, snippet_slug, modify_snippet_template, snippet_profile_template):
    modify = True
    from quest.forms import AddSnippetForm
    if request.method == 'POST':
        form = AddSnippetForm(post_data(request))
        existing_snippet = Snippet.objects.get(id=snippet_id)
        if form.is_valid():
            updated_snippet = _handle_snippet_updation(form, existing_snippet)
            from quest.messages import SNIPPET_UPDATION_SUCCESSFUL
            django_messages_framework.success(request, SNIPPET_UPDATION_SUCCESSFUL)
            return response(request, snippet_profile_template, {'snippet': updated_snippet,
                                                                'owner': True})
        return response(request, modify_snippet_template, {'form': form})
    else:
        snippet = Snippet.objects.get(id=snippet_id)
        form_data = {'title':snippet.title,
                     'explanation':snippet.explanation,
                     'code':snippet.code,
                     'public':snippet.public,
                     'lang':snippet.lang,
                     'tags':" ".join([tag.name for tag in snippet.tags()])}
        form = AddSnippetForm(form_data)
        return response(request, modify_snippet_template, {'form':form,
                                                           'snippet': snippet,
                                                           'modify':modify})

def view_edit_question(request, question_id, question_slug, edit_question_template):
    userprofile = loggedin_userprofile(request)
    question = get_object_or_404(Question, id=int(question_id))
    if userprofile.is_my_question(question):
        asked_questions = list(userprofile.asked_questions)
        for question_info in asked_questions:
            if question_info['id'] == int(question_id):
                asked_questions.remove({'title':question.title,
                                        'id':int(question_id),
                                        'slug':question_slug})
        
        if request.method == 'GET':
            question_data = {'title':question.title,
                             'description':question.description,
                             'tags':",".join([tag['name'] for tag in question.tags.values('name')])}
            form = AskQuestionForm(question_data)
            return response(request, edit_question_template, {'form':form,
                                                              'question':question,
                                                              'previous_questions':asked_questions})
        form = AskQuestionForm(post_data(request))
        if form.is_valid():
            Question.objects.update_question(question,
                                             title=form.cleaned_data.get('title'),
                                             description=form.cleaned_data.get('description'),
                                             tags=form.cleaned_data.get('tags'))
            from quest.messages import QUESTION_UPDATED_SUCCESSFULLY
            messages.success(request, QUESTION_UPDATED_SUCCESSFULLY)
            return HttpResponseRedirect(redirect_to=url_reverse('quest.views.view_question', args=(question.id, question.slug)))
        return response(request, edit_question_template, {'form':form,
                                                          'question':question,
                                                          'previous_questions':asked_questions})
    raise Http404

def view_messfood(request, messfood_registration_template, messfood_template):
    selected_maintab = 'messfood'
    if request.user.is_authenticated():
        return response(messfood_template,locals(),request)
    else:
        from messfood.forms import MessFoodRegistrationForm,MessCreationForm
        form = MessFoodRegistrationForm()
        newmessform = MessCreationForm()
        return response(messfood_registration_template,locals(),request)

def view_homefood(request, homefood_registration_template, homefood_template):
    selected_maintab = "homefood"
    if request.user.is_authenticated():
        googlemaps_api_key = None
        if settings.MAPPING_ENABLED:
            googlemaps_api_key = settings.GOOGLE_MAPS_API_KEY
        return response(homefood_template, locals(), request)
    else:
        from homefood.forms import HomeFoodRegistrationForm

        form = HomeFoodRegistrationForm()
        return response(homefood_registration_template, locals(), request)

def view_restaurants(request,restaurants_registration_template,restaurants_template):
    selected_maintab = 'restaurantfood'
    if request.user.is_authenticated():
        from restaurants.models import Restaurant
        restaurants = Restaurant.premiumobjects.all().order_by('-created_on')
        return response(restaurants_template,locals(),request)
    else:
        from restaurants.models import Restaurant
        restaurants = Restaurant.premiumobjects.all().order_by('-created_on')
        from restaurants.forms import RestaurantFoodRegistrationForm
        form = RestaurantFoodRegistrationForm()
        return response(restaurants_registration_template,locals(),request)

def view_contactus(request, contactus_template):
    if request.method == 'GET':
        return response(request, contactus_template, {'form':ContactUsForm()})
    form = ContactUsForm(post_data(request))
    if form.is_valid():
        mail_admins(from_email=form.cleaned_data.get('from_email'),
                    from_name=form.cleaned_data.get('from_name'),
                    subject=form.cleaned_data.get('subject'),
                    message=form.cleaned_data.get('message'))
        from users.messages import CONTACTED_SUCCESSFULLY
        messages.success(request, CONTACTED_SUCCESSFULLY)
        return HttpResponseRedirect(redirect_to='/')
    return response(request, contactus_template, {'form':form})

def view_contactgroup(request, group_type, group_id, contactgroup_template):
    userprofile = loggedin_userprofile(request)
    if group_type == 'college':
        group = get_object_or_404(College, id=int(group_id))
        to = "%s Students" % group.name
        redirect_url = url_reverse('users.views.view_college', args=(group_id, group.slug))
    elif group_type == 'company':
        group = get_object_or_404(Company, id=int(group_id))
        to = "%s Employees" % group.name
        redirect_url = url_reverse('users.views.view_company', args=(group_id, group.slug))
    else:
        raise Http404
    if request.method == 'POST':
        contactgroupform = ContactGroupForm(post_data(request))
        if contactgroupform.is_valid():
            mail_group(group_type=group_type,
                       group=group,
                       from_email=userprofile.user.email,
                       message=contactgroupform.cleaned_data.get('message'),
                       from_name=userprofile.name,
                       subject=contactgroupform.cleaned_data.get('subject'))
            from users.messages import CONTACTED_SUCCESSFULLY
            messages.success(request, CONTACTED_SUCCESSFULLY)
            return HttpResponseRedirect(redirect_to=redirect_url)
    contactgroupform = ContactGroupForm({'to':to})
    return response(request, contactgroup_template, {'contactgroupform':contactgroupform,
                                                     'group_type':group_type,
                                                     'group_id':group_id})

def view_photoalbum(request, photoalbum_id):
    album = get_object_or_404(PicasaAlbum, id=photoalbum_id, user=request.user)

    return response(request, 'photoalbum.html', {
        'photoalbum': album,
        'page_type': 'photoalbum',
    })

def view_get_workinfo_settings(request, workinfo_settings_template):
    userprofile = loggedin_userprofile(request)
    (workplace, designation, years_of_exp) = userprofile.work_details
    form = WorkInfoSettingsForm({'workplace':workplace if workplace else '',
                                 'designation':designation,
                                 'years_of_exp':years_of_exp})
    return response(request, workinfo_settings_template, {'workinfo_form':form})

def feed(request):
    feed = News.objects.all()
    template = 'home.html'
    context = {
        'feed': feed,
    }
    return response(request, template, context)

def view_save_feed(request, all_feeds_template):
    # FIXME:Move this entire view code to a command extension.
    # Views are implicitly assumed to be called by the "browser" 'get' operation
    for url_obj in Feed.objects.all():
        # FIXME:Feed.objects.all() returns all feed objects.  And not "url_obj"s
        # So change url_obj to feed

        # FIXME:And refactor the below functionality into functions. Like,
        # 1)ping feed, 2)process feed response, etc...

        # FIXME:Never, ever use variables like fp, file or something. Have
        # a context related variable name
        url = url_obj.source_url
        fp = urllib.urlopen(url)
        xmldoc = minidom.parse(fp)
        xmlitem = xmldoc.getElementsByTagName("item")
        # FIXME:xmldoc.getElementsByTagName returns objects(plural). So,
        # rename the 'xmlitem' to 'feeditems'
        for item in xmlitem:
            title = item.getElementsByTagName("title")[0].firstChild.data
            pub_date = item.getElementsByTagName("pubDate")[0].firstChild.data
            page_link = item.getElementsByTagName("link")[0].firstChild.data
            desc = item.getElementsByTagName("description")[0].firstChild.data
            FeedEntry.objects.create_feedentry(
                title=title, desc=desc, page_link=page_link, pub_date=pub_date, source=url
            )
    # FIXME:Try to pass only variables accessed in all_feeds_template.
    # Only use locals when too many objects are to be accessed, which wont be
    # the normal case anyway.
    return response(request, all_feeds_template, locals())

def blog_view(request, template, context):
    """All blog views: contain links menu"""
    # Sources
    choices = Link.objects.values_list('category', flat=True).distinct()
    categories = [ (c, C) for c,C in Link.CATEGORY_CHOICES if c in choices ]
    sources = [ (category[-1], Link.objects.filter(category=category[0])) for category in categories ]

    # Previous entries
    previous = Entry.objects.all()[:16]

    # Dates archive
    dates = Entry.objects.values_list('timestamp', flat=True).distinct()
    dates_index = list(set([ date.year for date in set(dates) ]))
    for y in range(len(dates_index)):
        months = list(set([ date.month for date in dates if date.year == dates_index[y] ]))
        for m in range(len(months)):
            days = list(set([ date.day for date in dates if date.year == dates_index[y] and date.month == months[m] ]))
            months[m]= (months[m], days)
        dates_index[y] = (dates_index[y], months)

    # Author archive
    ids = list(set(Entry.objects.values_list('author', flat=True).distinct()))
    authors_index = [ User.objects.get(pk=id) for id in ids ]
            
    context['sources'] = sources
    context['previous'] = previous
    context['authors'] = authors_index
    context['dates'] = dates_index
    return response(request, template, context)

def view_validate_versions(request, validate_versions_template, enter_versions_template):
    form = VersionsForm(request.POST)
    if form.is_valid():
        validated_versions = []
        versions_info = form.cleaned_data.get('versions')
        for (name, version_digits) in versions_info:
            version = {}
            version['name'] = name
            version['version'] = version_digits
            version['flag'] = _validate_version(name, version_digits)
            validated_versions.append(version)
        default_file_name = ''.join(('versions_',
                                     datetime.today().strftime('%Y_%b_%d'),
                                     '.txt'))
        return response(request, validate_versions_template, {'versions':validated_versions, 'default_file_name':default_file_name})
    return response(request, enter_versions_template, {'form':form})

def view_save_personal_settings(request, personal_settings_template):
    if request.method == 'GET':
        return view_get_personal_settings(request, personal_settings_template)
    userprofile = loggedin_userprofile(request)
    form = PersonalSettingsForm(post_data(request))
    if form.is_valid():
        name = form.cleaned_data.get('name')
        new_password = form.cleaned_data.get('new_password')
        slug = form.cleaned_data.get('slug')
        if userprofile.can_update_slug():
            if slug:
                if UserProfile.objects.filter(slug=slug).count():
                    from users.messages import WEB_RESUME_URL_ALREADY_PICKED
                    form._errors['slug'] = WEB_RESUME_URL_ALREADY_PICKED
                else:
                    userprofile.update(name=name, slug=slug, password=new_password)
                    from users.messages import ACCOUNT_SETTINGS_SAVED
                    messages.success(request, ACCOUNT_SETTINGS_SAVED)
            else:
                from users.messages import INVALID_WEB_RESUME_URL
                messages.error(request, INVALID_WEB_RESUME_URL)
        else:
            userprofile.update(name=name, password=new_password)
            from users.messages import ACCOUNT_SETTINGS_SAVED
            messages.success(request, ACCOUNT_SETTINGS_SAVED)
    return response(request, personal_settings_template, {'personal_form':form})

def save_article(request, article_id=None):
    article = None
    if article_id:
        article = get_object_or_404(Article, id=article_id, user=request.user)
        form = ArticleForm(request.POST, instance=article)

        if 'delete' in request.POST:
            article.delete()
            messages.add_message(request, messages.INFO, _(u'The article “%s” has been deleted.') % article.name)
            return redirect('management:index')

    else:
        form = ArticleForm(request.POST)

    if form.is_valid():
        if article_id:
            form.save()
        else:
            article = form.save(commit=False)
            article.user = request.user
            article.save()
            article_id = article.id

        messages.add_message(request, messages.SUCCESS, _(u'The article is saved.'))
        return redirect('management:article', article_id=article_id)

    return response(request, 'edit_article.html', {
        'article': article,
        'article_form': form,
        'article_id': article_id,
        'page_type': 'article',
    })

def user(request, username):
    """Takes a username value"""
    author = User.objects.get(username=username)
    context = {
        'author': author,
    }
    return response(request, template, context)