Python models.SurveyKeyword类代码示例

    def migrate(self, log_file):
        count = 0
        ids = self.get_couch_ids()
        total_count = len(ids)
        for doc in iter_docs_with_retry(SurveyKeyword.get_db(), ids):
            try:
                couch_obj = SurveyKeyword.wrap(doc)
                couch_obj._migration_do_sync()
            except Exception as e:
                log_file.write('Could not sync SurveyKeyword %s: %s\n' % (doc['_id'], e))

            count += 1
            if (count % 1000) == 0:
                print 'Processed %s / %s documents' % (count, total_count)

 def keyword(self):
     if self.keyword_id is None:
         raise Http404()
     sk = SurveyKeyword.get(self.keyword_id)
     if sk.domain != self.domain:
         raise Http404()
     return sk

 def get_couch_ids(self):
     result = SurveyKeyword.view(
         'reminders/survey_keywords',
         include_docs=False,
         reduce=False,
     ).all()
     return [row['id'] for row in result]

 def total(self):
     data = (
         SurveyKeyword.get_db()
         .view("reminders/survey_keywords", reduce=True, startkey=[self.domain], endkey=[self.domain, {}])
         .first()
     )
     return data["value"] if data else 0

 def total(self):
     data = SurveyKeyword.get_db().view(
         'reminders/survey_keywords',
         reduce=True,
         startkey=[self.domain],
         endkey=[self.domain, {}],
     ).first()
     return data['value'] if data else 0

    def testCouchSyncToSQL(self):
        self.assertEqual(self.getCouchCount(), 0)
        self.assertEqual(self.getSQLCount(), 0)

        # Test Create
        couch_obj = SurveyKeyword()
        self.setRandomCouchObjectValues(couch_obj)
        self.assertEqual(self.getCouchCount(), 1)
        self.assertEqual(self.getSQLCount(), 1)

        sql_obj = Keyword.objects.get(couch_id=couch_obj._id)
        self.compareObjects(couch_obj, sql_obj)
        self.assertTrue(SurveyKeyword.get_db().get_rev(couch_obj._id).startswith('1-'))

        # Test Update
        self.setRandomCouchObjectValues(couch_obj)
        self.assertEqual(self.getCouchCount(), 1)
        self.assertEqual(self.getSQLCount(), 1)
        sql_obj = Keyword.objects.get(couch_id=couch_obj._id)
        self.compareObjects(couch_obj, sql_obj)
        self.assertTrue(SurveyKeyword.get_db().get_rev(couch_obj._id).startswith('2-'))

        # Test Delete
        couch_id = couch_obj._id
        couch_obj.delete()
        with self.assertRaises(ResourceNotFound):
            SurveyKeyword.get(couch_id)
        self.assertEqual(self.getCouchCount(), 0)
        self.assertEqual(self.getSQLCount(), 0)

 def get_couch_count(self):
     result = SurveyKeyword.view(
         'reminders/survey_keywords',
         include_docs=False,
         reduce=True,
     ).all()
     if result:
         return result[0]['value']
     return 0

 def get_deleted_item_data(self, item_id):
     try:
         s = SurveyKeyword.get(item_id)
     except ResourceNotFound:
         raise Http404()
     if s.domain != self.domain or s.doc_type != "SurveyKeyword":
         raise Http404()
     s.delete()
     return {"itemData": self._fmt_deleted_keyword_data(s), "template": "keyword-deleted-template"}

 def paginated_list(self):
     for keyword in SurveyKeyword.get_by_domain(
         self.domain,
         limit=self.limit,
         skip=self.skip,
     ):
         yield {
             'itemData': self._fmt_keyword_data(keyword),
             'template': 'keyword-row-template',
         }

 def getCouchCount(self):
     result = SurveyKeyword.view(
         'reminders/survey_keywords',
         startkey=[self.domain],
         endkey=[self.domain, {}],
         include_docs=False,
         reduce=True,
     ).all()
     if result:
         return result[0]['value']
     return 0

