Example #1
0
def handle(request):   
    if request.method == 'GET':
        return siteaction.render_to_response('idxcaptcha.htm')
    elif request.method == 'POST':
        captchatextin = request.session['signup_captcha_text']
        if dataplus.dictGetVal(request.REQUEST,'captcha_text') != captchatextin:
            return siteaction.render_to_response('idxcaptcha.htm',
                    {'error_html':'The captcha text entered is incorrect.'})
                
        params = request.session['signup-params']
        if params['username'].lower() in config.reserved_words or models.Account.objects.filter(username=params['username']).count() > 0:
            countries = models.Country.objects.all().order_by('name')
            country_select_html = hotmetal.elemSelect([('Select', '')], countries,
                lambda x:x.name, lambda x:x.code, dataplus.dictGetVal(request.REQUEST,'country'), 'name="country" id="country" style="width:160px"')
            
            industry_cats = models.IndustryCategory.objects.all()
            industry_cats_html = hotmetal.elemSelect([('Select', '')], industry_cats,
                lambda x:x.name, lambda x:x.name, dataplus.dictGetVal(request.REQUEST,'industry_category'), 'name="industry_category" id="industry_category" style="width:160px"')
            
            experience_select_html = hotmetal.elemSelect([('Select', '-1')], range(0,51),
                lambda x:x, lambda x:x, dataplus.dictGetVal(request.REQUEST,'experience'), 'name="experience" id="experience" style="width:90px"')
                    
            error_message = 'Username already exists. Please choose another'
            return siteaction.render_to_response('index.htm', 
                {'error_html': '<p class="error-note">' + error_message + '</p>',
                'name':params['name'],
                'username':params['username'],
                'email':params['email'],
                'country_select_html':country_select_html,
                'industry_categories_html':industry_cats_html,
                'experience_select_html':experience_select_html})
        else:           
            req_username = params['username'].lower()
            user = siteaction.createUser(req_username, params['name'], params['password'], params['email'], 
                    params['country'], params['industry_category'].replace('&amp;','&'), params['experience'])                 
           
            request.session['signup-params'] = None
            
            useraccount = user.account
        
            #none if these users would have posted their resume, or setup preferences....
            todoResumeMail_subject = '<span style="color:#FF9900">Next step: Update your Resume</span>'
            todoResumeMail_body_html = '<p>To effectively use socialray for Professional Networking and Jobs, you need to update your resume. You can do so by opening the <a href="http://www.socialray.org/me/editresume.htm">Resume Editor</a>.</p>' + \
                '<p>Regards,<br />Socialray Team</p>'
            mailman.sendToInbox(None, req_username, todoResumeMail_subject, todoResumeMail_body_html, 'SA')
            
            session_id = sessions_client.query('addNewSession', [useraccount.username])
            if session_id:
                chat_settings = models.ChatSettings.objects.get(account=useraccount)
                livewire_client.command('updateUserSession', [session_id, useraccount.username, useraccount.name, chat_settings.online_status, 
                    chat_settings.custom_message, chat_settings.invite_preference, chat_settings.ignore_list, 
                    dataplus.getStaticUrl(chat_settings.image_size1_file_path), dataplus.getStaticUrl(chat_settings.image_size2_file_path), 
                    dataplus.getStaticUrl(chat_settings.image_size3_file_path)])

                return siteaction.redirectWithCookie('/me', 'session_id', session_id)
            else:
                return HttpResponseRedirect('500.html')
Example #2
0
def handle(request):
    myself = siteaction.getLoggedInUser(request)
    if not myself:
        return HttpResponseRedirect('/login.htm')
    
    settings = models.UserSettings.objects.get(user=myself)
    
    if request.method == 'GET':
        resume_visibility = hotmetal.elemSelect([('Everyone', 'everyone'), ('Friends only', 'friends'), ('Nobody', 'nobody')], [],
            None, None, settings.resume_visibility, 'name="resume_visibility" id="resume_visibility" style="width:120px"')
            
        hide_phone_numbers_checked = ('', 'checked="checked"')[settings.phone_num_visibility != 'everyone']
            
        action_result = ''
        if dataplus.dictGetVal(request.REQUEST, 'flashId'):
            action_result = dataplus.dictGetVal(statix.action_messages, dataplus.dictGetVal(request.REQUEST, 'flashId'), '')
        
        return siteaction.render_to_response('me/editprivacy.htm',
                    {'resume_visibility':resume_visibility, 
                     'hide_phone_numbers_checked':hide_phone_numbers_checked, 
                     'action_result':action_result,
                     'myself': myself
                    })
            
    elif request.method == 'POST':
        settings.resume_visibility = dataplus.dictGetVal(request.REQUEST,'resume_visibility')
        settings.phone_num_visibility = dataplus.dictGetVal(request.REQUEST, 'hide_phone_numbers', 'everyone', lambda x:'friends')
        settings.save()
        
        return HttpResponseRedirect('/me/editprivacy.htm?flashId=privacy_saved')
