예제 #1
0
def get_redact_notes(request):
    request_user = basicauth_get_user_by_emailaddr(request)
    if not request_user:
        logevent(request, 'ActivityLog.create POST', 401,
                 jv3.utils.decode_emailaddr(request))
        response = HttpResponse(
            JSONEncoder().encode(
                {'autherror': "Incorrect user/password combination"}),
            "text/json")
        response.status_code = 401
        return response

    ## Filter out notes that have already been redacted
    notes = Note.objects.filter(
        owner=request_user).order_by("-created").exclude(jid=-1).exclude(
            contents="")
    numNotes = len(notes)
    userRedactedNotes = RedactedNote.objects.filter(owner=request_user)

    for redactedNote in userRedactedNotes:
        notes = notes.exclude(version=redactedNote.version,
                              jid=redactedNote.jid)
        pass
    numNotesLeft = len(notes)
    ndicts = [extract_zen_notes_data(note) for note in notes]
    allNotes = []
    for note in ndicts:
        allNotes.append({
            "jid": note['jid'],
            "version": note['version'],
            "contents": note['noteText'],
            "deleted": note['deleted'],
            "created": str(note['created']),
            "edited": str(note['edited'])
        })
    resultMap = {
        'markAsRemoved': {},
        'markAsName': {},
        'markAsPassword': {},
        'markAsPhone': {}
    }
    redactedWordArray = WordMap.objects.filter(owner=request_user)
    for wMap in redactedWordArray:
        if wMap.wordType in resultMap:
            resultMap[wMap.wordType][wMap.privWord] = True
        pass

    userMeta = {
        'userPoints': "0",
        'totalNotes': str(numNotes),
        'numNotesLeft': str(numNotesLeft)
    }
    response = HttpResponse(
        JSONEncoder().encode({
            'notes': allNotes,
            'wordMapIndices': resultMap,
            'userMeta': userMeta
        }), "text/json")
    response.status_code = 200
    return response
예제 #2
0
def find_locations_in_radius(request):
    """
    Determines the coordinates of the input address and finds all active
    locations within the specified radius.  The results are returned as a JSON
    object.
    """

    # This view should only be requested via an HTTP POST + XHR request
    if not (request.method == 'POST' and request.is_ajax()):
        raise Http404

    json = JSONEncoder()

    # snag some needed info from the request
    address = request.POST.get('address', '')
    radius = float(request.POST.get('radius', 25))

    try:
        # TODO: figure out how to make this better when more than one result
        # is retrieved
        coords = utils.get_coordinates(address=address)
    except StopIteration:
        # this happens if no matches were found
        err = {'error': 'Please enter a valid location!'}
        return render_to_response('reploc/json.js',
                                  {'json': json.encode(err)})

    lat1, lng1 = float(coords[0]), float(coords[1])

    # put stuff into a dictionary
    data = {'center': {
                'address': address,
                'lat': lat1,
                'lng': lng1
            },
            'locations': []}

    # this number is used a lot.  I'm not math wiz, so I have no idea what it's
    # used for, but my guess is that it has something to do with trig (which I
    # conveniently skipped in school)
    C = 57.2958

    # iterate over all active locations
    for location in Location.objects.active():
        lat2, lng2 = location.coordinates

        # check the distance between the center and the location
        # source: http://www.meridianworlddata.com/Distance-Calculation.asp
        dist = 3963.189 * acos(sin(lat1 / C) * sin(lat2 / C) + cos(lat1 / C) \
                * cos(lat2 / C) * cos(lng2 / C - lng1 / C))

        # if the location is within the radius of the input address, add it to
        # our collection
        if dist <= radius:
            data['locations'].append(jsonify_location(location))

    # send everything back as a JSON object
    return render_to_response('reploc/json.js',
                              {'json': json.encode(data)},
                              mimetype='text/javascript')
예제 #3
0
def get_json_notes(request):
    request_user = basicauth_get_user_by_emailaddr(request)
    if not request_user:
        logevent(request, 'ActivityLog.create POST', 401,
                 jv3.utils.decode_emailaddr(request))
        response = HttpResponse(
            JSONEncoder().encode(
                {'autherror': "Incorrect user/password combination"}),
            "text/json")
        response.status_code = 401
        return response

    ## Filter out notes that have already been redacted
    notes = _filter_dupes(
        request_user.note_owner.filter(deleted=0).order_by("-created"))

    ndicts = [extract_zen_notes_data(note) for note in notes]
    allNotes = []
    for note in ndicts:
        allNotes.append({
            "jid": note['jid'],
            "version": note['version'],
            "contents": note['noteText'],
            "deleted": note['deleted'],
            "created": str(note['created']),
            "edited": str(note['edited'])
        })

    allNotes.sort(lambda x, y: cmp(x['created'], y['created']))

    response = HttpResponse(JSONEncoder().encode({"notes": allNotes}),
                            "text/json")
    response.status_code = 200
    return response
