Code review

class Register(TimeProfiling, ExceptionLoging, View):

    def post(self, request, *value_tuple, **value_dict):
        self.set_resp_type('xml')

        logr.info("Incoming request for corporate register()")
        # Read the request body
        xmlData = urllib.unquote_plus(request.body)
        #logr.info("xmlData: '%s'" % xmlData)

        # Hack -- UI sends as 'key=value'
        if xmlData.startswith('data='):
            xmlData = xmlData[5:]

        h = XmlHandler()
        xml.sax.parseString(xmlData, h)

        # Data validation: all required fields must be present.
        if not h.params.has_key("name"):
            logr.info("Error: Company name can not be empty")
            return HttpResponse(EMPTY_FIELD_ERR % 'Company Name', content_type="text/xml")
        if not h.params.has_key("location"):
            logr.info("Error: Company location can not be empty")
            return HttpResponse(EMPTY_FIELD_ERR % 'Company location', content_type="text/xml")
        if not h.params.has_key("url"):
            logr.info("Error: Company URL can not be empty")
            return HttpResponse(EMPTY_FIELD_ERR % 'Company URL', content_type="text/xml")
        if not h.params.has_key("phone"):
            logr.info("Error: Company User Phone can not be empty")
            return HttpResponse(EMPTY_FIELD_ERR % 'Phone of corporate user', content_type="text/xml")
        if not h.params.has_key("password"):
            logr.info("Error: Company User Password can not be empty")
            return HttpResponse(EMPTY_FIELD_ERR % 'Password of corporate user', content_type="text/xml")
        '''
        if not h.params.has_key("g-recaptcha-response"):
                    logr.info("Error: recaptcha response field 'g-recaptcha-respcorporate/changeToPaidAccount/?name=SAXhonse' cannot be empty")
                    return HttpResponse(BAD_REQUEST % "Missing recaptcha response field", content_type="text/xml")

        captcha_rs = h.params["g-recaptcha-response"]
            #captcha_pk = "6LdvNhUTAAAAAGrestjqoQLlPuivaa3M53b1fuje"
        captcha_pk = settings.RECAPTCHA_SECRET_KEY[socket.gethostbyname(socket.gethostname())]

            url = "https://www.google.com/recaptcha/api/siteverify"
            params = {
                'secret': captcha_pk,
                'response': captcha_rs
            }
            verify_rs = requests.get(url, params=params, verify=True)
            verify_rs = verify_rs.json()
            status = verify_rs.get("success", False)
            message = verify_rs.get('error-codes', None) or "Unspecified error."
            logr.info("status is %s, error code is %s" %(status, message))
            if not status:
                    logr.info("Error: recaptcha validation failed")
                    return HttpResponse(BAD_REQUEST % "recaptcha validation failed", content_type="text/xml")
        '''
        existingCorps = Corporate.objects.filter(name = h.params["name"])
        if existingCorps.count() != 0:
            logr.info("Error: Corporate with name %s already exists!" % h.params["name"])
            qualifier = 'with name "%s"' % h.params["name"]
            return HttpResponse(DUPLICATE_OBJECT_ERR % ('A company', qualifier), content_type="text/xml")

        err = _validate_email(h.params["email"])
        if err:
            return HttpResponse(err, content_type="text/xml")

        # It is possible to have common office number among multiple users.  So, we won't impose
        # uniqueness of phone numbers for corporate users.

        # First of all, create the Corporate (company) object.  Keep is inactive, till an admin approves.
        corp = Corporate()
        corp.is_active = False
        corp.name = h.params["name"]
        corp.hq_location = h.params["location"]
        corp.url = h.params["url"]
        if h.params.has_key("description"):
            corp.description = h.params["description"]
        if h.params.has_key("size"):
            corp.company_size = h.params["size"]
        if h.params.has_key("industry"):
            corp.industry = h.params["industry"]
        if h.params.has_key("isrecruiter") and h.params["isrecruiter"].lower() == 'true':
            corp.is_recruiter = True

        corp.save()

        #Creating a Subscription
        subscription = Subscription()
        subscription.corporate = corp
        subscription.package = SalesPackage.objects.get(pkg_type = 'Free')
        subscription.activation_time = datetime.now()
        subscription.activator = CorpUser.objects.filter(user__email = 'vishnuprasad@flocareer.com')[0]
        subscription.save()

        corp.credit = subscription.package.max_public_questions_credit
        corp.save()

        #Creating a Subscription History
        history = SubscriptionHistory()
        history.corporate = corp
        history.old_package = subscription.package
        history.new_package = subscription.package
        history.create_time = datetime.now()
        history.activator = subscription.activator
        history.save()

        # Create the first (super) user for the corporate
        username = _username_from_email(h.params["email"])
        #user = User.objects.create_user(username=username, email=h.params["email"], password=h.params["password"])
        user = User.objects.create_user(username=username, email=h.params["email"])
        #user.set_unusable_password()
        if h.params.has_key("firstname"):
            user.first_name = h.params["firstname"]
        if h.params.has_key("lastname"):
            user.last_name = h.params["lastname"]
        user.save()

        protocol, site_name = _get_ip(self.request)
        url = 'reset_password.html'
        token = default_token_generator.make_token(user)
        password_link = "%s%s/reset_password.html?token=%s&email=%s&new_corpuser=True"%(protocol, site_name, token, user.email)

        corpUser = CorpUser()
        corpUser.user = user
        corpUser.corporate = corp
        corpUser.is_super_user = True
        corpUser.phone_number = h.params["phone"]
        corpUser.last_login = datetime.now()
        if h.params.has_key("title"):
            corpUser.title = h.params["title"]
        corpUser.save()

        # Finally, initialize the analytics for the company
        analytics = CorpAnalytics()
        analytics.corporate = corp
        analytics.save()
        resp = ""
        activator_company_name = activator_user_name = ""
        is_created_by_logged_in_user = False
        if request.user.is_authenticated():
            auth = ""
            if _isCorpUser(request.user):
                is_created_by_logged_in_user = True
                corp_user = CorpUser.objects.get(user_id=request.user.id)
                activator_company_name = corp_user.corporate.name
                activator_user_name = _get_name(corp_user.user)
                if (not corp_user.corporate.is_recruiter and corp.is_recruiter) or\
                   (corp_user.corporate.is_recruiter and not corp.is_recruiter):
                    corp.is_active = True
                        corp.save()

                    if h.params.has_key("auth"):
                        auth = h.params["auth"]

                    if not corp_user.corporate.is_recruiter and corp.is_recruiter:
                        resp = _connect_recruiter_client_helper(corp_user.corporate.id,corp.id,False,auth)
                    elif corp_user.corporate.is_recruiter and not corp.is_recruiter:
                        resp = _connect_recruiter_client_helper(corp.id,corp_user.corporate.id,True,auth)

        # when hiring company invites recruiting company they connect automatically by default.
        if corpUser.corporate.is_recruiter == True:
            recruiting_clients  = corp.recruitingclient_set.all()
            if recruiting_clients.exists():
                for recruiting_client in recruiting_clients:
                    recruiting_client.status = "connected"
                    recruiting_client.create_time = datetime.now()
                    recruiting_client.save()

        ctx = { 'corpUser_FN':corpUser.user.first_name,
            'auth_corp_name': activator_company_name,
            'creator_name': activator_user_name,
            'resp':True if resp else False,
            'to_list':[corpUser.user.email],
            }
        notify (FEC_COMPANY_REG, ctx)

            ctx = { 'company_name':corp.name,
            'company_location':corp.hq_location,
            'company_url':corp.url,
            'company_description': corp.description,
            'company_size': corp.company_size,
            'company_industry': corp.industry,
            'is_recruiter': "Yes" if corp.is_recruiter else "No",
                        'is_created_internally': is_created_by_logged_in_user,
                        'creator_name': activator_user_name,
                        'auth_corp_name': activator_company_name,
            'corpUser_name': _get_name(corpUser.user),
            'corpUser_email': corpUser.user.email,
            'corpUser_phone': corpUser.phone_number,
            'corpUser_title': corpUser.title,
            'corp_id': corp.id,
            'to_list': _SALES_SU_LIST,
            }
        notify(FEC_COMPANY_REG_TO_FLO_ADMIN,ctx)

        resp = '<?xml version="1.0" encoding="UTF-8"?>\r\n'
        resp += '<company>\r\n'
        resp += '\t<id>%d</id>\r\n' % corp.id
        resp += '\t<user>\r\n'
        resp += '\t\t<name>%s</name>\r\n' % _get_name(user)
        resp += '\t\t<id>%d</id>\r\n' % user.id
        resp += '\t</user>\r\n'
        resp += '</company>\r\n'

            return HttpResponse(resp, content_type="text/xml")
#End of register()