Example #1
0
def check_marketo_complete(course_id, email, course_map):
    """
    check if a course is already marked as complete in Marketo
    """
    # email = '*****@*****.**'
    # import pdb; pdb.set_trace()
    mkto_field_id = course_map[course_id]
    try:
        mc = get_marketo_client()
        complete = mc.execute(method='get_leads', filtr='email',
                              values=(email,), fields=(mkto_field_id,))
        if len(complete) > 1:
            raise MarketoException

        completeness = complete[0][mkto_field_id]
        if completeness:  # only cache True
            cachekey = cache_key('marketo_complete_cache',
                                 course=course_id, email=email)
            # our version of keyedcache doesn't recognize a cache is 
            # enabled in our multi-cache setup.
            if not cache_enabled():
                cache_enable()
            cache_set(cachekey, value=completeness)

        return completeness
    except MarketoException:
        # if we can't connect to Marketo or have some error with API,
        # don't continue trying to check completion
        return True
Example #2
0
    def testDisable(self):
        keyedcache.cache_set('disabled', value=False)
        v = keyedcache.cache_get('disabled')
        self.assertEqual(v, False)

        keyedcache.cache_enable(False)
        keyedcache.cache_set('disabled', value=True)
        try:
            keyedcache.cache_get('disabled')
            self.fail('should have raised NotCachedError')
        except keyedcache.NotCachedError, nce:
            key = keyedcache.cache_key('disabled')
            self.assertEqual(nce.key, key)
Example #3
0
    def testDisable(self):
        keyedcache.cache_set("disabled", value=False)
        v = keyedcache.cache_get("disabled")
        self.assertEqual(v, False)

        keyedcache.cache_enable(False)
        keyedcache.cache_set("disabled", value=True)
        try:
            keyedcache.cache_get("disabled")
            self.fail("should have raised NotCachedError")
        except keyedcache.NotCachedError, nce:
            key = keyedcache.cache_key("disabled")
            self.assertEqual(nce.key, key)
Example #4
0
    def testDisable(self):
        keyedcache.cache_set('disabled', value=False)
        v = keyedcache.cache_get('disabled')
        self.assertEqual(v, False)

        keyedcache.cache_enable(False)
        keyedcache.cache_set('disabled', value=True)
        try:
            keyedcache.cache_get('disabled')
            self.fail('should have raised NotCachedError')
        except keyedcache.NotCachedError as nce:
            key = keyedcache.cache_key('disabled')
            self.assertEqual(nce.key, key)

        keyedcache.cache_enable()
        v2 = keyedcache.cache_get('disabled')
        # should still be False, since the cache was disabled
        self.assertEqual(v2, False)