예제 #4
0
def get_locations(request):
    """
    Retrieves all locations for all active representatives and returns the
    collection as a JSON object.
    """

    locations = Location.objects.active()
    json = JSONEncoder()

    data = {'locations': [jsonify_location(l) for l in locations]}

    return render_to_response('reploc/json.js',
                              {'json': json.encode(data)},
                              mimetype='text/javascript')
예제 #5
0
파일: views.py 프로젝트: bingwen/ring
 def default(self, obj):
     if isinstance(obj, QuerySet):
         # `default` must return a python serializable
         # structure, the easiest way is to load the JSON
         # string produced by `serialize` and return it
         return loads(serialize('json', obj))
     return JSONEncoder.default(self,obj)
예제 #6
0
def get_iphone(request):
    request_user = basicauth_get_user_by_emailaddr(request)
    if not request_user:
        logevent(request, 'ActivityLog.create POST', 401,
                 jv3.utils.decode_emailaddr(request))
        response = HttpResponse(
            JSONEncoder().encode(
                {'autherror': "Incorrect user/password combination"}),
            "text/json")
        response.status_code = 401  ## removed semi-colon??
        return response

    notes = sort_user_notes(request_user)

    numNotes = len(notes)
    startIndex = int(request.GET.get("START_INDEX", 0))
    endIndex = int(request.GET.get("END_INDEX", None))
    if not endIndex:
        endIndex = numNotes
    notesLeft = numNotes - endIndex

    ndicts = [
        extract_zen_notes_data(note) for note in notes[startIndex:endIndex]
    ]
    deltaIndex = endIndex - startIndex
    htmlblob = "\n".join([
        "<li><div name='note' style='overflow:hidden;' id='%(jid)s' edited='%(edited)s' created='%(created)s' version='%(version)s' deleted='%(deleted)s' pk='%(pk)s' onClick='gid(\"%(jid)s\").blur(); zenNoteView.noteClicked(\"%(jid)s\")'><pre>%(noteText)s</pre></div></li>"
        % n for n in ndicts
    ])  # onBlur='zenNoteView.noteBlur(\"%(jid)s\")'
    if notesLeft > 0:  ## height:25px was in style for new notes (=2 lines visible without pre tags)
        htmlblob += "<li><div id='reqMore'><button id='requestMore' onClick='zenAjax.requestMore()'>Get %s of %s more notes</button></div></li>" % (
            min(deltaIndex, notesLeft), notesLeft)
    response = HttpResponse(htmlblob, 'text/html')
    response.status_code = 200
    return response
예제 #7
0
    def __init__(self, source, options={}, attrs={}, func_display=False):
        """source can be a list containing the autocomplete values or a
        string containing the url used for the XHR request.
        
        For available options see the autocomplete sample page::
        http://jquery.bassistance.de/autocomplete/"""

        self.source = source
        self.func_display = func_display

        if len(options) > 0:
            #self.options = JSONEncoder().encode(options)
            opt_list = []

            for k, v in options.items():
                opt = '"%s":' % k

                if k == 'select':
                    opt += v
                elif type(v) == types.StringType:
                    opt += '"%s"' % v
                else:
                    opt += JSONEncoder().encode(v)

                opt_list.append(opt)

            self.options = '{%s}' % (','.join(opt_list))

        self.attrs.update(attrs)
예제 #8
0
    def default(self, obj):

        # if it's a NoneType, return ""
        if type(obj) is types.NoneType:
            return Objectify("")

        # if it's a queryset, it's easy
        if isinstance(obj, QuerySet):
            return [Objectify(o) for o in obj]

        # maybe it's a normal object
        try:
            return JSONEncoder.default(self, obj)

        except TypeError, e:

            # maybe it's a Django object with an obj() method
            try:
                return obj.obj()
            except AttributeError:

                # maybe it's a Django object without an obj() method
                try:
                    return loads(serialize('json', [obj]))

                # OK, I give up
                except Exception, e:
                    return None
예제 #9
0
def default_getstate(obj):
    try:
        return obj.__getstate__()
    except AttributeError:
        # TODO: Fix this, must raise exception somehow
        from django.utils.simplejson import JSONEncoder
        return JSONEncoder.default(None, obj)
