예제 #1
0
파일: views.py 프로젝트: minrivertea/reader
def text(request, hashkey=None, words=None):
    
    if not hashkey:
        hashkey = ''.join(random.choice(string.ascii_lowercase + string.digits) for x in range(5))
        key = "text:%s" % hashkey
    
        if request.user.is_authenticated():
            user = request.user.email
        else:
            user = '******'
            
        mapping = {
            'user': user,
            'title': '', 
            'chars': words,
            'timestamp': time.time(),
            'hash': hashkey,
            'url' : '',
        }
        
        # ADD IT TO REDIS
        r_server = _get_redis()
        r_server.hmset(key, mapping)
                        
    else:
        key = 'text:%s' % hashkey
    
    
    obj = None
    if _search_redis(key, lookup=False):
        obj = _search_redis(key)
    
    if not obj:
        if request.is_ajax():
            html = render_to_string('website/problem_snippet.html', locals())
            return HttpResponse(html)
        
        return _render(request, 'website/problem.html', locals())
    
    title = 'Article'
    try:
        url = urlparse(obj['url']).netloc
    except KeyError:
        pass
        
    chars = obj['chars'].decode('utf-8') # because redis stores things as strings...
    things = _split_unicode_chrs(chars)
    obj_list = _group_words(things) 
    
    
    list_template = 'creader/text_page_snippet.html' 
    
    if request.GET.get('page'):
        template = 'creader/text_page_snippet.html'
        return render_to_response(template, locals())
        
    return _render(request, 'creader/text.html', locals())
예제 #2
0
파일: views.py 프로젝트: minrivertea/reader
def _pinyin_search(request, search_string):
    
    # CLEAN UP THE INCOMING PINYIN
    clean_string = _normalize_pinyin(search_string)
    ascii_string = _pinyin_to_ascii(search_string)
    key = settings.PINYIN_WORD_KEY % ascii_string  
        
    suggested = []
    words = [] 
    r_server = _get_redis()    
    try:
        for o in json.loads(r_server.get(key)):
            word = ChineseWord(chars=o)
            for i in word.meanings:
                
                # IF THE CLEANED SEARCH STRING AND THE CONVERTED PINYIN MATCH
                if _normalize_pinyin(i['pinyin']) == clean_string:
                    words.append(word)
                    
                # IF THERE'S NO NUMBERS IN THE CLEANED_STRING, ADD IT
                elif not any(ext in clean_string for ext in ['1', '2', '3', '4', '5']):
                    words.append(word)
                
                else:
                    suggested.append(word)
    except TypeError:
        pass
    
                     
    return _render(request, 'website/wordlist.html', locals())
예제 #3
0
파일: views.py 프로젝트: minrivertea/reader
def _english_search(request, search_string):

    r_server = _get_redis()
    words = []
    
    try:
        key = settings.ENGLISH_WORD_KEY % (len(search_string.split(' ')), search_string.lower())
        obj = json.loads(r_server.get(key))
        for x in obj['characters']:
            words.append(ChineseWord(chars=x))
    except TypeError:
        # split up the string and search each word individually
        pass
    
    suggested = []
    for x in search_string.split(' '):
        try:
            key = settings.ENGLISH_WORD_KEY % (len(x.split(' ')), x.lower())
            obj = json.loads(r_server.get(key))
            for x in obj['characters']:
                suggested.append(ChineseWord(chars=x))
        except TypeError:
            pass
  
    return _render(request, 'website/wordlist.html', locals())
예제 #4
0
파일: views.py 프로젝트: minrivertea/reader
def login(request, template_name='registration/login.html',
          redirect_field_name=REDIRECT_FIELD_NAME,
          authentication_form=CustomAuthenticationForm,
          current_app=None, extra_context=None):

        
    redirect_to = request.POST.get(redirect_field_name,
                                   request.GET.get(redirect_field_name, ''))

    if request.method == "POST":
        form = authentication_form(request, data=request.POST)
        if form.is_valid():
            
            # Ensure the user-originating redirection url is safe.
            if not is_safe_url(url=redirect_to, host=request.get_host()):
                redirect_to = resolve_url(settings.LOGIN_REDIRECT_URL)

            # Okay, security check complete. Log the user in.
            from django.contrib.auth import login
            login(request, form.get_user())

            return HttpResponseRedirect(redirect_to)

    else:
        form = authentication_form(request)


    context = {
        'form': form,
        redirect_field_name: redirect_to,
    }
    if extra_context is not None:
        context.update(extra_context)
    return _render(request, template_name, context)
