skinparam linetype ortho

namespace django #DDDDDD {
    namespace django.db.models {
        class FileField {}
        class FieldFile {}
        class FileDescriptor {}
    }
  
    namespace django.views {
        class View <<V, lightblue>>{
            dispatch(): HttpResponse
        }
    }

    namespace django.forms {
        class Form <<F, lightgreen >>
        class ModelForm <<F, lightgreen>>
        ModelForm -|> Form
    }

    namespace django.core.management.base {
        class BaseCommand
    }

    namespace django.contrib.auth.base_user {
        class AbstractBaseUser << (M,orchid) >>
    }
    'django.contrib.auth.base_user.AbstractBaseUser -d-|>django.db.models.Model
    django.contrib.auth.base_user.AbstractBaseUser -[hidden]d- django.core.management.base.BaseCommand
    'django.forms -[hidden]u- django.db.models
    django.core.management.base.BaseCommand -[hidden]d- django.forms
    
}

namespace django-media-fields.models {
    AudioField -|> django.db.models.FileField
    class AudioField {
        length_field: str
        
        update_metadata_fields(self, instance, force=False, *args, **kwargs)
    }
    AudioFileDescriptor -|> django.db.models.FileDescriptor
    AudioFieldFile -|> django.db.models.FieldFile
    AudioField -[hidden]d- AudioFileDescriptor
    AudioFileDescriptor -[hidden]d- AudioFieldFile
    
    AudioFieldFile -[hidden]d- VideoField
    
    VideoField -|> django.db.models.FileField
    class VideoField {
        length_field: str
        width_field: str
        height_field: str
        
        update_metadata_fields(self, instance, force=False, *args, **kwargs)
    }
    VideoFileDescriptor -|> django.db.models.FileDescriptor
    VideoFieldFile -d-|> django.db.models.FieldFile
    VideoField -[hidden]d- VideoFileDescriptor
    VideoFileDescriptor -[hidden]d- VideoFieldFile
}



namespace dill {
    namespace dill.accounts {
        namespace dill.accounts.backends {
            class BaseBackend {
                authenticate(request: Request, **kwargs);
                get_user(user_id: int): User
            }

            HttpUserBackend -d-|> BaseBackend
            class HttpUserBackend {
                authenticate(request: Request, **kwargs): User
            }

            LDAPBackend -d-|> BaseBackend
            class LDAPBackend {
                authenticate(request: Request, username: str, password: str, **kwargs): User
            }

            ShibbolethBackend -r-|> BaseBackend
            class ShibbolethBackend {
                authenticate(request: Request, **kwargs): User
            }
        }

        namespace dill.accounts.mixins {
            class AccessMixin {
                login_url: str
                redirect_field_name: str
                permission_denied_message: str

                dispatch(request: Request, *args, **kwargs): Response
                check_permission(user: User): bool
                handle_no_permission(): Response
                handle_unauthenticated(): Response
                get_permission_denied_message(): str
            }

            LoginRequiredMixin -|> AccessMixin
            class LoginRequiredMixin {
                check_permission(user: User): bool
            }

            PermissionRequiredMixin -|> AccessMixin
            class PermissionRequiredMixin {
                required_permission: [Perm]

                check_permission(user: User): bool
            }
            
        }

        namespace dill.accounts.models {
            class PermissionMixin {
                get_implicit_groups(): [Group]
                get_explicit_groups(): [Group]
                get_groups(): [Group]
                get_all_permissions(): set<Perm>
                has_perms(perms: [Perm]): bool
            }

            User -|> django.contrib.auth.base_user.AbstractBaseUser
            User .|> PermissionMixin
            class User  << (M, orchid) >> {
                username: CharField
                first_name: CharField
                last_name: CharField
                mail: EmailField
                profile_image: ImageField

                clean()
                get_full_name(): str
                get_short_name(): str
                get_implicit_groups(): [Group]

                << deprecated >> is_anonymous(): bool
                is_authenticated(): bool
            }
            User *- "many" UserGroup: groups
            
            ' AnonymousUser is not a model do not mark it as such
            AnonymousUser -|> User
            
            'UserGroup -|> django.db.models.Model
            class UserGroup  << (M,orchid) >> {
                name: CharField
            }
        }

        namespace dill.accounts.permissions {
            class Perm {
                app: str
                key: str
                description: str

                __init__(app: str, key: str, description: str)
            }
        }

        namespace dill.accounts.management.commands {
            namespace dill.accounts.management.commands.createuser {
                Command -|> django.core.management.base.BaseCommand
                class Command {
                    add_argument(parser: OptionParser)
                    handle(*args, **kwargs)
                }
            }

            namespace dill.accounts.management.commands.promoteuser {
                Command -|> django.core.management.base.BaseCommand
                class Command {
                    add_argument(parser: OptionParser)
                    handle(*args, **kwargs)
                }
            }
        }

        namespace dill.accounts.views {
             
            class LoginView << (V,lightblue) >>
            'LoginView -|> django.views.View
            class LogoutView << (V,lightblue) >>
            'LogoutView -|> django.views.View
            class ProfileView << (V,lightblue) >>
            'ProfileView -|> django.views.View
            ProfileView .|> dill.accounts.mixins.LoginRequiredMixin
            class ProfileEditView << (V,lightblue) >>
            