예제 #10
0
    def default(self, obj):
        if isinstance(obj, datetime.datetime) or isinstance(obj, datetime.date):
            return obj.isoformat()
        if isinstance(obj, object):
            return dict(filter(lambda (x,y): not x.startswith('_'), obj.__dict__.items()))

        return JSONEncoder.default(self, obj)
예제 #11
0
def get_active_users(request):
    """
    Retrieves a list of active users which is returned as plain JSON for
    easier manipulation with JavaScript.
    """
    if request.is_ajax():
        active = Visitor.objects.active().reverse()
        now = datetime.now()

        # we don't put the session key or IP address here for security reasons
        try:
            data = {'users': [{
                    'id': v.id,
                    #'user': uc(v.user),
                    'user_agent': uc(v.user_agent),
                    'referrer': uc(v.referrer),
                    'url': uc(v.url),
                    'page_views': v.page_views,
                    'geoip': v.geoip_data_json,
                    'last_update': (now - v.last_update).seconds,
                    'friendly_time': ', '.join(friendly_time((now - v.last_update).seconds)),
                } for v in active]}
        except:
            log.error('There was a problem putting all of the visitor data together:\n%s\n\n%s' % (traceback.format_exc(), locals()))
            return HttpResponse(content='{}', mimetype='text/javascript')

        response = HttpResponse(content=JSONEncoder().encode(data),
                                mimetype='text/javascript')
        response['Content-Length'] = len(response.content)

        return response

    # if the request was not made via AJAX, raise a 404
    raise Http404
예제 #12
0
def report(req):
    g = req.GET

    # check that the required fields
    # were all provided, or raise
    try:
        sc = g["sc"]
        qx_num = int(g["qx"])
        qy_num = int(g["qy"])

    except KeyError:
        return HttpResponse("Required fields: sc, qx, qy",
                            content_type="text/plain",
                            status=400)

    except ValueError:
        return HttpResponse("Invalid question number(s)",
                            content_type="text/plain",
                            status=400)

    # resolve the section code into a Section
    # object, question numbers into Questions
    section = Section.objects.get(code=sc)
    qx = section.questions.get(number=qx_num)
    qy = section.questions.get(number=qy_num)

    # fetch and check the
    # values of optional fields
    qx_type = getattr(Answer, g.get("tx", "str").upper())
    qy_type = getattr(Answer, g.get("ty", "str").upper())

    # find all of the submissions which have answers
    # to both question-x and question-y. if either
    # are missing, we can't draw any correlation,
    # so omit the data altogether
    submissions = [(subm, subm.answers.get(question__number=qx_num),
                    subm.answers.get(question__number=qy_num))
                   for subm in Submission.objects.filter(section__code=sc)
                   if subm.answers.filter(
                       question__number__in=[qx_num, qy_num]).count() == 2]

    graph_data = [(ans_x.normalized(qx_type), ans_y.normalized(qy_type))
                  for subm, ans_x, ans_y in submissions]

    graph_data_json =\
        JSONEncoder().encode(
            graph_data)

    return render_to_response(
        req, "questions/report.html", {
            "graph_data": graph_data_json,
            "submissions": submissions,
            "question_x": qx,
            "question_y": qy
        })

    return HttpResponse("subm: %r\nans: %r" %
                        (list(submissions), list(answers)),
                        content_type="text/plain")
예제 #13
0
 def default(self, obj):
     if isinstance(obj, datetime.datetime):
         return unicode(obj)
     if isinstance(obj, ValuesQuerySet):
         return list(obj)
     if isinstance(obj, QuerySet):
         return loads(serialize('json', obj))
     return JSONEncoder.default(self, obj)
예제 #14
0
 def _handle_max_log_request(self, user, clientid):
     ## return the max id (used by the client to determine which recordsneed to be retrieved.)
     maxdate, count = self._get_max_helper(user, clientid)
     print "  returning ", maxdate, count
     return HttpResponse(JSONEncoder().encode({
         'value': long(maxdate),
         'num_logs': long(count)
     }))
예제 #15
0
def default_getstate(obj):
    try:
        return obj.__getstate__()
    except AttributeError:
        # TODO: Fix this, must raise exception somehow
        from django.utils.simplejson import JSONEncoder

        return JSONEncoder.default(None, obj)