예제 #5
0
파일: views.py 프로젝트: minrivertea/reader
def stats(request):
    
    if request.user.is_superuser:
        users = User.objects.all()
    else:
        users = User.objects.filter(email=request.user.email)
        
    return _render(request, 'website/stats.html', locals())
예제 #6
0
파일: views.py 프로젝트: minrivertea/reader
def review_new(request):

    words = request.user.get_review_items()
    items = []
    for x in words:
        thing = {}
        thing['word'] = ChineseWord(chars=x['chars'])
        thing['personal'] = x
        items.append(thing)
        
    return _render(request, 'srs/review_new.html', locals())
예제 #7
0
파일: views.py 프로젝트: minrivertea/reader
def single_word(request, chars):
   
    word = ChineseWord(chars)
                    
    # chars = _split_unicode_chrs(smart_unicode(word['chars']))
    
    if request.user.is_authenticated():
        word_viewed.send(
                    sender=word_viewed, 
                    word=word, 
                    time=datetime.datetime.now(), 
                    user_id=request.user.email
                )
    
    return _render(request, 'cedict/single.html', locals())   
예제 #8
0
파일: views.py 프로젝트: minrivertea/reader
def url(request):
    # TODO if it's already been scanned and saved, don't bother parsing it again….
    
    if request.GET.get('url'):
        url = request.GET.get('url')
        
        # PARSE THE WEBPAGE AND RETURN A LIST OF CHARACTERS
        html = urllib2.urlopen(url).read()
        text = readabilityParser(html)
        title = Document(html).title() 
        new_text = strip_tags(text)
        
        # GIVE IT AN ID
        this_id = ''.join(random.choice(string.ascii_lowercase + string.digits) for x in range(5))
        key = "text:%s" % this_id
    
        if request.user.is_authenticated():
            user = request.user.email
        else:
            user = '******'
            
        mapping = {
            'user': user,
            'title': title, 
            'chars': new_text,
            'timestamp': time.time(),
            'hash': this_id,
            'url' : url,
        }
        
        # ADD IT TO REDIS
        r_server = _get_redis()
        r_server.hmset(key, mapping)
        
        if request.user.is_authenticated():
            article_saved.send(sender=article_saved, article_id=this_id, time=time.time(), user_id=request.user.pk)
    
        return HttpResponseRedirect(reverse('text', args=[this_id]))
    else:
        
        problem = "TODO: Make a proper page here which explains the reader and how it works"
        return _render(request, 'website/problem.html', locals())  
예제 #9
0
파일: views.py 프로젝트: minrivertea/reader
def view_wordlist(request):
    return _render(request, 'users/wordlist.html', locals())
예제 #10
0
파일: views.py 프로젝트: minrivertea/reader
def search_starts_with(request, word):
    words = ChineseWord()._starts_with(word)
    return _render(request, 'website/wordlist.html', locals())     
예제 #11
0
파일: views.py 프로젝트: minrivertea/reader
def get_examples(request, word):
    
    words = ChineseWord().starting_with(word)
    print words
        
    return _render(request, 'website/examples.html', locals())
