Python signals.disconnect_entry_signals函数代码示例

    def handle(self, *args, **options):
        disconnect_entry_signals()
        self.verbosity = int(options.get('verbosity', 1))
        for entry in Entry.objects.all():
            self.write_out('Processing %s\n' % entry.title)
            changed = False
            comment_count = entry.comments.count()
            pingback_count = entry.pingbacks.count()
            trackback_count = entry.trackbacks.count()

            if entry.comment_count != comment_count:
                changed = True
                self.write_out('- %s comments found, %s before\n' % (
                    comment_count, entry.comment_count))
                entry.comment_count = comment_count

            if entry.pingback_count != pingback_count:
                changed = True
                self.write_out('- %s pingbacks found, %s before\n' % (
                    pingback_count, entry.pingback_count))
                entry.pingback_count = pingback_count

            if entry.trackback_count != trackback_count:
                changed = True
                self.write_out('- %s trackbacks found, %s before\n' % (
                    trackback_count, entry.trackback_count))
                entry.trackback_count = trackback_count

            if changed:
                self.write_out('- Updating...\n')
                entry.save()

    def setUp(self):
        disconnect_entry_signals()
        activate('en')
        self.request_factory = RequestFactory()
        self.site = Site.objects.get_current()

        params = {'title': 'My entry 1',
                  'content': 'My content 1',
                  'status': PUBLISHED,
                  'slug': 'my-entry-1'}
        self.entry_1 = Entry.objects.create(**params)
        self.entry_1.sites.add(self.site)

        params = {'title': 'My entry 2',
                  'content': 'My content 2',
                  'status': PUBLISHED,
                  'slug': 'my-entry-2'}
        self.entry_2 = Entry.objects.create(**params)
        self.entry_2.sites.add(self.site)

        params = {'title': 'My entry draft',
                  'content': 'My content draft',
                  'slug': 'my-entry-draft'}
        self.entry_draft = Entry.objects.create(**params)
        self.entry_draft.sites.add(self.site)

    def setUp(self):
        disconnect_entry_signals()
        self.site = Site.objects.get_current()
        self.authors = [
            Author.objects.create(username='admin', email='[email protected]'),
            Author.objects.create(username='user', email='[email protected]')]
        self.categories = [
            Category.objects.create(title='Category 1', slug='cat-1'),
            Category.objects.create(title='Category 2', slug='cat-2')]
        params = {'title': 'My entry 1', 'content': 'My content 1',
                  'tags': 'zinnia, test', 'slug': 'my-entry-1',
                  'status': PUBLISHED}
        self.entry_1 = Entry.objects.create(**params)
        self.entry_1.authors.add(*self.authors)
        self.entry_1.categories.add(*self.categories)
        self.entry_1.sites.add(self.site)

        params = {'title': 'My entry 2', 'content': 'My content 2',
                  'tags': 'zinnia', 'slug': 'my-entry-2',
                  'status': PUBLISHED}
        self.entry_2 = Entry.objects.create(**params)
        self.entry_2.authors.add(self.authors[0])
        self.entry_2.categories.add(self.categories[0])
        self.entry_2.sites.add(self.site)

        params = {'title': 'My entry draft', 'content': 'My content draft',
                  'tags': 'zinnia, tag', 'slug': 'my-entry-draft'}
        self.entry_draft = Entry.objects.create(**params)
        self.entry_draft.authors.add(self.authors[0])
        self.entry_draft.categories.add(self.categories[0])
        self.entry_draft.sites.add(self.site)

 def setUp(self):
     disconnect_entry_signals()
     disconnect_discussion_signals()
     params = {'title': 'My entry',
               'content': 'My content',
               'slug': 'my-entry'}
     self.entry = Entry.objects.create(**params)

    def handle(self, database_name, **options):

        # Verify that
        if options['threaded_comments'] and not hasattr(Comment, "parent"):
            raise CommandError("Currently configured comment model does not have the 'parent' attribute, but threaded comment import has been requested. Check your COMMENTS_APP setting.")

        # Read the password for Drupal database if it wasn't provided within a file.
        if options['database_password_file']:
            options['database_password'] = open(options['database_password_file'], "r").read().rstrip().lstrip()
        else:
            options['database_password'] = getpass.getpass("Database password for '%s'@'%s': " % (options['database_username'], database_name))

        # Set-up SQLAlchemy ORM.
        database_connection_url = "mysql://%s:%[email protected]%s/%s" % (urllib.quote(options['database_username']),
                                                           urllib.quote(options['database_password']),
                                                           urllib.quote(options['database_hostname']),
                                                           urllib.quote(database_name))
        engine = create_engine(database_connection_url)
        drupal = DrupalDatabase(engine)

        # Create list of users that should be imported.
        users = options["users"]
        if users:
            users = users.split(",")

        # Disconnect Zinnia signals.
        disconnect_discussion_signals()
        disconnect_entry_signals()

        # Import the users.
        with transaction.atomic():
            user_stats, user_mapping = import_users(drupal, users=users, custom_mapping=options["user_mapping"])
        # Import the categories.
        with transaction.atomic():
            category_stats, category_mapping = import_categories(drupal)
        # Extract the tag mapping.
        with transaction.atomic():
            tag_mapping = extract_tags(drupal)
        # Finally, import the actual content.
        with transaction.atomic():
            content_stats = import_content(drupal, user_mapping, category_mapping, tag_mapping, options['node_type'], options["threaded_comments"])

        # Output a summary.
        print
        print "User import summary"
        print "==================="
        for key, value in user_stats.iteritems():
            print "%s: %s" % (key, value)

        print
        print "Category import summary"
        print "======================="
        for key, value in category_stats.iteritems():
            print "%s: %s" % (key, value)

        print
        print "Content import summary"
        print "======================"
        for key, value in content_stats.iteritems():
            print "%s: %s" % (key, value)

    def setUp(self):
        disconnect_entry_signals()
        self.sites = [
            Site.objects.get_current(),
            Site.objects.create(domain='http://domain.com',
                                name='Domain.com')]
        self.authors = [
            Author.objects.create_user(username='webmaster',
                                       email='[email protected]'),
            Author.objects.create_user(username='contributor',
                                       email='[email protected]')]
        self.categories = [
            Category.objects.create(title='Category 1',
                                    slug='category-1'),
            Category.objects.create(title='Category 2',
                                    slug='category-2')]

        params = {'title': 'My entry 1', 'content': 'My content 1',
                  'tags': 'zinnia, test', 'slug': 'my-entry-1',
                  'status': PUBLISHED}
        self.entry_1 = Entry.objects.create(**params)
        self.entry_1.authors.add(self.authors[0])
        self.entry_1.categories.add(*self.categories)
        self.entry_1.sites.add(*self.sites)

        params = {'title': 'My entry 2', 'content': 'My content 2',
                  'tags': 'zinnia, test', 'slug': 'my-entry-2'}
        self.entry_2 = Entry.objects.create(**params)
        self.entry_2.authors.add(*self.authors)
        self.entry_2.categories.add(self.categories[0])
        self.entry_2.sites.add(self.sites[0])

 def setUp(self):
     disconnect_entry_signals()
     params = {'title': 'My entry',
               'content': 'My content',
               'tags': 'zinnia, test',
               'slug': 'my-entry'}
     self.entry = Entry.objects.create(**params)

    def setUp(self):
        disconnect_entry_signals()
        disconnect_discussion_signals()
        self.site = Site.objects.get_current()
        self.author = Author.objects.create_user(username='admin',
                                                 email='[email protected]',
                                                 password='password')
        self.category = Category.objects.create(title='Tests', slug='tests')
        params = {'title': 'Test 1',
                  'content': 'First test entry published',
                  'slug': 'test-1',
                  'tags': 'tests',
                  'publication_date': datetime(2010, 1, 1, 23, 0),
                  'status': PUBLISHED}
        entry = Entry.objects.create(**params)
        entry.sites.add(self.site)
        entry.categories.add(self.category)
        entry.authors.add(self.author)
        self.first_entry = entry

        params = {'title': 'Test 2',
                  'content': 'Second test entry published',
                  'slug': 'test-2',
                  'tags': 'tests',
                  'publication_date': datetime(2010, 5, 31, 23, 00),
                  'status': PUBLISHED}
        entry = Entry.objects.create(**params)
        entry.sites.add(self.site)
        entry.categories.add(self.category)
        entry.authors.add(self.author)
        self.second_entry = entry

    def setUp(self):
        disconnect_entry_signals()
        disconnect_discussion_signals()
        # Clear the cache of user flagger to avoid error on MySQL
        get_user_flagger.cache_clear()
        # Use default URL shortener backend, to avoid networks errors
        self.original_shortener = shortener_settings.URL_SHORTENER_BACKEND
        shortener_settings.URL_SHORTENER_BACKEND = "zinnia.url_shortener." "backends.default"
        # Set up a stub around urlopen
        import zinnia.xmlrpc.pingback

        self.original_urlopen = zinnia.xmlrpc.pingback.urlopen
        zinnia.xmlrpc.pingback.urlopen = self.fake_urlopen
        # Set a short template for entry_detail to avoid rendering errors
        setup_test_template_loader(
            {
                "zinnia/entry_detail.html": "<html><head><title>{{ object.title }}</title></head>"
                "<body>{{ object.html_content|safe }}</body></html>",
                "404.html": "404",
            }
        )
        # Preparing site
        self.site = Site.objects.get_current()
        # Creating tests entries
        self.author = Author.objects.create_user(username="webmaster", email="[email protected]")
        self.category = Category.objects.create(title="test", slug="test")
        params = {
            "title": "My first entry",
            "content": "My first content",
            "slug": "my-first-entry",
            "creation_date": datetime(2010, 1, 1, 12),
            "status": PUBLISHED,
        }
        self.first_entry = Entry.objects.create(**params)
        self.first_entry.sites.add(self.site)
        self.first_entry.categories.add(self.category)
        self.first_entry.authors.add(self.author)

        params = {
            "title": "My second entry",
            "content": "My second content with link "
            'to <a href="http://%s%s">first entry</a>'
            " and other links : %s %s."
            % (
                self.site.domain,
                self.first_entry.get_absolute_url(),
                "http://example.com/error-404/",
                "http://external/",
            ),
            "slug": "my-second-entry",
            "creation_date": datetime(2010, 1, 1, 12),
            "status": PUBLISHED,
        }
        self.second_entry = Entry.objects.create(**params)
        self.second_entry.sites.add(self.site)
        self.second_entry.categories.add(self.category)
        self.second_entry.authors.add(self.author)
        # Instanciating the server proxy
        self.server = ServerProxy("http://example.com/xmlrpc/", transport=TestTransport())

 def __init__(self):
     """Init the Command and add custom styles"""
     super(Command, self).__init__()
     self.style.TITLE = self.style.SQL_FIELD
     self.style.STEP = self.style.SQL_COLTYPE
     self.style.ITEM = self.style.HTTP_INFO
     disconnect_entry_signals()
     disconnect_discussion_signals()

    def setUp(self):
        disconnect_entry_signals()
        disconnect_discussion_signals()
        # Clean the memoization of user flagger to avoid error on MySQL
        try:
            del user_flagger_[()]
        except KeyError:
            pass
        # Use default URL shortener backend, to avoid networks errors
        self.original_shortener = shortener_settings.URL_SHORTENER_BACKEND
        shortener_settings.URL_SHORTENER_BACKEND = 'zinnia.url_shortener.'\
                                                   'backends.default'
        # Set up a stub around urlopen
        import zinnia.xmlrpc.pingback
        self.original_urlopen = zinnia.xmlrpc.pingback.urlopen
        zinnia.xmlrpc.pingback.urlopen = self.fake_urlopen
        # Set a short template for entry_detail to avoid rendering errors
        setup_test_template_loader(
            {'zinnia/entry_detail.html':
             '<html><head><title>{{ object.title }}</title></head>'
             '<body>{{ object.html_content|safe }}</body></html>',
             '404.html': '404'})
        # Preparing site
        self.site = Site.objects.get_current()
        # Creating tests entries
        self.author = Author.objects.create_user(username='webmaster',
                                                 email='[email protected]')
        self.category = Category.objects.create(title='test', slug='test')
        params = {'title': 'My first entry',
                  'content': 'My first content',
                  'slug': 'my-first-entry',
                  'creation_date': datetime(2010, 1, 1, 12),
                  'status': PUBLISHED}
        self.first_entry = Entry.objects.create(**params)
        self.first_entry.sites.add(self.site)
        self.first_entry.categories.add(self.category)
        self.first_entry.authors.add(self.author)

        params = {'title': 'My second entry',
                  'content': 'My second content with link '
                  'to <a href="http://%s%s">first entry</a>'
                  ' and other links : %s %s.' % (
                      self.site.domain,
                      self.first_entry.get_absolute_url(),
                      'http://example.com/error-404/',
                      'http://external/'),
                  'slug': 'my-second-entry',
                  'creation_date': datetime(2010, 1, 1, 12),
                  'status': PUBLISHED}
        self.second_entry = Entry.objects.create(**params)
        self.second_entry.sites.add(self.site)
        self.second_entry.categories.add(self.category)
        self.second_entry.authors.add(self.author)
        # Instanciating the server proxy
        self.server = ServerProxy('http://example.com/xmlrpc/',
                                  transport=TestTransport())

 def setUp(self):
     disconnect_entry_signals()
     disconnect_discussion_signals()
     params = {'title': 'My entry',
               'content': 'My content',
               'tags': 'zinnia, test',
               'creation_date': datetime(2010, 1, 1, 12),
               'slug': 'my-entry'}
     self.entry = Entry.objects.create(**params)
     self.site = Site.objects.get_current()

 def setUp(self):
     disconnect_entry_signals()
     disconnect_discussion_signals()
     activate('en')
     self.site = Site.objects.get_current()
     self.author = Author.objects.create(username='admin',
                                         first_name='Root',
                                         last_name='Bloody',
                                         email='[email protected]')
     self.category = Category.objects.create(title='Tests', slug='tests')
     self.entry_ct_id = ContentType.objects.get_for_model(Entry).pk

    def setUp(self):
        disconnect_entry_signals()
        activate("en")
        self.request_factory = RequestFactory()
        self.site = Site.objects.get_current()

        params = {"title": "My entry 1", "content": "My content 1", "status": PUBLISHED, "slug": "my-entry-1"}
        self.entry_1 = Entry.objects.create(**params)
        self.entry_1.sites.add(self.site)

        params = {"title": "My entry 2", "content": "My content 2", "status": PUBLISHED, "slug": "my-entry-2"}
        self.entry_2 = Entry.objects.create(**params)
        self.entry_2.sites.add(self.site)

    def setUp(self):
        disconnect_entry_signals()
        self.site = Site.objects.get_current()
        self.author = Author.objects.create_user(
            'webmaster', '[email protected]')
        params = {'title': 'My entry',
                  'content': 'My content',
                  'tags': 'zinnia, test',
                  'slug': 'my-entry'}

        self.entry = Entry.objects.create(**params)
        self.entry.authors.add(self.author)
        self.entry.sites.add(self.site)