예제 #16
0
파일: jsonencoder.py 프로젝트: patsy/gypsum
    def default(self, obj):
        if isinstance(obj, datetime.datetime):
            return obj.strftime('%Y-%m-%d %H:%M:%S')
        if isinstance(obj, datetime.date):
            return obj.strftime('%Y-%m-%d')
        if isinstance(obj, object):
            return obj.__dict__

        return JSONEncoder.default(self, obj)
예제 #17
0
def dailyCounts(request,set,relevant_date_accessor):
    counts = {}
    for i in range(set.count()):
        item = set[i]
        day = int(int(relevant_date_accessor(item))/(24*60*60*1000.0))*24*60*60*1000
        counts[day] = counts.get(day,0) + 1;
    response = HttpResponse(JSONEncoder().encode(counts), "text/json")
    response.status_code = 200;
    return response
예제 #18
0
    def read(self,request):
        request_user = authenticate_user(request);
        if not request_user:
            return self.responder.error(request, 401, ErrorDict({"autherror":"Incorrect user/password combination"}))

        if (request.GET['type'] == 'get_max_log_id'):
            clientid = self._get_client(request)                    
            ## "what is the last thing i sent?"
            try:
                return self._handle_max_log_request(request_user,clientid);
            except:
                print sys.exc_info()
                logging.error(str(sys.exc_info()))
            return HttpResponse(JSONEncoder().encode({'value':0, 'num_logs':0}))            

        ## retrieve the entire activity log
        ## return self.responder.list(Event.objects.filter(owner=request_user), qs_user)                
        return HttpResponse(JSONEncoder().encode([]), self.responder.mimetype)
예제 #19
0
파일: views.py 프로젝트: copyliu/mj_ranking
 def default(self, obj):
     if isinstance(obj, QuerySet):
         # `default` must return a python serializable
         # structure, the easiest way is to load the JSON
         # string produced by `serialize` and return it
         return loads(serialize('json', obj))
     if isinstance(obj, models.Model):
         return dict([(attr, getattr(obj, attr)) for attr in [f.name for f in obj._meta.fields]])
     return JSONEncoder.default(self, obj)
예제 #20
0
 def getJSONData(self, model_list, sEcho, total_records):
     data = {"sEcho": sEcho, "iTotalRecords": total_records, "iTotalDisplayRecords": total_records}
     item = []
     for model in model_list:
         item.append(model.to_dict())
     data.update({"aaData": item})
     jsonstr = JSONEncoder().encode(data)
     return jsonstr
     
예제 #21
0
def get_zen(request):
    iphone = True
    request_user = basicauth_get_user_by_emailaddr(request)
    if not request_user:
        logevent(request, 'ActivityLog.create POST', 401,
                 jv3.utils.decode_emailaddr(request))
        response = HttpResponse(
            JSONEncoder().encode(
                {'autherror': "Incorrect user/password combination"}),
            "text/json")
        response.status_code = 401  ## removed semi-colon??
        return response

    notes = sort_user_notes(request_user)

    startIndex = int(request.GET.get("START_INDEX", 0))
    noteLength = len(notes)
    endIndex = int(request.GET.get("END_INDEX", -1))
    if endIndex == -1:
        iphone = False
        endIndex = noteLength

    additionalNotesWaiting = True
    if iphone and (endIndex >= noteLength):
        additionalNotesWaiting = False

    ## make magic happen
    ndicts = [
        extract_zen_notes_data_extras(note)
        for note in notes[startIndex:endIndex]
    ]
    deltaIndex = endIndex - startIndex

    iconType = request.GET.get("ICON", 'none')
    if iconType == 'X':  ## For zen site
        ##print "Called from /zen/ site"
        htmlblob = "\n".join([
            "<div class='note' name='%(archiveState)s' style='display:%(startVisibility)s'><img class='deleteX' src='x.png' alt='Delete' onClick='zenNoteAjax.saveEditedNote(\"%(jid)s\", true)'/> <textarea name='note' id='%(jid)s' edited='%(edited)s' created='%(created)s' version='%(version)s' deleted='%(deleted)s' pk='%(pk)s' onFocus='zenNoteView.noteClicked(\"%(jid)s\")' cols='%(col)s' rows='%(row)s' hasFocus='false' hasSelect='false' onBlur='zenNoteView.noteBlur(\"%(jid)s\")' style='overflow:hidden'>%(noteText)s</textarea></div>"
            % n for n in ndicts
        ])
    else:  ## For tags site
        ##print "Called from /tags/ site"
        htmlblob = "\n".join([
            "<div class='note' name='%(archiveState)s' style='display:%(startVisibility)s'><img class='deleteX' src='arrow-left.png' alt='Delete' onMouseOver='zenNoteView.dispNoteOptions(\"%(jid)s\", true)' onmouseout=\"zenNoteView.noteOptions.startTimer();\"/> <textarea name='note' id='%(jid)s' edited='%(edited)s' created='%(created)s' version='%(version)s' deleted='%(deleted)s' pk='%(pk)s' onFocus='zenNoteView.noteClicked(\"%(jid)s\")' cols='%(col)s' rows='%(row)s' hasFocus='false' hasSelect='false' onBlur='zenNoteView.noteBlur(\"%(jid)s\")' style='overflow:hidden'>%(noteText)s</textarea></div>"
            % n for n in ndicts
        ])

    if iphone and additionalNotesWaiting:
        htmlblob += "\n <button id='requestMore' onClick='zeniPhone.requestMore()'>Get %s more notes</div>" % (
            deltaIndex)
    elif iphone:
        htmlblob += "\n <button id='requestMore' style='display:none' onClick='zeniPhone.requestMore()'>Get %s more notes</div>" % (
            deltaIndex)
    response = HttpResponse(htmlblob, 'text/html')
    response.status_code = 200
    return response