예제 #12
0
파일: views.py 프로젝트: minrivertea/reader
def test(request):
    
    # COLLECT THE WORDS
    words = request.user.get_test_items()
        
    # DECIDE HOW TO TEST THE ITEMS
    items = []
    count = 1
    for x in words:

        to_test = []
        testing = ['pinyin', 'characters', 'meaning']  
               
        
        for t in testing:
            
            # work out what level we should test this item at
            level = int( x.get(('%s_test_level' % t), 0))
            if level < settings.MAX_TEST_LEVEL and x.get(('%s_pass' % t), False):
                level += 1
            
            # setup some values           
            vals = {}
            vals['level'] = level
            vals['testing'] = t
            to_test.append(vals)
        
        # randomly decide which item to test this time.
        test = random.choice(to_test)
        word = ChineseWord(chars=x['chars'])
        
                
        # PREPARE THE CHOICES
        for m in word.meanings:
            
            test['choices'] = []
            test['chars'] = word.chars
            
            # PINYIN CHOICES
            if test['testing'] == 'pinyin':
                
                test['main'] = word.chars
                test['other'] = m['meaning']
                test['answer'] = m['pinyin']
                test['choices'].append(m['pinyin_numbered'])
                
                
                # EASY
                if test['level'] == 0:
                    new = ChineseWord()._get_random(number=1, chars=word.chars)['meanings'][0]
                    test['choices'].append(new['pinyin_numbered'])
                
                # MEDIUM
                if test['level'] == 1:
                    test['choices'].append( _alt_pinyin(m['pinyin_numbered']) )
                    
        
            # CHARACTER CHOICES
            if test['testing'] == 'characters':
                
                test['main'] = m['pinyin']
                test['other'] = m['meaning']
                test['answer'] = word.chars
                test['choices'].append(word.chars)
                
                # EASY
                if test['level'] == 0:
                    new = ChineseWord()._get_random(number=1, chars=word.chars)
                    test['choices'].append( new['chars'] )
                
                # MEDIUM
                if test['level'] == 1:
                    new = ChineseWord()._get_random(number=1, chars=word.chars)
                    test['choices'].append( new['chars'] )
            
            
            # MEANING CHOICES
            if test['testing'] == 'meaning':
                test['main'] = word.chars
                test['other'] = m['pinyin']
                test['answer'] = m['meaning']
                test['choices'].append(m['meaning'])
                
                # EASY
                if test['level'] == 0:
                    new = ChineseWord()._get_random(number=1, chars=word.chars)['meanings'][0]
                    test['choices'].append( new['meaning'] )
                
                # MEDIUM
                if test['level'] == 1:
                    new = ChineseWord()._get_random(number=1, chars=word.chars)['meanings'][0]
                    test['choices'].append( new['meaning'] )
            
            random.shuffle(test['choices'])
                
        
                       
        html = render_to_string(
            'srs/tests/base_test.html', 
            {'test': test,}, 
            context_instance=RequestContext(request)
        )
        

        # if we get here, add it to the items list
        if html:
            count += 1
            items.append(html)
                
    return _render(request, 'srs/test.html', locals())
예제 #13
0
파일: views.py 프로젝트: minrivertea/reader
def search(request, search_string=None, title='Search', words=None):
    
    r_server = _get_redis()
        
    # replace search string underscores with spaces
    if search_string:
        search_string = search_string.strip().replace('_', ' ')        
               

    # HANDLES EMPTY OR NULL SEARCH STRING
    if search_string == None and request.method != 'POST':
        form = SearchForm()
        return _render(request, 'website/search.html', locals())
          
          
    # CHECK IF IT'S A POST REQUEST OR URL SEARCH
    if search_string == None and request.method == 'POST':
        form = SearchForm(request.POST)
        if form.is_valid():
            search_string = form.cleaned_data['char']

        else:
            # POST AND NO SEARCH STRING - SHOW THEM THE PLAIN JANE SEARCH PAGE
            form = SearchForm()
            return _render(request, 'website/search.html', locals())


    # HANDLES AN AMBIGUOUS SEARCH
    if _is_ambiguous(search_string):
        message = messages.AMBIGUOUS_WORD
        return render(request, 'problem.html', locals())


    if r_server.exists((settings.PINYIN_WORD_KEY % _pinyin_to_ascii(search_string))):  
        return _pinyin_search(request, search_string)


    if _is_english(search_string):
        return _english_search(request, search_string)


    # IF THE SEARCH IS OVER 10 CHARACTERS, RETURN A TEXT
    #if len(search_string) > 12:
    #    from creader.views import text                
    #    return text(request, words=search_string)
    
    
    if not words:
        things = _split_unicode_chrs(search_string)        
        words = _group_words(things)   

        
    # IF THE USER WAS LOGGED IN, RECORD IT IN THEIR 'SAVED WORDS'
    if request.user.is_authenticated():
        for x in words:
            word_searched.send(
                sender=word_searched, 
                word=x.chars, 
                time=datetime.datetime.now(), 
                user_id=request.user.email
            )
    
    
    # if there's only 1 word, take us straight to the single word definition
    if len(words) == 1:
        word = words[0]
        url = reverse('single_word', args=[word])
        return HttpResponseRedirect(url)
    
    return _render(request, 'website/wordlist.html', locals())
예제 #14
0
파일: views.py 프로젝트: minrivertea/reader
def page(request, slug):
    template = 'website/pages/%s.html' % slug
    return _render(request, template, locals())
예제 #15
0
파일: views.py 프로젝트: minrivertea/reader
def search_contains(request, word):
    words = ChineseWord()._contains(word)    
    return _render(request, 'website/wordlist.html', locals())
예제 #16
0
파일: views.py 프로젝트: minrivertea/reader
def home(request):
    return _render(request, 'website/home.html', locals())
예제 #17
0
파일: views.py 프로젝트: minrivertea/reader
def user(request):
    return _render(request, 'users/user.html', locals())