def device_data(request):
    if "data" not in request.POST:
        return HttpResponseBadRequest("Missing 'data' POST parameter.")

    data = request.POST.get("data")
    data = data.strip()
    data_points = data.split(",")
    device_id = None
    for data_point in data_points:
        key_value = data_point.partition("=")
        key = key_value[0].strip().upper()
        value = key_value[2].strip()
        if key == "SN":
            device_id = value
            break

    if device_id is None:
        return HttpResponseBadRequest("Missing 'SN' in data string.")

    # This view lookup is an implicit assert that either one device exists
    # with the given device_id, or no devices exist with this device_id.
    case = CommConnectCase.view("wisepill/device", key=[device_id], include_docs=True).one()

    event = WisePillDeviceEvent(
        domain=case.domain if case is not None else None,
        data=data,
        received_on=datetime.utcnow(),
        case_id=case._id if case is not None else None,
        processed=False,
    )
    event.save()

    if case is not None:
        survey_keywords = SurveyKeyword.get_all(case.domain)
        for survey_keyword in survey_keywords:
            if survey_keyword.keyword.upper() == "DEVICE_EVENT":
                for survey_keyword_action in survey_keyword.actions:
                    if survey_keyword_action.action == METHOD_STRUCTURED_SMS:
                        handle_structured_sms(
                            survey_keyword,
                            survey_keyword_action,
                            case,
                            None,
                            "DEVICE_EVENT,%s" % data,
                            send_response=False,
                        )
                        event.processed = True
                        event.save()
                        break

    return HttpResponse("")

 def create_survey_keyword(self, keyword, form_unique_id, delimiter=None,
     override_open_sessions=True, initiator_filter=None):
     sk = SurveyKeyword(
         domain=self.domain,
         keyword=keyword,
         description=keyword,
         actions=[SurveyKeywordAction(
             recipient=RECIPIENT_SENDER,
             recipient_id=None,
             action=METHOD_SMS_SURVEY,
             message_content=None,
             form_unique_id=form_unique_id,
             use_named_args=False,
             named_args={},
             named_args_separator=None,
         )],
         delimiter=delimiter,
         override_open_sessions=override_open_sessions,
         initiator_doc_type_filter=initiator_filter or [],
     )
     sk.save()
     self.keywords.append(sk)
     return sk

 def page_context(self):
     domain_has_reminders_or_keywords = (
         CaseReminderHandler.domain_has_reminders(self.domain) or
         SurveyKeyword.domain_has_keywords(self.domain)
     )
     bulk_sms_verification_enabled = (
         domain_has_reminders_or_keywords and
         domain_has_privilege(self.domain, privileges.INBOUND_SMS)
     )
     return {
         'group': self.group,
         'bulk_sms_verification_enabled': bulk_sms_verification_enabled,
         'num_users': len(self.member_ids),
         'user_form': self.user_selection_form,
         'domain_uses_case_sharing': self.domain_uses_case_sharing,
     }

    def get_keyword_display(self, keyword_id, content_cache):
        if keyword_id in content_cache:
            return content_cache[keyword_id]
        try:
            keyword = SurveyKeyword.get(keyword_id)
            if keyword.deleted():
                display = '%s %s' % (keyword.description, _('(Deleted Keyword)'))
            else:
                urlname = (EditStructuredKeywordView.urlname if keyword.is_structured_sms()
                    else EditNormalKeywordView.urlname)
                display = '<a target="_blank" href="%s">%s</a>' % (
                    reverse(urlname, args=[keyword.domain, keyword_id]),
                    keyword.description,
                )
        except ResourceNotFound:
            display = '-'

        content_cache[keyword_id] = display
        return display

    def get_keyword_display(self, keyword_id, content_cache):
        if keyword_id in content_cache:
            return content_cache[keyword_id]
        try:
            keyword = SurveyKeyword.get(keyword_id)
            if keyword.doc_type.endswith('-Deleted'):
                # We'll get rid of this once we move to postgres
                raise ResourceNotFound()
        except ResourceNotFound:
            display = _('(Deleted Keyword)')
        else:
            urlname = (EditStructuredKeywordView.urlname if keyword.is_structured_sms()
                else EditNormalKeywordView.urlname)
            display = '<a target="_blank" href="%s">%s</a>' % (
                reverse(urlname, args=[keyword.domain, keyword_id]),
                keyword.description,
            )

        content_cache[keyword_id] = display
        return display