예제 #22
0
def post_json_chrome_logs(request):
    """
    Record Chrome usage logs, return timestamp of last log recorded.
    """
    request_user = basicauth_get_user_by_emailaddr(request)
    if not request_user:
        logevent(request, 'post_json_chrome_logs POST', 401,
                 jv3.utils.decode_emailaddr(request))
        response = HttpResponse(
            JSONEncoder().encode(
                {'autherror': "Incorrect user/password combination"}),
            "text/json")
        response.status_code = 401
        return response

    payload = JSONDecoder().decode(request.raw_post_data)
    logs = payload
    timestamp = 0
    for log in logs:
        # Save each log, keep track of latest log's timestamp.
        # keys: time, action, noteid (>0 or -10), info (JSON string)
        # ext only: tabid (chrome ext tab), url (of focused tab)
        entry = ChromeLog()
        entry.owner = request_user
        entry.when = log['time']
        timestamp = max(entry.when, timestamp)
        entry.action = log['action']
        entry.noteid = log.get("noteid", None)
        entry.info = log.get("info", None)
        entry.url = log.get("url", None)
        entry.tabid = log.get("tabid", None)
        ## added in new rev
        entry.save()

    ## Return Response!
    response = HttpResponse(
        JSONEncoder().encode({
            "lastTimeRecorded": timestamp,
        }), "text/json")
    response.status_code = 200
    return response
예제 #23
0
def create_fake_complete_movie(request):
    """
        INPUT :
            None
        OUTPUT :
            Create_Fake_Movie_WF's 
    """
    wf = Create_Fake_Movie_WF({}, None)
    result = wf.work()
    return HttpResponse(JSONEncoder().encode(", ".join([result["status"],
                                            str(result["already-existed"]),
                                            str(result["time-to-serve"])])))
예제 #24
0
    def render_js(self, field_id):
        if isinstance(self.source, list):
            source = JSONEncoder().encode(self.source)
        elif isinstance(self.source, str):
            source = "'%s'" % escape(self.source)
        else:
            raise ValueError('source type is not valid')

        options = ''
        if self.options:
            options += ',%s' % self.options
        return u"""jQuery('#%s').autocomplete(%s%s);""" % (field_id, source, options)
예제 #25
0
def get_survey(request):
    # generates a personalized survey based on the contents of survey
    import jv3.study.survey
    cookie = request.GET['cookie']
    (user,
     registration) = get_user_and_registration_from_cookie(cookie, request)

    if not user:
        print "no such user from cookie %s " % request.GET['cookie']
        response = render_to_response('/500.html')
        response.status_code = 500
        return response

    questions = []
    survey = jv3.study.survey.get_survey_for_user(user)

    if not survey:
        print "no survey for user %s " % repr(user)
        response = render_to_response('/404.html')
        response.status_code = 404
        return response

    for q in survey:
        questions.append(q)
        if q.has_key("qid") and len(
                jv3.models.SurveyQuestion.objects.filter(user=user,
                                                         qid=q["qid"])) == 0:
            ## allocate a placeholder in the database to store our result
            q_model = jv3.models.SurveyQuestion()
            q_model.qid = q["qid"]
            q_model.user = user
            q_model.response = ""
            q_model.save()
        elif q.has_key("qid"):
            for sq in jv3.models.SurveyQuestion.objects.filter(user=user,
                                                               qid=q["qid"]):
                q['response'] = sq.response
        else:
            ## textual
            pass

    return HttpResponse(
        get_template("jv3/surveyform.html").render({}) % {
            'email': user.email,
            'first_name': registration.first_name,
            'last_name': registration.last_name,
            'server': settings.SERVER_URL,
            'cookie': cookie,
            'questions': unicode(JSONEncoder().encode(questions))
        }, "text/html")