            dill.accounts.mixins.PermissionRequiredMixin <|- dill.accounts.views.ProfileEditView
            
        }

        namespace dill.accounts.forms {
            class AuthenticationForm <<F, lightgreen>>
            
            AuthenticationForm o-- dill.accounts.views.LoginView

            class ProfileForm <<F, lightgreen>>
            ProfileForm -|> django.forms.ModelForm
            ProfileForm o-- dill.accounts.views.ProfileEditView
        }

        namespace dill.accounts.middleware {
            class AuthenticationMiddleware {
                - cached_user: User

                __init__(get_response: callable)
                __call__(request: Request): Request
                get_user(request: Request): User
            }
        }

        namespace dill.accounts.templatetags.perms {
            class PermWrapper {
                __init__(user: User)
                __iter__(): iterator<Perm>
                __contains__(perm: Perm): bool
            }
        }
        dill.accounts.mixins.LoginRequiredMixin --[hidden]l- dill.accounts.mixins.AccessMixin
    
    dill.accounts.models -[hidden]d- dill.accounts.management.commands
    dill.accounts.management.commands -[hidden]l- dill.accounts.permissions
    dill.accounts.permissions --[hidden]d- dill.accounts.backends
    dill.accounts.backends --[hidden]d- dill.accounts.forms
    dill.accounts.views -[hidden]d- dill.accounts.mixins

    'dill.accounts.views -[hidden]d- dill.accounts.forms
    dill.accounts.mixins --[hidden]d- dill.accounts.middleware
    dill.accounts.middleware -[hidden]l- dill.accounts.templatetags.perms
    }

    namespace dill.models {
        'subpackage?
        'Experiment -|> django.db.models.Model
        class Experiment  << (M,orchid) >> {
            name: CharField
            description: TextField
            archived_at: DateTimeField
            created_at: DateTimeField
            __str__()
        }
        Experiment -> dill.accounts.models.User: creator
        Experiment "many" <- dill.accounts.models.User: favorites
        'Tag -|> django.db.models.Model
        class Tag  << (M,orchid) >> {
            name: CharField
            color: IntegerField
            __str__()
        }
        Tag --* Experiment

        
        class "//NoteMedia//" as NoteMedia  << (M,orchid) >> {
            name: CharField
            content_type: CharField
            size: IntegerField
            thumb: ImageField
            thumb_height: IntegerField
            thumb_width: IntegerField
            
        }
        
        class Note  << (M,orchid) >> {
            content: TextField
            created_at:  DateTimeField
            __str__()
        }
        
        AudioMedia -|> NoteMedia
        class AudioMedia  << (M,orchid) >> {
            file: django_file_fields.models.AudioField
            length: IntegerField
            
            __str__()
        }
        
        ImageMedia -|> NoteMedia
        class ImageMedia << (M,orchid) >> {
            file: ImageField
            height: IntegerField
            width: IntegerField
            
            __str__()
        }
        
        VideoMedia -|> NoteMedia
        class VideoMedia << (M,orchid) >> {
            file: djang_file_fields.models.VideoField
            length: IntegerField
            height: IntegerField
            width: IntegerField
            
            __str__()
        }
        
        NoteMedia -[hidden]d- Note
        NoteMedia -[hidden]d- AudioMedia
        AudioMedia -[hidden]d- VideoMedia
        VideoMedia -[hidden]d- ImageMedia
        Note -d---> dill.accounts.models.User: creator
        Note -> "many" Tag: tags
        Note *- "many" NoteMedia: media
        Note -* Experiment: experiment
    }

    namespace dill.views {
        'subpackage?
        class ExperimentView << (V,lightblue) >>
        'TODO change to ExperimentDetailView?
        dill.accounts.mixins.PermissionRequiredMixin <|- dill.views.ExperimentView

        'ExperimentView -|> django.views.View
        class ExperimentEditView << (V,lightblue) >>
        'ExperimentEditView -|> django.views.View
        class Startpage << (V,lightblue) >>
        class SearchResultPage << (V, lightblue) >>
        
    }

    namespace dill.forms {
        'subpackage?
        class ExperimentForm <<F, lightgreen>>
        ExperimentForm -|> django.forms.ModelForm
        ExperimentForm o-- dill.views.ExperimentEditView
        
        class NoteForm <<F, lightgreen>>
        NoteForm o-- dill.views.ExperimentView
    }

    namespace dill.admin {
        namespace dill.admin.views {
            class ExportView << (V,lightblue) >>
            class UserListView << (V,lightblue) >>
            'ExportView -|> django.views.View
            dill.admin.views.ExportView -|> dill.accounts.mixins.PermissionRequiredMixin
            dill.accounts.mixins.PermissionRequiredMixin <|- dill.admin.views.UserListView

        }
    }

    'django-media-fields.models.VideoField -[hidden]d- django.contrib.auth.base_user.AbstractBaseUser
    
    ' make it nice
    
    'django.views -[hidden]u- django.forms
    dill.accounts.middleware -[hidden]d- dill.admin
    'django.forms -[hidden]d- django.core.management.base.BaseCommand
    'django.core.management.base.BaseCommand -[hidden]d- django.views
    dill.models --[hidden]d- dill.accounts
    
    
}