Example #3
0
def errorResponse(error_message, request):
    countries = models.Country.objects.all().order_by('name')
    country_select_html = hotmetal.elemSelect([('Select', '')], countries,
        lambda x:x.name, lambda x:x.code, dataplus.dictGetVal(request.REQUEST,'country'), 'name="country" id="country" style="width:160px"')
    
    industry_cats = models.IndustryCategory.objects.all()
    industry_cats_html = hotmetal.elemSelect([('Select', '')], industry_cats,
        lambda x:x.name, lambda x:x.name, dataplus.dictGetVal(request.REQUEST,'industry_category'), 'name="industry_category" id="industry_category" style="width:160px"')
    
    experience_select_html = hotmetal.elemSelect([('Select', '-1')], range(0,51),
        lambda x:x, lambda x:x, dataplus.dictGetVal(request.REQUEST,'experience'), 'name="experience" id="experience" style="width:90px"')
    
    return siteaction.render_to_response('index.htm', 
        {'error_html': '<p class="error-note">' + error_message + '</p>',
        'name':dataplus.dictGetVal(request.REQUEST,'name'),
        'username':dataplus.dictGetVal(request.REQUEST,'user-name'),
        'email':dataplus.dictGetVal(request.REQUEST,'email'),
        'country_select_html':country_select_html,
        'industry_categories_html':industry_cats_html,
        'experience_select_html':experience_select_html})
def handle(request):
  
    if request.method == 'GET':
##        locations = models.Location.objects.all().order_by('name')
##        locations_select_html = hotmetal.elemSelect([('Select', '')], locations,
##            lambda x:x.name, lambda x:x.name, '', 'name="location" id="location" style="width:160px"')  
        
        industry_cats = models.IndustryCategory.objects.all()
        industry_cats_html = hotmetal.elemSelect([('Select', '')], industry_cats,
            lambda x:x.name, lambda x:x.name, '', 'name="industry_category" id="industry_category" style="width:260px"')
            
        countries = models.Country.objects.all().order_by('name')
        country_select_html = hotmetal.elemSelect([('Select', '')], countries,
            lambda x:x.name, lambda x:x.code, '', 'name="country" id="country" style="width:160px"')
       
        return siteaction.render_to_response('recruiters/postjobsnow1.htm',
            {'industry_cats_html': industry_cats_html,
##            'locations_select_html':locations_select_html,
            'country_select_html':country_select_html})
    
    elif request.method == 'POST':
        return HttpResponseRedirect('/index.htm')
Example #5
0
def handle(request):   
    if request.method == 'GET':
        socialray_invite = dataplus.dictGetSafeVal(request.REQUEST,'inviteId','')
        comm_invite = dataplus.dictGetSafeVal(request.REQUEST,'commInviteId','')
        comm_friend_invite = dataplus.dictGetSafeVal(request.REQUEST,'commFriendInviteId','')
        invitation = ''
        if socialray_invite:
            invitation = 'inviteId=' + socialray_invite
        elif comm_invite:
            invitation = 'commInviteId=' + comm_invite
        elif comm_friend_invite:
            invitation = 'commFriendInviteId=' + comm_friend_invite
        
        countries = models.Country.objects.all().order_by('name')
        country_select_html = hotmetal.elemSelect([('Select', '')], countries,
            lambda x:x.name, lambda x:x.code, '', 'name="country" id="country" style="width:160px"')   
        
        return siteaction.render_to_response('me/signup.htm', 
            {'invitation':invitation,
            'cid':dataplus.getUniqueId(),
            'country_select_html':country_select_html})
    elif request.method == 'POST':
        result, response = validateRequest(request)
        if not result:
            return response
        
        username = dataplus.dictGetVal(request.REQUEST, 'username')
        if username.lower() in config.reserved_words or models.Account.objects.filter(username=username).count() > 0:
            return siteaction.render_to_response('me/signup.htm', 
                {'error_html': '<p class="error-note">Username already exists. Please choose another.</p>',
                'name':dataplus.dictGetVal(request.REQUEST, 'name'),
                'username':dataplus.dictGetVal(request.REQUEST, 'username'),
                'email':dataplus.dictGetVal(request.REQUEST, 'email'),
                'cid':dataplus.getUniqueId()})
        else:
            username = dataplus.dictGetVal(request.REQUEST,'username').lower()
            siteaction.createUser(username, dataplus.dictGetSafeVal(request.REQUEST, 'name'), 
                dataplus.dictGetSafeVal(request.REQUEST, 'password1'), dataplus.dictGetSafeVal(request.REQUEST, 'email'), 
                dataplus.dictGetSafeVal(request.REQUEST, 'country'), 'Software/IT', 0, dataplus.dictGetVal(request.REQUEST, 'invitation'))
            
            account = models.Account.objects.get(username=username)
            session_id = sessions_client.query('addNewSession', [account.username])
            if session_id:
                chat_settings = models.ChatSettings.objects.get(account=account)
                livewire_client.command('updateUserSession', [session_id, account.username, account.name, chat_settings.online_status, 
                    chat_settings.custom_message, chat_settings.invite_preference, chat_settings.ignore_list, 
                    dataplus.getStaticUrl(chat_settings.image_size1_file_path), dataplus.getStaticUrl(chat_settings.image_size2_file_path), 
                    dataplus.getStaticUrl(chat_settings.image_size3_file_path)])
    
            return siteaction.redirectWithCookie('createresume.htm', 'session_id', session_id)