예제 #26
0
 def default(self, obj):
     if isinstance(obj, QuerySet):
         # `default` must return a python serializable
         # structure, the easiest way is to load the JSON
         # string produced by `serialize` and return it
         return loads(serialize('json', obj))
     if isinstance(obj, models.Model):
         #do the same as above by making it a queryset first
         set_obj = [obj]
         set_str = serialize('json', set_obj)
         #eliminate brackets in the beginning and the end 
         str_obj = set_str[1:len(set_str)-2]
         return str_obj
     return JSONEncoder.default(self,obj)
예제 #27
0
파일: widgets.py 프로젝트: patfreeman/ocemr
    def __init__(self, source, options={}, attrs={}):
        """source can be a list containing the autocomplete values or a
		string containing the url used for the XHR request.

		For available options see the autocomplete sample page::
		http://jquery.bassistance.de/autocomplete/"""

        self.options = {'matchContains': 'true', 'minChars': '2'}
        self.attrs = {'autocomplete': 'off'}
        self.source = source
        if len(options) > 0:
            self.options = JSONEncoder().encode(options)

        self.attrs.update(attrs)
예제 #28
0
    def read(self, request):
        request_user = basicauth_get_user_by_emailaddr(request)
        if not request_user:
            logevent(request, 'ActivityLog.read', 401,
                     {"requesting user:"******"autherror": "Incorrect user/password combintion"}))

        clientid = self._get_client(request)
        if (request.GET['type'] == 'get_max_log_id'):
            ## "what is the last thing i sent?"
            try:
                return self._handle_max_log_request(request_user, clientid)
            except:
                print sys.exc_info()
                logging.error(str(sys.exc_info()))
            return HttpResponse(JSONEncoder().encode({
                'value': 0,
                'num_logs': 0
            }))

        return HttpResponse(JSONEncoder().encode([]), self.responder.mimetype)
예제 #29
0
def get_detailed_infos_for_movie(request):
    """
        INPUT :
            movie-id
        OUTPUT :
            Get_Detailed_Infos_For_Movie_Model_WF's output
    """
    start = datetime.now()
    if request.method == "GET": HttpResponse("POST excepted")
    details_wf = Get_Detailed_Infos_For_Movie_Model_WF(request.POST, None)
    result = details_wf.work()
    result["time-to-serve"] += datetime.now() - start
    
#    return render_to_response("template_url", JSONEncoder().encode(str(result)))
    return HttpResponse(JSONEncoder().encode(str(result)))
예제 #30
0
 def default(self, obj):
     """
     Transform obj into a serializable object 
     """      
     if isinstance(obj, QuerySet):
         return list(obj)
     elif obj.__class__.__name__=='Pin' or obj.__class__.__name__=='User':
         return obj.__dict__
     elif isinstance(obj, datetime.datetime):
         return {'year':obj.year,'month':obj.month,'day': obj.day}
     elif isinstance(obj, Model):
         d=obj.__dict__
         del d['_state']
         return d
     return JSONEncoder.default(self,obj)
예제 #31
0
    def __init__(self, source, options={}, attrs={}):
        """source can be a list containing the autocomplete values or a
        string containing the url used for the XHR request.
        
        For available options see the autocomplete sample page::
        http://jquery.bassistance.de/autocomplete/   
        http://www.djangosnippets.org/snippets/233/"""

        self.options = None
        self.attrs = {'autocomplete': 'off'}
        self.source = source
        if len(options) > 0:
            self.options = JSONEncoder().encode(options)

        self.attrs.update(attrs)
예제 #32
0
def list_ajax(request, query, limit):
    users = request.user.get_permitted_objects("LIST", Contact).filter(
        Q(username__startswith=query) | Q(surname__istartswith=query)
        | Q(name__istartswith=query) | Q(mail__istartswith=query))[:limit]

    users = [{
        'id':
        user.id,
        'label':
        "%s (%s)" % (user.username,
                     ("%s %s" % (user.name, user.surname)).strip()),
        'value':
        user.username
    } for user in users]
    return HttpResponse(JSONEncoder().encode(users),
                        mimetype='application/json')
