Python db.shorten_name函数代码示例

    def forwards(self, orm):
        # Adding model 'Usuario'
        db.create_table(u'skeleton_usuario', (
            (u'id', self.gf('django.db.models.fields.AutoField')(primary_key=True)),
            ('password', self.gf('django.db.models.fields.CharField')(max_length=128)),
            ('last_login', self.gf('django.db.models.fields.DateTimeField')(default=datetime.datetime.now)),
            ('is_superuser', self.gf('django.db.models.fields.BooleanField')(default=False)),
            ('usuario', self.gf('django.db.models.fields.CharField')(unique=True, max_length=15, db_index=True)),
            ('email', self.gf('django.db.models.fields.EmailField')(max_length=50, null=True, blank=True)),
            ('nombre', self.gf('django.db.models.fields.CharField')(max_length=100)),
            ('apellidos', self.gf('django.db.models.fields.CharField')(max_length=100)),
            ('fecha', self.gf('django.db.models.fields.DateTimeField')(auto_now_add=True, blank=True)),
            ('fecha_mod', self.gf('django.db.models.fields.DateTimeField')(auto_now=True, blank=True)),
            ('is_active', self.gf('django.db.models.fields.BooleanField')(default=True)),
            ('is_admin', self.gf('django.db.models.fields.BooleanField')(default=False)),
        ))
        db.send_create_signal('skeleton', ['Usuario'])

        # Adding M2M table for field groups on 'Usuario'
        m2m_table_name = db.shorten_name(u'skeleton_usuario_groups')
        db.create_table(m2m_table_name, (
            ('id', models.AutoField(verbose_name='ID', primary_key=True, auto_created=True)),
            ('usuario', models.ForeignKey(orm['skeleton.usuario'], null=False)),
            ('group', models.ForeignKey(orm[u'auth.group'], null=False))
        ))
        db.create_unique(m2m_table_name, ['usuario_id', 'group_id'])

        # Adding M2M table for field user_permissions on 'Usuario'
        m2m_table_name = db.shorten_name(u'skeleton_usuario_user_permissions')
        db.create_table(m2m_table_name, (
            ('id', models.AutoField(verbose_name='ID', primary_key=True, auto_created=True)),
            ('usuario', models.ForeignKey(orm['skeleton.usuario'], null=False)),
            ('permission', models.ForeignKey(orm[u'auth.permission'], null=False))
        ))
        db.create_unique(m2m_table_name, ['usuario_id', 'permission_id'])

    def backwards(self, orm):
        # Deleting model 'Language'
        db.delete_table(u'events_language')

        # Deleting model 'Organization'
        db.delete_table(u'events_organization')

        # Deleting model 'Category'
        db.delete_table(u'events_category')

        # Deleting model 'PlacePostalAddress'
        db.delete_table(u'events_placepostaladdress')

        # Deleting model 'Place'
        db.delete_table(u'events_place')

        # Deleting model 'Offer'
        db.delete_table(u'events_offer')

        # Deleting model 'Event'
        db.delete_table(u'events_event')

        # Removing M2M table for field categories on 'Event'
        db.delete_table(db.shorten_name(u'events_event_categories'))

        # Removing M2M table for field offers on 'Event'
        db.delete_table(db.shorten_name(u'events_event_offers'))

    def forwards(self, orm):
        # Adding model 'ClassSession'
        db.create_table(u'class_sessions_classsession', (
            (u'id', self.gf('django.db.models.fields.AutoField')(primary_key=True)),
            ('title', self.gf('django.db.models.fields.CharField')(max_length=200)),
            ('description', self.gf('django.db.models.fields.TextField')()),
            ('session_start', self.gf('django.db.models.fields.DateTimeField')()),
            ('session_end', self.gf('django.db.models.fields.DateTimeField')()),
            ('class_type', self.gf('django.db.models.fields.CharField')(max_length=25)),
            ('teacher', self.gf('django.db.models.fields.related.ForeignKey')(to=orm['teachers.TeacherProfile'])),
            ('fee', self.gf('django.db.models.fields.FloatField')()),
            ('session_id', self.gf('django.db.models.fields.CharField')(max_length=100, blank=True)),
        ))
        db.send_create_signal(u'class_sessions', ['ClassSession'])

        # Adding M2M table for field students on 'ClassSession'
        m2m_table_name = db.shorten_name(u'class_sessions_classsession_students')
        db.create_table(m2m_table_name, (
            ('id', models.AutoField(verbose_name='ID', primary_key=True, auto_created=True)),
            ('classsession', models.ForeignKey(orm[u'class_sessions.classsession'], null=False)),
            ('userprofile', models.ForeignKey(orm[u'core.userprofile'], null=False))
        ))
        db.create_unique(m2m_table_name, ['classsession_id', 'userprofile_id'])

        # Adding M2M table for field files on 'ClassSession'
        m2m_table_name = db.shorten_name(u'class_sessions_classsession_files')
        db.create_table(m2m_table_name, (
            ('id', models.AutoField(verbose_name='ID', primary_key=True, auto_created=True)),
            ('classsession', models.ForeignKey(orm[u'class_sessions.classsession'], null=False)),
            ('teacherfile', models.ForeignKey(orm[u'teachers.teacherfile'], null=False))
        ))
        db.create_unique(m2m_table_name, ['classsession_id', 'teacherfile_id'])

    def forwards(self, orm):
        # Adding M2M table for field tags on 'Seance'
        m2m_table_name = db.shorten_name(u'contenus_seance_tags')
        db.create_table(m2m_table_name, (
            ('id', models.AutoField(verbose_name='ID', primary_key=True, auto_created=True)),
            ('seance', models.ForeignKey(orm[u'contenus.seance'], null=False)),
            ('tag', models.ForeignKey(orm[u'programme.tag'], null=False))
        ))
        db.create_unique(m2m_table_name, ['seance_id', 'tag_id'])

        # Adding M2M table for field tags on 'Item'
        m2m_table_name = db.shorten_name(u'contenus_item_tags')
        db.create_table(m2m_table_name, (
            ('id', models.AutoField(verbose_name='ID', primary_key=True, auto_created=True)),
            ('item', models.ForeignKey(orm[u'contenus.item'], null=False)),
            ('tag', models.ForeignKey(orm[u'programme.tag'], null=False))
        ))
        db.create_unique(m2m_table_name, ['item_id', 'tag_id'])

        # Adding M2M table for field tags on 'Theme'
        m2m_table_name = db.shorten_name(u'contenus_theme_tags')
        db.create_table(m2m_table_name, (
            ('id', models.AutoField(verbose_name='ID', primary_key=True, auto_created=True)),
            ('theme', models.ForeignKey(orm[u'contenus.theme'], null=False)),
            ('tag', models.ForeignKey(orm[u'programme.tag'], null=False))
        ))
        db.create_unique(m2m_table_name, ['theme_id', 'tag_id'])

    def backwards(self, orm):
        # Deleting model 'Player'
        db.delete_table(u'play_player')

        # Deleting model 'Shop'
        db.delete_table(u'play_shop')

        # Deleting model 'Organization'
        db.delete_table(u'play_organization')

        # Deleting model 'Coupon'
        db.delete_table(u'play_coupon')

        # Removing M2M table for field buyers on 'Coupon'
        db.delete_table(db.shorten_name(u'play_coupon_buyers'))

        # Deleting model 'Event'
        db.delete_table(u'play_event')

        # Removing M2M table for field participants on 'Event'
        db.delete_table(db.shorten_name(u'play_event_participants'))

        # Deleting model 'Challenge'
        db.delete_table(u'play_challenge')

        # Removing M2M table for field participants on 'Challenge'
        db.delete_table(db.shorten_name(u'play_challenge_participants'))

        # Deleting model 'CouponHistory'
        db.delete_table(u'play_couponhistory')

        # Deleting model 'EventHistory'
        db.delete_table(u'play_eventhistory')

    def backwards(self, orm):
        # Deleting field 'CartItem.cart'
        db.delete_column(u"carts_cartitem", "cart_id")

        # Deleting field 'CartItem.line_total'
        db.delete_column(u"carts_cartitem", "line_total")

        # Adding M2M table for field products on 'Cart'
        m2m_table_name = db.shorten_name(u"carts_cart_products")
        db.create_table(
            m2m_table_name,
            (
                ("id", models.AutoField(verbose_name="ID", primary_key=True, auto_created=True)),
                ("cart", models.ForeignKey(orm[u"carts.cart"], null=False)),
                ("product", models.ForeignKey(orm[u"products.product"], null=False)),
            ),
        )
        db.create_unique(m2m_table_name, ["cart_id", "product_id"])

        # Adding M2M table for field items on 'Cart'
        m2m_table_name = db.shorten_name(u"carts_cart_items")
        db.create_table(
            m2m_table_name,
            (
                ("id", models.AutoField(verbose_name="ID", primary_key=True, auto_created=True)),
                ("cart", models.ForeignKey(orm[u"carts.cart"], null=False)),
                ("cartitem", models.ForeignKey(orm[u"carts.cartitem"], null=False)),
            ),
        )
        db.create_unique(m2m_table_name, ["cart_id", "cartitem_id"])

    def backwards(self, orm):
        # Removing unique constraint on 'FacebookInvite', fields ['user', 'user_invited']
        db.delete_unique('django_facebook_facebook_invite', ['user_id', 'user_invited'])

        # Removing unique constraint on 'FacebookLike', fields ['user_id', 'facebook_id']
        db.delete_unique(u'django_facebook_facebooklike', ['user_id', 'facebook_id'])

        # Removing unique constraint on 'FacebookUser', fields ['user_id', 'facebook_id']
        db.delete_unique(u'django_facebook_facebookuser', ['user_id', 'facebook_id'])

        # Deleting model 'FacebookUser'
        db.delete_table(u'django_facebook_facebookuser')

        # Deleting model 'FacebookLike'
        db.delete_table(u'django_facebook_facebooklike')

        # Deleting model 'FacebookProfile'
        db.delete_table(u'django_facebook_facebookprofile')

        # Deleting model 'FacebookCustomUser'
        db.delete_table(u'django_facebook_facebookcustomuser')

        # Removing M2M table for field groups on 'FacebookCustomUser'
        db.delete_table(db.shorten_name(u'django_facebook_facebookcustomuser_groups'))

        # Removing M2M table for field user_permissions on 'FacebookCustomUser'
        db.delete_table(db.shorten_name(u'django_facebook_facebookcustomuser_user_permissions'))

        # Deleting model 'OpenGraphShare'
        db.delete_table('django_facebook_open_graph_share')

        # Deleting model 'FacebookInvite'
        db.delete_table('django_facebook_facebook_invite')

    def forwards(self, orm):
        # Adding model 'Faction'
        db.create_table('representative_faction', (
            ('id', self.gf('django.db.models.fields.AutoField')(primary_key=True)),
            ('name', self.gf('django.db.models.fields.CharField')(max_length=255, null=True)),
            ('short', self.gf('django.db.models.fields.CharField')(max_length=32, null=True)),
        ))
        db.send_create_signal('representative', ['Faction'])

        # Deleting field 'Representative.faction_en'
        db.delete_column('representative_representative', 'faction_en')

        # Deleting field 'Representative.faction_ka'
        db.delete_column('representative_representative', 'faction_ka')


        # Renaming column for 'Representative.faction' to match new field type.
        db.rename_column('representative_representative', 'faction', 'faction_id')
        # Changing field 'Representative.faction'
        db.alter_column('representative_representative', 'faction_id', self.gf('django.db.models.fields.related.ForeignKey')(null=True, to=orm['representative.Faction']))
        # Adding index on 'Representative', fields ['faction']
        db.create_index('representative_representative', ['faction_id'])

        # Removing M2M table for field parties on 'Cabinet'
        db.delete_table(db.shorten_name('representative_cabinet_parties'))

        # Adding M2M table for field factions on 'Cabinet'
        m2m_table_name = db.shorten_name('representative_cabinet_factions')
        db.create_table(m2m_table_name, (
            ('id', models.AutoField(verbose_name='ID', primary_key=True, auto_created=True)),
            ('cabinet', models.ForeignKey(orm['representative.cabinet'], null=False)),
            ('faction', models.ForeignKey(orm['representative.faction'], null=False))
        ))
        db.create_unique(m2m_table_name, ['cabinet_id', 'faction_id'])

    def backwards(self, orm):
        # Deleting model 'Document2'
        db.delete_table('desktop_document2')

        # Removing M2M table for field tags on 'Document2'
        db.delete_table(db.shorten_name('desktop_document2_tags'))

        # Removing M2M table for field dependencies on 'Document2'
        db.delete_table(db.shorten_name('desktop_document2_dependencies'))


        # Changing field 'UserPreferences.key'
        db.alter_column('desktop_userpreferences', 'key', self.gf('django.db.models.fields.CharField')(max_length=20, null=True))

        # Changing field 'UserPreferences.value'
        db.alter_column('desktop_userpreferences', 'value', self.gf('django.db.models.fields.TextField')(max_length=4096, null=True))

        # Changing field 'DocumentPermission.perms'
        db.alter_column('desktop_documentpermission', 'perms', self.gf('django.db.models.fields.TextField')(null=True))

        # Changing field 'DocumentTag.tag'
        db.alter_column('desktop_documenttag', 'tag', self.gf('django.db.models.fields.SlugField')(max_length=50, null=True))

        # Changing field 'Document.extra'
        db.alter_column('desktop_document', 'extra', self.gf('django.db.models.fields.TextField')(null=True))

        # Changing field 'Document.name'
        db.alter_column('desktop_document', 'name', self.gf('django.db.models.fields.CharField')(max_length=255, null=True))

        # Changing field 'Document.description'
        db.alter_column('desktop_document', 'description', self.gf('django.db.models.fields.TextField')(null=True))

    def backwards(self, orm):
        # Deleting model 'Category'
        db.delete_table(u'book_category')

        # Deleting model 'Book'
        db.delete_table(u'book_book')

        # Removing M2M table for field categories on 'Book'
        db.delete_table(db.shorten_name(u'book_book_categories'))

        # Removing M2M table for field sites on 'Book'
        db.delete_table(db.shorten_name(u'book_book_sites'))

        # Deleting model 'BookType'
        db.delete_table(u'book_booktype')

        # Deleting model 'Author'
        db.delete_table(u'book_author')

        # Deleting model 'Type'
        db.delete_table(u'book_type')

        # Deleting model 'Chapter'
        db.delete_table(u'book_chapter')

        # Deleting model 'ChapterType'
        db.delete_table(u'book_chaptertype')

    def backwards(self, orm):
        # Removing index on 'Representative', fields ['faction']
        db.delete_index('representative_representative', ['faction_id'])

        # Deleting model 'Faction'
        db.delete_table('representative_faction')

        # Adding field 'Representative.faction_en'
        db.add_column('representative_representative', 'faction_en',
                      self.gf('django.db.models.fields.TextField')(null=True, blank=True),
                      keep_default=False)

        # Adding field 'Representative.faction_ka'
        db.add_column('representative_representative', 'faction_ka',
                      self.gf('django.db.models.fields.TextField')(null=True, blank=True),
                      keep_default=False)


        # Renaming column for 'Representative.faction' to match new field type.
        db.rename_column('representative_representative', 'faction_id', 'faction')
        # Changing field 'Representative.faction'
        db.alter_column('representative_representative', 'faction', self.gf('django.db.models.fields.TextField')(null=True))
        # Adding M2M table for field parties on 'Cabinet'
        m2m_table_name = db.shorten_name('representative_cabinet_parties')
        db.create_table(m2m_table_name, (
            ('id', models.AutoField(verbose_name='ID', primary_key=True, auto_created=True)),
            ('cabinet', models.ForeignKey(orm['representative.cabinet'], null=False)),
            ('party', models.ForeignKey(orm['representative.party'], null=False))
        ))
        db.create_unique(m2m_table_name, ['cabinet_id', 'party_id'])

        # Removing M2M table for field factions on 'Cabinet'
        db.delete_table(db.shorten_name('representative_cabinet_factions'))

    def backwards(self, orm):
        # Deleting model 'Narzedzia'
        db.delete_table(u"base_narzedzia")

        # Deleting model 'Rok'
        db.delete_table(u"base_rok")

        # Deleting model 'Okres'
        db.delete_table(u"base_okres")

        # Removing M2M table for field narzedzia on 'Okres'
        db.delete_table(db.shorten_name(u"base_okres_narzedzia"))

        # Deleting model 'Blad'
        db.delete_table(u"base_blad")

        # Removing M2M table for field narzedzie on 'Blad'
        db.delete_table(db.shorten_name(u"base_blad_narzedzie"))

        # Deleting model 'Tradycja'
        db.delete_table(u"base_tradycja")

        # Deleting model 'Pomysl'
        db.delete_table(u"base_pomysl")

        # Deleting model 'Komentarz'
        db.delete_table(u"base_komentarz")

    def backwards(self, orm):
        # Deleting model 'Choices'
        db.delete_table(u'core_choices')

        # Deleting model 'User'
        db.delete_table(u'core_user')

        # Removing M2M table for field groups on 'User'
        db.delete_table(db.shorten_name(u'core_user_groups'))

        # Removing M2M table for field user_permissions on 'User'
        db.delete_table(db.shorten_name(u'core_user_user_permissions'))

        # Deleting model 'Competition'
        db.delete_table(u'core_competition')

        # Deleting model 'Distance'
        db.delete_table(u'core_distance')

        # Deleting model 'InsuranceCompany'
        db.delete_table(u'core_insurancecompany')

        # Deleting model 'Insurance'
        db.delete_table(u'core_insurance')

        # Deleting model 'CustomSlug'
        db.delete_table(u'core_customslug')

        # Deleting model 'Log'
        db.delete_table(u'core_log')

        # Deleting model 'Map'
        db.delete_table(u'core_map')

    def forwards(self, orm):
        # Adding model 'Person'
        db.create_table(u'legacy_person', (
            ('user', self.gf('django.db.models.fields.CharField')(max_length=200, primary_key=True)),
        ))
        db.send_create_signal(u'legacy', ['Person'])

        # Adding M2M table for field upvotes on 'Person'
        m2m_table_name = db.shorten_name(u'legacy_person_upvotes')
        db.create_table(m2m_table_name, (
            ('id', models.AutoField(verbose_name='ID', primary_key=True, auto_created=True)),
            ('person', models.ForeignKey(orm[u'legacy.person'], null=False)),
            ('comment', models.ForeignKey(orm[u'legacy.comment'], null=False))
        ))
        db.create_unique(m2m_table_name, ['person_id', 'comment_id'])

        # Adding M2M table for field downvotes on 'Person'
        m2m_table_name = db.shorten_name(u'legacy_person_downvotes')
        db.create_table(m2m_table_name, (
            ('id', models.AutoField(verbose_name='ID', primary_key=True, auto_created=True)),
            ('person', models.ForeignKey(orm[u'legacy.person'], null=False)),
            ('comment', models.ForeignKey(orm[u'legacy.comment'], null=False))
        ))
        db.create_unique(m2m_table_name, ['person_id', 'comment_id'])

        # Adding model 'Comment'
        db.create_table(u'legacy_comment', (
            (u'id', self.gf('django.db.models.fields.AutoField')(primary_key=True)),
            ('owner', self.gf('django.db.models.fields.related.ForeignKey')(to=orm['legacy.Person'])),
            ('text', self.gf('django.db.models.fields.TextField')()),
            ('upvotes', self.gf('django.db.models.fields.IntegerField')(default=0)),
            ('downvotes', self.gf('django.db.models.fields.IntegerField')(default=0)),
            ('created', self.gf('django.db.models.fields.DateTimeField')(auto_now_add=True, blank=True)),
        ))
        db.send_create_signal(u'legacy', ['Comment'])

    def backwards(self, orm):
        # Deleting model 'Monitorable'
        db.delete_table(u'projects_monitorable')

        # Removing M2M table for field subjects on 'Monitorable'
        db.delete_table(db.shorten_name(u'projects_monitorable_subjects'))

        # Removing M2M table for field locations on 'Monitorable'
        db.delete_table(db.shorten_name(u'projects_monitorable_locations'))

        # Deleting model 'Project'
        db.delete_table(u'projects_project')

        # Deleting model 'Good'
        db.delete_table(u'projects_good')

        # Deleting model 'Location'
        db.delete_table(u'projects_location')

        # Deleting model 'Geo'
        db.delete_table(u'projects_geo')

        # Deleting model 'Subject'
        db.delete_table(u'projects_subject')

        # Deleting model 'Tags'
        db.delete_table(u'projects_tags')

        # Deleting model 'Layer'
        db.delete_table(u'projects_layer')

        # Removing M2M table for field projects on 'Layer'
        db.delete_table(db.shorten_name(u'projects_layer_projects'))