Example #6
0
def handle(request):
    if not (request.method == 'GET' and dataplus.dictGetVal(request.REQUEST, 'action') == 'logout'):
        #handling the user specific sub domain request...
        user = siteaction.getUserFromRequest(request)
        if user:
            return profiles_show.handle(request, user.username)
        #handling over
    
    if request.method == 'GET': 
        if (dataplus.dictGetVal(request.REQUEST, 'action') == 'logout'):
            siteaction.doLogout(request)
            
        if siteaction.getLoggedInUser(request):
            return HttpResponseRedirect('/me/')
        
        countries = models.Country.objects.all().order_by('name')
        country_select_html = hotmetal.elemSelect([('Select', '')], countries,
            lambda x:x.name, lambda x:x.code, '', 'name="country" id="country" style="width:160px"')
        
        industry_cats = models.IndustryCategory.objects.all().order_by('id')
        industry_cats_html = hotmetal.elemSelect([('Select', '')], industry_cats,
            lambda x:x.name, lambda x:x.name, '', 'name="industry_category" id="industry_category" style="width:160px"')
        
        experience_select_html = hotmetal.elemSelect([('Select', '-1')], range(0,51),
            lambda x:x, lambda x:x, '', 'name="experience" id="experience" style="width:90px"')
            
        return siteaction.render_to_response('index.htm',
            {'country_select_html':country_select_html,
            'industry_categories_html':industry_cats_html,
            'experience_select_html':experience_select_html})
        
    elif request.method == 'POST':
        return {
            'login':siteaction.doLogin,
            'signup':signupUser,
        }[dataplus.dictGetVal(request.REQUEST,'action')](request)
Example #7
0
def handle(request):
    myself = siteaction.getLoggedInUser(request)
    if not myself:
        return HttpResponseRedirect('/login.htm')
    
    settings = models.UserSettings.objects.get(user=myself)
    if request.method == 'GET':
        action_result = ''
        if dataplus.dictGetVal(request.REQUEST, 'flashId'):
            action_result = dataplus.dictGetVal(statix.action_messages, dataplus.dictGetVal(request.REQUEST, 'flashId'), '')
        
        experience_select_html = ''
        diff_years = None
        if myself.working_since != None:
            diff_years = (datetime.datetime.utcnow() - myself.working_since).days/365        
        experience_select_html = hotmetal.elemSelect([('Select', '-1')], range(0,30),
            lambda x:x, lambda x:x, diff_years, 'name="experience" id="experience" style="width:90px"')
        
        curr_range = str(myself.salary_range_lower) + '-' + str(myself.salary_range_upper)  
        salary_ranges = codejar_resume.getSalaryRanges(settings.country)
        salary_range_select_html = hotmetal.elemSelect([('Prefer not to say', '0-0')], salary_ranges,
            lambda x:x[1], lambda x:x[0], curr_range, 'name="salary_range" id="salary_range" style="width:160px"')
        salary_range_select_html += '(' + settings.currency + ')'
      
##        salary_ranges = statix.getSalaryRanges()
##        salary_range_select_html = hotmetal.elemSelect([('Prefer not to say', '0-0')], salary_ranges,
##            lambda x:x[1], lambda x:x[0], curr_range, 'name="salary_range" id="salary_range" style="width:160px"')
##        
##        locations = models.Location.objects.all().order_by('name')
##        preferred_location = hotmetal.elemSelect([('Select', ''),('Anywhere', 'Anywhere')], locations,
##            lambda x:x.name, lambda x:x.name, settings.preferred_location, 'name="preferred_location" id="preferred_location" style="width:160px"')
        
        interest_in_new_job = hotmetal.elemSelect([('Interested', 'active'),
            ('Only Terrific! Offers', 'passive'), ('Not Interested', 'no')], [],
                None, None, settings.interest_in_new_job, 'name="interest_in_new_job" id="interest_in_new_job" style="width:160px"')
        
        format_list = []
        selected_format = ''
        if not settings.resume_download_format_set:
            format_list = [('Select',''),('PDF', 'pdf'),('HTML', 'html'),('Word Doc', 'doc')]
        else:
            format_list = [('PDF', 'pdf'),('HTML', 'html'),('Word Doc', 'doc')]
            selected_format = settings.preferred_resume_download_format
        
        preferred_resume_download_format = hotmetal.elemSelect(format_list,
                [], None, None, selected_format, 'name="preferred_resume_download_format" id="preferred_resume_download_format" style="width:120px"')
        
        return siteaction.render_to_response('me/editresume.htm',
            {   'resume_contents' : codejar_resume.getResumeText(myself),
                'has_doc_resume':(settings.original_resume_format == 'doc'),
                'has_odt_resume':(settings.original_resume_format == 'odt'),
                'industry_categories_html': codejar_resume.getIndustryCategoriesHtml(myself),
                'experience_select_html':experience_select_html,
                'salary_range_select_html' : salary_range_select_html,
##                'preferred_location':preferred_location,
                'interest_in_new_job': interest_in_new_job, 
                'html_style':myself.resume_contents.html_style,
                'action_result':action_result,
                'preferred_resume_download_format':preferred_resume_download_format,
                'myself': myself})                
    
    elif request.method == 'POST':
        if dataplus.dictGetVal(request.REQUEST,'action') == 'upload':
            success, error_code = codejar_resume.saveResumeDoc(myself, request, 'resume_doc')
            if not success:
                return HttpResponseRedirect('/me/editresume.htm?flashId=' + error_code)
            
            return HttpResponseRedirect('/profiles/' + myself.username + '?flashId=res_uploaded')
##            return HttpResponseRedirect('/me/editresume.htm?flashId=res_uploaded')
            
        elif dataplus.dictGetVal(request.REQUEST,'action') == 'save':
            resumetext = dataplus.dictGetVal(request.REQUEST,'resumetext')
            success = codejar_resume.saveResume(myself, resumetext)
            if not success:
                return HttpResponseRedirect('/me/editresume.htm?flashId=cannot_create_html')
            
            return HttpResponseRedirect('/me/editresume.htm?flashId=res_saved')
            
        elif dataplus.dictGetVal(request.REQUEST,'action') == 'profilesettings':
            #save industry_category
            str_industry_cat = dataplus.dictGetVal(request.REQUEST,'industry_category')
            industry_category = models.IndustryCategory.objects.get(name=str_industry_cat)
            myself.industry_category = industry_category
            
            myself.working_since = datetime.datetime.utcnow() - datetime.timedelta(dataplus.dictGetVal(request.REQUEST,'experience',0,string.atoi) * 365)
            
            #salary in the format 'min_salary-max_salary'
            #this string needs to be split into min and max
            sal_range = dataplus.dictGetVal(request.REQUEST,'salary_range').split('-')
            myself.salary_range_lower = string.atoi(sal_range[0])
            myself.salary_range_upper = string.atoi(sal_range[1])