예제 #33
0
    def __init__(self, source, options={}, attrs={}):
        """source can be a list containing the autocomplete values or a
        string containing the url used for the XHR request.

        For available options see the autocomplete sample page::
        sources: http://bassistance.de/jquery-plugins/jquery-plugin-autocomplete/
        demo: http://jquery.bassistance.de/autocomplete/
        """

        self.options = None
        self.attrs = {'autocomplete': 'on'}
        self.source = source
        if len(options) > 0:
            self.options = JSONEncoder().encode(options)

        self.attrs.update(attrs)
예제 #34
0
 def default(self, obj):
     if isinstance(obj, QuerySet):
         # `default` must return a python serializable
         # structure, the easiest way is to load the JSON
         # string produced by `serialize` and return it
         return serialize('python', obj)
     if isinstance(obj, models.Model):
         # do the same as above by making it a queryset first
         set_obj = [obj]
         set_str = serialize('python', set_obj)
         return set_str[0]
     if isinstance(obj, datetime.datetime):
         return time.mktime(obj.timetuple())
     if isinstance(obj, datetime.date):
         return time.mktime(obj.timetuple())
     return JSONEncoder.default(self, obj)
예제 #35
0
 def default(self, obj):
     if isinstance(obj, QuerySet):
         # `default` must return a python serializable
         # structure, the easiest way is to load the JSON
         # string produced by `serialize` and return it
         return serialize('python', obj)
     if isinstance(obj, models.Model):
         # do the same as above by making it a queryset first
         set_obj = [obj]
         set_str = serialize('python', set_obj)
         return set_str[0]
     if isinstance(obj, datetime.datetime):
         return time.mktime(obj.timetuple())
     if isinstance(obj, datetime.date):
         return time.mktime(obj.timetuple())
     return JSONEncoder.default(self, obj)
예제 #36
0
    def render(self, name, value, attrs=None):
        if value is None: value = ''
        value = smart_unicode(value)
        final_attrs = self.build_attrs(attrs, name=name)

        self.mce_settings['elements'] = "id_%s" % name
        mce_json = JSONEncoder().encode(self.mce_settings)

        # Print script head once per instance
        if self.print_head:
            head = load_javascript(TINYMCE_JS)
        else:
            head = u''

        return mark_safe(u'''<textarea%s>%s</textarea>
                %s
                <script type="text/javascript">tinyMCE.init(%s)</script>''' % (flatatt(final_attrs), escape(value), head, mce_json))
예제 #37
0
 def render(self, name, value, attrs=None):
     if value is None:
         value = ''
     if sys.version_info[0] == 2:
         from django.utils.encoding import smart_unicode
         value = smart_unicode(value)
     final_attrs = self.build_attrs(attrs, name=name)
     self.mce_settings['elements'] = "id_%s" % name
     mce_json = JSONEncoder().encode(self.mce_settings).replace("\"function", "function").replace("}\"", "}")
     return mark_safe(u'''<div%s>%s</div>
             <script type="text/javascript">
                 tinyMCE.init(%s);
                 setTimeout(function () {
                     $("#%s").focus();
                 }, 500);
             </script>''' % (flatatt(final_attrs),
                             value,
                             mce_json,
                             self.mce_settings['elements']))
예제 #38
0
def dailyCounts2(request,set,field_name):
    # counts by issuing lots of queries ins sequences
    counts = {}
    datemin = int(set.order_by(field_name)[0].__getattribute__(field_name))
    datemax = int(time.mktime(time.localtime())*1000)
    ## datemax = set.order_by("-%s"%field_name)[0].__getattribute__(field_name)
    ## print set.order_by("-%s"%field_name)[0]

    while datemin < datemax:
        ##print "datemin %s datemax %s " % (repr(time.ctime(datemin)),repr(time.ctime(datemax)))
        # print set.filter(**{""+field_name+"__gt":datemin,""+field_name+"__lt":datemax}).count()
        nextday = int(datemin) + 24*60*60*1000

        counts[datemin] = set.filter(**{""+field_name+"__gt":datemin,""+field_name+"__lt":nextday}).count()
        datemin = nextday ## 24*60*60*1000 ## plus one day
        
    response = HttpResponse(JSONEncoder().encode(counts), "text/json")
    response.status_code = 200;
    return response