##            
##            settings.preferred_location = dataplus.dictGetSafeVal(request.REQUEST,'preferred_location')
            settings.interest_in_new_job = dataplus.dictGetVal(request.REQUEST,'interest_in_new_job')
            preferred_format = dataplus.dictGetVal(request.REQUEST,'preferred_resume_download_format')
            if preferred_format != '':
                settings.preferred_resume_download_format = preferred_format
                settings.resume_download_format_set = True
            
            settings.save()
            myself.save()
        
            return HttpResponseRedirect('/me/editresume.htm?flashId=prof_set_saved')
def handle(request):    
    if request.method == 'GET':
        #there cannot be get requests to this page.....
        return siteaction.render_to_response('showmessage.htm', 
            {'msg_heading': 'Error',
              'msg_html': 'Invalid URL'})
    
    elif request.method == 'POST':
        if (dataplus.dictGetVal(request.REQUEST,'action') == 'page2'):
            industry_cat = dataplus.dictGetVal(request.REQUEST,'industry_category')
            
            if not (dataplus.dictGetVal(request.REQUEST,'postedby') and dataplus.dictGetVal(request.REQUEST,'industry_category') \
                and dataplus.dictGetVal(request.REQUEST,'company')  and dataplus.dictGetVal(request.REQUEST,'location') \
                and dataplus.dictGetVal(request.REQUEST,'phone') and dataplus.dictGetVal(request.REQUEST,'email')):
                return siteaction.render_to_response('showmessage.htm', {'msg_heading':'Invalid request', \
                    'msg_html':'Required fields were not supplied. Please fill all the required fields and try again.'})
                    
            salary_ranges = codejar_resume.getSalaryRanges(dataplus.dictGetVal(request.REQUEST,'country'))
            salary_range_select_html = hotmetal.elemSelect([('Select', '0-0')], salary_ranges,
                lambda x:x[1], lambda x:x[0], '0-0', 'name="salary_range" id="salary_range" style="width:160px"')
            currency_code = models.Country.objects.get(code=dataplus.dictGetVal(request.REQUEST,'country')).currency_code
            
            return siteaction.render_to_response('recruiters/postjobsnow2.htm',
                {'postedby': dataplus.dictGetVal(request.REQUEST,'postedby'),
                 'industry_category': cgi.escape(dataplus.dictGetVal(request.REQUEST,'industry_category')),
                 'company': dataplus.dictGetVal(request.REQUEST,'company'),
                 'location': dataplus.dictGetVal(request.REQUEST,'location'),
                 'country': dataplus.dictGetVal(request.REQUEST,'country'),
                 'email': dataplus.dictGetVal(request.REQUEST,'email'),
                 'phone': dataplus.dictGetVal(request.REQUEST,'phone'),
                 'salary_range_select_html': salary_range_select_html,
                 'currency_code':currency_code,
                 'cid':dataplus.getUniqueId(),})

        elif (dataplus.dictGetVal(request.REQUEST,'action') == 'save'):
            if dataplus.dictGetVal(request.REQUEST,'captcha_text') != request.session['postjob_captcha_text']:
                return siteaction.render_to_response('recruiters/postjobsnow2.htm',
                    {'postedby': dataplus.dictGetVal(request.REQUEST,'postedby'),
                     'industry_category': cgi.escape(dataplus.dictGetVal(request.REQUEST,'industry_category')),
                     'company': dataplus.dictGetVal(request.REQUEST,'company'),
                     'location': dataplus.dictGetVal(request.REQUEST,'location'),
                     'country': dataplus.dictGetVal(request.REQUEST,'country'),
                     'email': dataplus.dictGetVal(request.REQUEST,'email'),
                     'phone': dataplus.dictGetVal(request.REQUEST,'phone'),
                     'designation': dataplus.dictGetVal(request.REQUEST,'designation'),
                     'jobdescription': dataplus.dictGetVal(request.REQUEST,'jobdescription'),
                     'location': dataplus.dictGetVal(request.REQUEST,'location'),
                     'exact_salary': dataplus.dictGetVal(request.REQUEST,'exact_salary'),
                     'mandatory_skills': dataplus.dictGetVal(request.REQUEST,'mandatory_skills'),
                     'desired_skills': dataplus.dictGetVal(request.REQUEST,'desired_skills'),
                     'title': dataplus.dictGetVal(request.REQUEST,'title'),
                     'error_html':'<p class="error-note">The captcha(verification) text entered doesn\'t match.</p>'})
            
            job_pos = models.JobPosition()
            job_pos.tag = 'name=' + dataplus.dictGetSafeVal(request.REQUEST, 'postedby') + ';'
            job_pos.company_name = dataplus.dictGetSafeVal(request.REQUEST, 'company')
                    
            industry_category = models.IndustryCategory.objects.get(name=dataplus.dictGetVal(request.REQUEST,'industry_category'))
            job_pos.industry_category = industry_category
            
            job_pos.designation = dataplus.dictGetSafeVal(request.REQUEST, 'designation')
            job_pos.job_description = dataplus.dictGetSafeVal(request.REQUEST, 'jobdescription','')
            job_pos.num_positions = 1 #one for now.
            job_pos.closing_date = config.max_date
            job_pos.location = dataplus.dictGetSafeVal(request.REQUEST, 'location')
            job_pos.country = dataplus.dictGetSafeVal(request.REQUEST, 'country')
            
            exact_salary = dataplus.dictGetVal(request.REQUEST,'exact_salary')
            if exact_salary:
                exact_salary = string.atoi(exact_salary)
                job_pos.min_compensation = exact_salary
                job_pos.max_compensation = exact_salary
            else:            
                #salary in the format 'min_salary-max_salary'
                #this string needs to be split into min and max
                sal = string.split(dataplus.dictGetVal(request.REQUEST,'salary_range'),'-')
                job_pos.min_compensation = string.atoi(sal[0])
                job_pos.max_compensation = string.atoi(sal[1])
            
            job_pos.min_exp_years = dataplus.dictGetVal(request.REQUEST,'min_exp_years',0)
            job_pos.mandatory_skills = dataplus.dictGetSafeVal(request.REQUEST, 'mandatory_skills')
            job_pos.desired_skills = dataplus.dictGetSafeVal(request.REQUEST, 'desired_skills')
            job_pos.educational_qualifications = dataplus.dictGetSafeVal(request.REQUEST,'edu_qualifications')
            job_pos.contact_email = dataplus.dictGetSafeVal(request.REQUEST,'email')
            job_pos.contact_phone = dataplus.dictGetSafeVal(request.REQUEST,'phone')
            if dataplus.dictGetVal(request.REQUEST,'title') != '':
                job_pos.title = dataplus.dictGetSafeVal(request.REQUEST,'title')
            else:
                job_pos.title = (job_pos.designation + ' - ' + job_pos.mandatory_skills + ' (' + str(job_pos.min_exp_years) + ' years)')[:30] + '...'
            
            job_pos.currency = config.default_currency
            job_pos.url = ''
            
            job_pos.save()
            
            return siteaction.render_to_response('showmessage.htm', 
                                    { 'msg_heading':'Success',
                                       'msg_html':'The job was added successfully. <a href="/recruiters/postjobsnow1.htm">Add Another</a>.'})
def handle(request):
    myself = siteaction.getLoggedInUser(request, True)
    if not myself:
        return HttpResponseRedirect('/login.htm')
    
    if not myself.resume_contents.text:
        return HttpResponseRedirect('createresume.htm')
    
    if request.method == 'GET':
        settings = models.UserSettings.objects.get(user=myself)
        
        industry_cats = models.IndustryCategory.objects.all().order_by('id')
        industry_cats_html = hotmetal.elemSelect([('Select', '')], industry_cats,
            lambda x:x.name, lambda x:x.name, '', 'name="industry_category" id="industry_category" style="width:320px"')  
        
##        locations = models.Location.objects.all().order_by('name')
##        preferred_location = hotmetal.elemSelect([('Select', ''),('Anywhere', 'Anywhere')], locations,
##            lambda x:x.name, lambda x:x.name, '', 'name="preferred_location" id="preferred_location" style="width:160px"')  
        
##        salary_ranges = statix.getSalaryRanges()
##        salary_range_select_html = hotmetal.elemSelect([('Select', '0-0'),('Prefer not to say', '0-0')], salary_ranges,
##            lambda x:x[1], lambda x:x[0], '0-0', 'name="salary_range" id="salary_range" style="width:160px"')   

        salary_ranges = codejar_resume.getSalaryRanges(settings.country)
        salary_range_select_html = hotmetal.elemSelect([('Select', '0-0'),('Prefer not to say', '0-0')], salary_ranges,
            lambda x:x[1], lambda x:x[0], '0-0', 'name="salary_range" id="salary_range" style="width:160px"') 
        salary_range_select_html += '(' + settings.currency + ')'

        experience_select_html = hotmetal.elemSelect([('Select', '-1')], range(0,51),
            lambda x:x, lambda x:x, '', 'name="experience" id="experience" style="width:90px"')  
    
        settings = models.UserSettings.objects.get(user=myself)
        interest_in_new_job = hotmetal.elemSelect([('Interested', 'active'),
            ('Only Terrific! Offers', 'passive'), ('Not Interested', 'no')], [],
                None, None, settings.interest_in_new_job, 'name="interest_in_new_job" id="interest_in_new_job" style="width:160px"')
                
        resume_visibility = hotmetal.elemSelect([('Everyone', 'everyone'), ('Friends only', 'friends'), ('Nobody', 'nobody')], [],
            None, None, settings.resume_visibility, 'name="resume_visibility" id="resume_visibility" style="width:120px"')            
            
        action_result = ''
        if dataplus.dictGetVal(request.REQUEST, 'flashId'):
            action_result = dataplus.dictGetVal(statix.action_messages, dataplus.dictGetVal(request.REQUEST, 'flashId'), '')
            
        return siteaction.render_to_response('me/createjobsettings.htm',
            {'industry_categories_html': industry_cats_html,
            'experience_select_html':experience_select_html,
            'salary_range_select_html':salary_range_select_html,
##            'preferred_location':preferred_location,
            'resume_visibility':resume_visibility, 
            'interest_in_new_job': interest_in_new_job, 
            'action_result':action_result,
            'myself': myself})
    
    elif request.method == 'POST':
        try:
            str_industry_category = dataplus.dictGetVal(request.REQUEST,'industry_category')
            industry_category = models.IndustryCategory.objects.get(name=str_industry_category)
            myself.industry_category = industry_category
            
            myself.working_since = datetime.datetime.utcnow() - datetime.timedelta(dataplus.dictGetVal(request.REQUEST,'experience',0,string.atoi) * 365)
            
            #salary in the format 'min_salary-max_salary'
            #this string needs to be split into min and max
            sal_range = dataplus.dictGetVal(request.REQUEST,'salary_range').split('-')
            myself.salary_range_lower = string.atoi(sal_range[0])
            myself.salary_range_upper = string.atoi(sal_range[1])        
            
            myself.phone = dataplus.dictGetVal(request.REQUEST,'phone')
            
            settings = models.UserSettings.objects.get(user=myself)
            settings.resume_visibilty = dataplus.dictGetVal(request.REQUEST,'resume_visibilty')
            settings.interest_in_new_job = dataplus.dictGetVal(request.REQUEST,'interest_in_new_job')
            settings.preferred_location = 'Anywhere'