예제 #39
0
def calendar_day_json(request, year, month, day):
    date = datetime.strptime("%s-%s-%s" % (year, month, day), "%Y-%m-%d")

    list_hour_registrations = HourRegistration.objects.filter(
        date=date, creator=Core.current_user())

    registrations = [{
        'id': reg.id,
        'time_start': reg.time_start,
        'time_end': reg.time_end,
        'hours': str(reg.hours),
        'order': reg.order.id,
        'type': str(reg.type.id),
        'customer_name': reg.get_customer_name(),
        'order_name': reg.get_order_name(),
        'description': reg.description
    } for reg in list_hour_registrations]

    return HttpResponse(JSONEncoder().encode(registrations),
                        mimetype='application/json')
예제 #40
0
def detail_data(request, id):
    if not check_user_login(request):
        return login(request)

    user = request.session.get('user')
    budget = BudgetService().getBudget(id, user)
    if budget:
        budgetdetail_list = BudgetService().getBudgetDetailList(budget)
        filter_dict = {
            'happentime >=': budget.begindate,
            'happentime <=': budget.enddate
        }
        moneystat = MoneyService().getMoneyStat(filter_dict, budget.currency,
                                                user)
        for budgetdetail in budgetdetail_list:
            BudgetService().updateBudgetDetailActualMoney(
                budgetdetail, moneystat)
        jsondata = BudgetService().encode(budgetdetail_list)
        return HttpResponse(JSONEncoder().encode(jsondata))
    else:
        return HttpResponse('')
예제 #41
0
def misc_json(request):
    allNotes = []
    notes = RedactedNote.objects.all().order_by('created')
    notes.reverse()
    for note in notes:
        allNotes.append({
            "type": "Note",
            "label": note.noteType,
            "contents": note.contents
        })
        pass
    print 1
    types = {"Note": {'pluralLabel': "Notes"}}
    print 2
    response = HttpResponse(
        JSONEncoder().encode({
            'types': types,
            'items': allNotes
        }), "text/json")
    response.status_code = 200
    return response
예제 #42
0
def calendar_json(request, year, month):
    year = int(year)
    month = int(month)

    date = datetime.strptime("%s-%s-%s" % (year, month, 1), "%Y-%m-%d")

    NOW = datetime.now()
    CURRENT_WEEK = date.isocalendar()[1]

    cal_month = calendar.monthcalendar(year, month)
    temp_cal = []

    #Build
    for week in cal_month:
        hours_count = 0
        for day in week:
            if int(day) > 0:
                day_date = datetime.strptime(
                    "%s-%s-%s" % (year, month, int(day)), "%Y-%m-%d")

                for reg in HourRegistration.objects.filter(
                        date=day_date, creator=Core.current_user()):
                    hours_count += float(reg.hours)

            if NOW == date:
                temp_cal.append((CURRENT_WEEK, day, "day today", hours_count))
            elif (day > 0):
                temp_cal.append((CURRENT_WEEK, day, "day", hours_count))
            else:
                temp_cal.append((CURRENT_WEEK, day, "", hours_count))

            hours_count = 0

        if CURRENT_WEEK == 52:
            CURRENT_WEEK = 0
        CURRENT_WEEK += 1

    return HttpResponse(JSONEncoder().encode(temp_cal),
                        mimetype='application/json')
예제 #43
0
파일: json.py 프로젝트: Dpetters/Umeqo
 def default(self, o):
     if isinstance(o, Student):
         return o.__json__()
     return JSONEncoder.default(self, o)
예제 #44
0
파일: json.py 프로젝트: frankk00/openblock
 def default(self, o):
     if isinstance(o, Bunch):
         return [o.objects, o.center]
     else:
         return JSONEncoder.default(self, o)
 def default( self, obj ):
     if isinstance( self, QuerySet ):
         return loads( serializers.serialize( 'json', obj ))
     return JSONEncoder.default( self, obj )
예제 #46
0
파일: views.py 프로젝트: Smiter/voodoo
 def default(self, obj):
     if isinstance(obj, QuerySet):
         return loads(serialize('json', obj, use_natural_keys=True))
     return JSONEncoder.default(self, obj)
예제 #47
0
 def default(self, obj):
     if isinstance(obj, QuerySet):
         return [jsonify_model(o) for o in obj]
     if isinstance(obj, Model):
         return jsonify_model(obj)
     return JSONEncoder.default(self, obj)
예제 #48
0
파일: utils.py 프로젝트: IMISME/jihua
	def default(self, obj):
		ty = type(obj)
		if ty is datetime:
			return obj.strftime('%Y-%m-%d %H:%M:%S')
		else:
			return JSONEncoder.default(self, obj)