##            settings.preferred_location = dataplus.dictGetSafeVal(request.REQUEST,'preferred_location')
                    
            myself.last_update_time = datetime.datetime.utcnow()
            myself.save() 
            settings.save()
            myself.account.account_state = 'A'
            myself.account.save()

            redirect_url = ''
            post_signup_actions = dataplus.returnIfExists(models.PostSignupActions.objects.filter(user=myself))
            if post_signup_actions:
                actions = post_signup_actions.actions.split(',')
                success, response = codejar_invites.processInvitations(myself, actions)
                if response:
                    return response            
        except:
            return HttpResponseRedirect('createjobsettings.htm?flashId=failed_jobset_save')
                
        return HttpResponseRedirect('/me/')
def handle(request):
    myself = siteaction.getLoggedInUser(request)    
    if not myself:
        return HttpResponseRedirect('/login.htm')
    
    rcvr = rcvr_comm = None    
    rcvr_id = dataplus.dictGetVal(request.REQUEST, 'rcvrId', 0, string.atoi)
    rcvr_type = dataplus.dictGetVal(request.REQUEST,'rcvrType')
    
    if rcvr_type == 'u':
        rcvr = dataplus.returnIfExists(models.User.objects.filter(id=rcvr_id))
        if not rcvr:
            return  siteaction.render_to_response('me/showmessage.htm', 
                                {'myself':myself, 'msg_heading':'Error', 'msg_html':'Invalid Request'})
        receivers =  [rcvr]
    elif rcvr_type == 'c':
        rcvr_comm = dataplus.returnIfExists(models.Community.objects.filter(id=rcvr_id))
        if not rcvr_comm:
            return  siteaction.render_to_response('me/showmessage.htm', 
                                {'myself':myself, 'msg_heading':'Error', 'msg_html':'Invalid Request'})
    
    if request.method == 'GET':
        if rcvr:
            receiver_html = '<a href="' + config.profiles_url + '/' + rcvr.username + '" >' + rcvr.name + '</a>'
        elif rcvr_comm:
            receiver_html = 'Members of <a href="' + config.communities_url + '/' + str(rcvr_comm.id) + '" >' + rcvr_comm.name + '</a>' 
        
        experience_select_html = hotmetal.elemSelect([('Select', '-1')], range(0,30),
            lambda x:x, lambda x:x, '', 'name="experience" id="experience" style="width:80px"')
        
        industry_categories_select_html = hotmetal.elemSelect([('Select', '-1')], models.IndustryCategory.objects.all().order_by('name'),
            lambda x:x.name, lambda x:x.name, '', 'name="industry_category" id="industry_category" style="width:180px"')
            
        old_referrals = myself.posted_referrals.order_by('-created_at')[:20]
        old_referrals_select_html = hotmetal.elemSelect([('Select', '0')], old_referrals,
            lambda x:x.subject + ' (' + dataplus.getStrDate(x.created_at) + ')', lambda x:x.id, '', 'name="old_referral" id="old_referral" style="width:280px;" onchange="resetReferral();"')
            
        return siteaction.render_to_response('me/sendjobreferral.htm',
            {'myself': myself,
            'rcvrId':rcvr_id,
            'rcvrType':rcvr_type,
            'receiver_html':receiver_html,
            'has_old_referrals': (old_referrals.count() > 0),
            'old_referrals_select_html':old_referrals_select_html,
            'experience_select_html':experience_select_html,
            'sending_to_user': (rcvr_type == 'u'),
            'industry_categories_select_html':industry_categories_select_html,})
            
    elif request.method == 'POST':
        job_ref_id = dataplus.dictGetVal(request.REQUEST, 'referral_id', 0, string.atoi)
        if job_ref_id > 0:
            job_ref = models.JobReferral.objects.get(id=job_ref_id)
        else:
            job_ref = models.JobReferral()
            job_ref.sender = myself        
            if rcvr:
                receivers = [rcvr]
                job_ref.industry_category = rcvr.industry_category
                if rcvr.working_since:
                    job_ref.min_experience_years = (datetime.datetime.utcnow() - rcvr.working_since).days/365
            else:
                receivers = [x for x in rcvr_comm.members.all() if x.username != myself.username]
                job_ref.industry_category = models.IndustryCategory.objects.get(name=dataplus.dictGetVal(request.REQUEST, 'industry_category'))
                job_ref.min_experience_years = dataplus.dictGetVal(request.REQUEST, 'experience', 0, string.atoi)
                
            job_ref.subject = dataplus.dictGetSafeVal(request.REQUEST, 'subject')
            job_ref.reply_to_email = dataplus.dictGetSafeVal(request.REQUEST, 'reply_to')
            job_ref.text = dataplus.dictGetSafeVal(request.REQUEST, 'text')
            job_ref.save()
        
        for receiver in receivers:
            job_ref.receivers.add(receiver)
        
        html_message = dataplus.replaceHtmlLineBreaks(job_ref.text) + '<p><a href="' + config.server_base_url + '/me/viewreferral.htm?id=' + str(job_ref.id) + '">Forward your resume</a></p>'
        text_message = job_ref.text + '\r\n Visit ' + config.server_base_url + '/me/viewreferral.htm?id=' + str(job_ref.id) + ' to forward your resume.\r\n\r\n'
        
        subject = 'Job Referral: ' + job_ref.subject
        def internalSender(rcvr_accounts):
            mailman.sendMessage(myself.username, [rcvr.username for rcvr in rcvr_accounts], subject, html_message)
            
        def externalSender(rcvr_accounts):
            sender = '"' + myself.name + '" <' + myself.username + '*****@*****.**>'
            receivers = ['"' + rcvr.name + '" <' + rcvr.email + '>' for rcvr in rcvr_accounts]
            ext_html_message = html_message + \
                '<br /><br /><br /><br /><br />' + \
                'If you don\'t want to receive notification emails, change your Account Settings ' + \
                '<a href="' + config.server_base_url + '/me/editsettings.htm">here</a>'                
            ext_text_message = text_message + \
                '\r\n\r\n\r\n\r\n\r\n' + \
                'If you don\'t want to receive notification emails, change your Account Settings here\r\n' + \
                config.server_base_url + '/me/editsettings.htm'
            mailman.sendMail(sender, receivers, subject, ext_html_message, None, None, ext_text_message, reply_to=myself.email)
        
        mailman.sendBySettings([rcvr.account for rcvr in receivers], internalSender, externalSender, 'JobReferral')
        
        return HttpResponseRedirect('/me/?flashId=jobref_sent')
Example #11
0
def handle(request):
    try:
        chat_id = dataplus.dictGetVal(request.REQUEST, 'chatId', '')
        if not chat_id:
            return ajaxian.getFailureResp('error:invalid_chatId')
        new_user = dataplus.dictGetVal(request.REQUEST, 'newUser')
        new_guest = dataplus.dictGetVal(request.REQUEST, 'newGuest')
        session_id = ''
        if new_user or new_guest:
            result = ''
            if new_user:
                session_id = request.COOKIES['session_id']
                result = livewire_client.command('addUser', [chat_id, new_user])
            elif new_guest:
                session_id = '#' + dataplus.getUniqueId(19)
                result = livewire_client.command('addGuest',[chat_id,session_id, new_guest, 'Invited Guest.', dataplus.getStaticUrl(config.chat_guest_img_50), 
                    dataplus.getStaticUrl(config.chat_guest_img_72), dataplus.getStaticUrl(config.chat_guest_img_128)])
            if(result != 'success'):
                if result == 'error:max_users_exceeded':
                    return HttpResponse('Failed to join chat. The chat session has exceeded the maximum number of users.')
                elif result == 'error:invalid_chat_id':
                    return siteaction.render_to_response('500.html')
                else:
                    return HttpResponse('Failed to join chat.')
        else:
            session_id = request.COOKIES['session_id']

        data = livewire_client.query('getChatInfo', [session_id, chat_id])
        if data == 'error:invalid_chat_id':
            return HttpResponse('This chat does not exist.')
        chat_info = cPickle.loads(data)

        is_member = False
        friends_select_html = ''
        self = chat_info['self']
        current_username = self['username']
        current_name = self['name']
        current_user_online_status = self['online_visibility']
        if not current_username.startswith('#'):
            try:
                account = models.Account.objects.get(username=current_username)
                is_member = True
                if account.account_type == 'U':
                    friends = models.User.objects.filter(friends__username=account.username).order_by('name')
                    friends_select_html = hotmetal.elemSelect([('Select', '')], friends,
                    lambda x:x.name, lambda x:x.username, '', 'name="friends_select" id="friends_select" style="width:160px"')
            except:
                pass
        
        response = siteaction.render_to_response('chat/chatbox.htm', { 'current_chat_id':chat_id,
                                                        'current_username':current_username,
                                                        'current_name':current_name,
                                                        'current_user_online_status':current_user_online_status,
                                                        'is_member':is_member,
                                                        'friends_select_html':friends_select_html})
        
        expiry_time = datetime.datetime.strftime(datetime.datetime.utcnow() + datetime.timedelta(days=90), "%a, %d-%b-%Y %H:%M:%S GMT")
        response.set_cookie('session_id', session_id, expires=expiry_time)
        return response
        
    except:
        return HttpResponse('Invalid Chat.')
def getExpRangeSelectHtml(selected_value='-1'):
    exp_ranges = statix.getExperienceRanges()
    exp_range_select_html = hotmetal.elemSelect([('Any', '-1')], exp_ranges,
        lambda x:x[1], lambda x:x[0], selected_value, 'name="min_exp_years" id="min_exp_years" style="width:160px"')
    return exp_range_select_html
def getSalaryRangeSelectHtml(selected_value=''):
    salary_ranges = statix.getSalaryRanges()
    salary_range_select_html = hotmetal.elemSelect([('Select', '0-0')], salary_ranges,
        lambda x:x[1], lambda x:x[0], selected_value, 'name="salary_range" id="salary_range" style="width:160px"')
    return salary_range_select_html
def getIndustryCatsHtml(selected_value=''):
    industry_cats = models.IndustryCategory.objects.all()
    industry_cats_html = hotmetal.elemSelect([], industry_cats,
        lambda x:x.name, lambda x:x.name, selected_value, 'name="industry_category" id="industry_category" style="width:320px"')
    return industry_cats_html
def getLocationsSelectHtml(selected_value=''):
    locations = models.Location.objects.all().order_by('name')
    locations_select_html = hotmetal.elemSelect([('Select', '')], locations,
        lambda x:x.name, lambda x:x.name, selected_value, 'name="location" id="location" style="width:160px"')
    return locations_select_html
def handle(request):
    myself = siteaction.getLoggedInUser(request)
    if not myself:
        return HttpResponseRedirect('/login.htm')
    
    user_settings = models.UserSettings.objects.get(user=myself)
    chat_settings = models.ChatSettings.objects.get(account=myself.account)
        
    if request.method == 'GET':
        action_result = ''
        if dataplus.dictGetVal(request.REQUEST, 'flashId'):
            action_result = dataplus.dictGetVal(statix.action_messages, dataplus.dictGetVal(request.REQUEST, 'flashId'), '')
        
        online_status_select_html = hotmetal.elemSelect([('Everyone', 'everyone'), ('Friends only', 'friends'), ('Nobody', 'nobody')], [],
            lambda x:x[0], lambda x:x[1], chat_settings.online_status, 'name="online_status" id="online_status" style="width:160px;"')
        
        invite_preference_select_html = hotmetal.elemSelect([('Everyone', 'everyone'), ('Friends only', 'friends'), ('Nobody', 'nobody')], [],
            lambda x:x[0], lambda x:x[1], chat_settings.invite_preference, 'name="invite_preference" id="invite_preference" style="width:160px;"')
            
        ignored_usernames = chat_settings.ignore_list.split(',')
        ignored_accounts = []
        for username in ignored_usernames:
            try:
                ignored_accounts.append(models.Account.objects.get(username=username))
            except:
                pass
        
        ignore_list_select_html = hotmetal.elemSelect([], ignored_accounts,
            lambda x:x.name + ' (' + x.username + ')', lambda x:x.username, '', 'name="ignore_list_select" id="ignore_list_select" size="8" multiple="multiple" style="width:240px;"')
            
        skype_username = ''
        yahoo_username = ''
        for msnger in models.WebMessenger.objects.filter(account=myself.account):
            if msnger.provider == 'skype':  skype_username = msnger.username
            elif msnger.provider == 'yahoo':  yahoo_username = msnger.username
        
        return siteaction.render_to_response('me/editconnectsettings.htm',
        {'online_status_select_html': online_status_select_html,
         'custom_message': chat_settings.custom_message,
         'invite_preference_select_html': invite_preference_select_html, 
         'ignore_list_select_html': ignore_list_select_html, 
         'phone': dataplus.replaceNull(myself.phone, ''),
         'enable_voip_dial': dataplus.conditionalValue(lambda: user_settings.enable_voip_dial == True, 'checked="checked"', ''),
         'skype_username':skype_username,
         'yahoo_username':yahoo_username,
         'blog_url': dataplus.replaceNull(myself.blog_url, ''),
         'action_result':action_result,
         'myself': myself})
        
    elif request.method == 'POST':            
        action = dataplus.dictGetVal(request.REQUEST, 'action')
        if action == 'save_chat_settings':
            chat_settings.online_status = dataplus.dictGetSafeVal(request.REQUEST, 'online_status')
            chat_settings.custom_message = dataplus.dictGetSafeVal(request.REQUEST, 'custom_message')
            chat_settings.invite_preference = dataplus.dictGetSafeVal(request.REQUEST, 'invite_preference')
            chat_settings.ignore_list = dataplus.dictGetSafeVal(request.REQUEST, 'ignore_list')
            chat_settings.save()
        
            session_id = request.COOKIES['session_id']
            siteaction.updateLivewireData(session_id, myself.account)
        
        elif action == 'save_telephone_settings':
            myself.phone = dataplus.dictGetSafeVal(request.REQUEST, 'phone')
            myself.save()
            user_settings.enable_voip_dial = dataplus.dictGetVal(request.REQUEST, 'enable_voip_dial', False, lambda x:True)
            user_settings.save()
        
        elif action == 'save_messengers_settings':
            for msnger in models.WebMessenger.objects.filter(account=myself.account):
                msnger.delete()
                
            if dataplus.dictGetSafeVal(request.REQUEST, 'skype_username'):
                skype_profile = models.WebMessenger(provider='skype')
                skype_profile.account=myself.account
                skype_profile.username = dataplus.dictGetSafeVal(request.REQUEST, 'skype_username')
                skype_profile.save()
            
            if dataplus.dictGetSafeVal(request.REQUEST, 'yahoo_username'):
                #remove '@yahoo.com' if its there
                yahoo_username = dataplus.dictGetSafeVal(request.REQUEST, 'yahoo_username').partition('@')[0]
                yahoo_profile = models.WebMessenger(provider='yahoo')
                yahoo_profile.account=myself.account
                yahoo_profile.username = yahoo_username
                yahoo_profile.save()
        
        elif action == 'save_blog_settings':
            myself.blog_url = dataplus.dictGetSafeVal(request.REQUEST, 'blog_url')
            if myself.blog_url and not myself.blog_url.lower().startswith('http://'):
                myself.blog_url = 'http://' + myself.blog_url
            myself.save()
            
        return HttpResponseRedirect('/me/editconnectsettings.htm?flashId=connectset_saved')