[init] Initial commit

2024-03-31 21:02:53 +03:00
commit 04d4e83d1f
105 changed files with 8559 additions and 0 deletions
@@ -0,0 +1,7 @@
+import os
+
+import django.core.asgi
+
+os.environ.setdefault("DJANGO_SETTINGS_MODULE", "config.settings")
+
+application = django.core.asgi.get_asgi_application()
@@ -0,0 +1,153 @@
+import pathlib
+import sys
+
+import environs
+
+BASE_DIR = pathlib.Path(__file__).resolve().parent.parent
+
+env = environs.Env()
+env.read_env(BASE_DIR.parent / ".env")
+
+DEFAULT_HOSTS = ["127.0.0.1", "localhost"]
+
+with env.prefixed("DJANGO_"):
+    SECRET_KEY = env("SECRET_KEY", "secret_key")
+    DEBUG = env.bool("DEBUG", True)
+    ALLOWED_HOSTS = env.list("ALLOWED_HOSTS", DEFAULT_HOSTS)
+    INTERNAL_IPS = env.list("INTERNAL_IPS", ALLOWED_HOSTS)
+    CSRF_TRUSTED_ORIGINS = env.list("CSRF_TRUSTED_ORIGINS", [])
+    DB_NAME = env("DB_NAME", "db.sqlite3")
+
+with env.prefixed("POSTGRES_"):
+    if not DEBUG:
+        POSTGRES_DB = env("DB", "postgres")
+        POSTGRES_USER = env("USER", "postgres")
+        POSTGRES_PASSWORD = env("PASSWORD", "postgres")
+        POSTGRES_HOST = env("HOST")
+        POSTGRES_PORT = env("PORT", "5432")
+
+
+TESTING = len(sys.argv) > 1 and sys.argv[1] == "test"
+MIGRATING = len(sys.argv) > 1 and (
+    "migrate" in sys.argv[1] or "makemigrations" in sys.argv[1]
+)
+
+
+def register_debug_toolbar():
+    INSTALLED_APPS.append("debug_toolbar")
+    MIDDLEWARE.append("debug_toolbar.middleware.DebugToolbarMiddleware")
+
+
+INSTALLED_APPS = [
+    # django apps
+    "django.contrib.admin",
+    "django.contrib.auth",
+    "django.contrib.contenttypes",
+    "django.contrib.sessions",
+    "django.contrib.messages",
+    "django.contrib.staticfiles",
+    # third party apps
+    "rest_framework",
+    "rest_framework_simplejwt",
+    "drf_yasg",
+    # project apps
+    "users.apps.UsersConfig",
+    "notifications.apps.NotificationsConfig",
+]
+
+MIDDLEWARE = [
+    "django.middleware.security.SecurityMiddleware",
+    "django.contrib.sessions.middleware.SessionMiddleware",
+    "django.middleware.common.CommonMiddleware",
+    "django.middleware.csrf.CsrfViewMiddleware",
+    "django.contrib.auth.middleware.AuthenticationMiddleware",
+    "django.contrib.messages.middleware.MessageMiddleware",
+    "django.middleware.clickjacking.XFrameOptionsMiddleware",
+]
+
+ROOT_URLCONF = "config.urls"
+
+TEMPLATES_DIR = BASE_DIR / "templates"
+TEMPLATES = [
+    {
+        "BACKEND": "django.template.backends.django.DjangoTemplates",
+        "DIRS": [TEMPLATES_DIR],
+        "APP_DIRS": True,
+        "OPTIONS": {
+            "context_processors": [
+                "django.template.context_processors.debug",
+                "django.template.context_processors.request",
+                "django.contrib.auth.context_processors.auth",
+                "django.contrib.messages.context_processors.messages",
+            ],
+        },
+    },
+]
+
+WSGI_APPLICATION = "config.wsgi.application"
+
+if DEBUG:
+    DATABASES = {
+        "default": {
+            "ENGINE": "django.db.backends.sqlite3",
+            "NAME": BASE_DIR / DB_NAME,
+        },
+    }
+else:
+    DATABASES = {
+        "default": {
+            "ENGINE": "django.db.backends.postgresql_psycopg2",
+            "NAME": POSTGRES_DB,
+            "USER": POSTGRES_USER,
+            "PASSWORD": POSTGRES_PASSWORD,
+            "HOST": POSTGRES_HOST,
+            "PORT": POSTGRES_PORT,
+        },
+    }
+
+AUTH_PASSWORD_VALIDATORS = [
+    {
+        "NAME": (
+            "django.contrib.auth.password_validation"
+            ".UserAttributeSimilarityValidator"
+        ),
+    },
+    {
+        "NAME": (
+            "django.contrib.auth.password_validation.MinimumLengthValidator"
+        ),
+    },
+    {
+        "NAME": (
+            "django.contrib.auth.password_validation"
+            ".CommonPasswordValidator"
+        ),
+    },
+    {
+        "NAME": (
+            "django.contrib.auth.password_validation"
+            ".NumericPasswordValidator"
+        ),
+    },
+]
+
+LANGUAGE_CODE = "ru-ru"
+
+TIME_ZONE = "UTC"
+USE_TZ = True
+USE_I18N = True
+
+STATIC_URL = "static/"
+
+DEFAULT_AUTO_FIELD = "django.db.models.BigAutoField"
+
+AUTH_USER_MODEL = "users.User"
+
+REST_FRAMEWORK = {
+    "DEFAULT_AUTHENTICATION_CLASSES": [
+        "rest_framework_simplejwt.authentication.JWTAuthentication",
+    ],
+}
+
+if DEBUG and not (TESTING or MIGRATING):
+    register_debug_toolbar()
@@ -0,0 +1,68 @@
+import django.conf
+import django.contrib.admin
+import django.urls
+import rest_framework_simplejwt.views
+import users.views
+from django.urls import include, path
+from drf_yasg import openapi
+from drf_yasg.views import get_schema_view
+from rest_framework import permissions, routers
+from users.views import UserViewSet
+
+router = routers.DefaultRouter()
+router.register("users", UserViewSet)
+
+schema_view = get_schema_view(
+    openapi.Info(title="SkillHub API", default_version="v1"),
+    public=True,
+    permission_classes=(permissions.AllowAny,),
+)
+
+
+urlpatterns = [
+    path(
+        "swagger<format>/",
+        schema_view.without_ui(cache_timeout=0),
+        name="schema-json",
+    ),
+    path(
+        "swagger/",
+        schema_view.with_ui("swagger", cache_timeout=0),
+        name="schema-swagger-ui",
+    ),
+    path(
+        "redoc/",
+        schema_view.with_ui("redoc", cache_timeout=0),
+        name="schema-redoc",
+    ),
+    path("api/", include(router.urls)),
+    path("api/registration/", users.views.RegisterView.as_view()),
+    django.urls.path(
+        "api/token/",
+        rest_framework_simplejwt.views.TokenObtainPairView.as_view(),
+        name="token_obtain_pair",
+    ),
+    django.urls.path(
+        "api/token/refresh/",
+        rest_framework_simplejwt.views.TokenRefreshView.as_view(),
+        name="token_refresh",
+    ),
+    django.urls.path(
+        "api/token/verify/",
+        rest_framework_simplejwt.views.TokenVerifyView.as_view(),
+        name="token_verify",
+    ),
+    django.urls.path("admin/", django.contrib.admin.site.urls),
+]
+
+if django.conf.settings.DEBUG and not (
+    django.conf.settings.TESTING or django.conf.settings.MIGRATING
+):
+    import debug_toolbar
+
+    urlpatterns.append(
+        django.urls.path(
+            "__debug__/",
+            django.urls.include(debug_toolbar.urls),
+        ),
+    )
@@ -0,0 +1,7 @@
+import os
+
+import django.core.wsgi
+
+os.environ.setdefault("DJANGO_SETTINGS_MODULE", "config.settings")
+
+application = django.core.wsgi.get_wsgi_application()
@@ -0,0 +1,21 @@
+#!/usr/bin/env python
+import os
+import sys
+
+
+def main():
+    os.environ.setdefault("DJANGO_SETTINGS_MODULE", "config.settings")
+    try:
+        from django.core.management import execute_from_command_line
+    except ImportError as exc:
+        msg = (
+            "Couldn't import Django. Are you sure it's installed and "
+            "available on your PYTHONPATH environment variable? Did you "
+            "forget to activate a virtual environment?"
+        )
+        raise ImportError(msg) from exc
+    execute_from_command_line(sys.argv)
+
+
+if __name__ == "__main__":
+    main()
@@ -0,0 +1,32 @@
+from django.contrib import admin
+
+from notifications import models
+from notifications.forms import (
+    CreateNotificationAdminForm,
+    EditNotificationAdminForm,
+)
+
+
+class NotificationAdmin(admin.ModelAdmin):
+    form = EditNotificationAdminForm
+    add_form = CreateNotificationAdminForm
+    list_display = [
+        models.Notification.title.field.name,
+        models.Notification.user.field.name,
+        models.Notification.content.field.name,
+        models.Notification.read.field.name,
+        models.Notification.created_at.field.name,
+    ]
+
+    def get_readonly_fields(self, request, obj=None):  # noqa: ARG002
+        if obj:
+            return (
+                *self.readonly_fields,
+                models.Notification.read.field.name,
+                models.Notification.created_at.field.name,
+            )
+
+        return self.readonly_fields
+
+
+admin.site.register(models.Notification, NotificationAdmin)
@@ -0,0 +1,6 @@
+from django.apps import AppConfig
+
+
+class NotificationsConfig(AppConfig):
+    default_auto_field = "django.db.models.BigAutoField"
+    name = "notifications"
@@ -0,0 +1,23 @@
+from django import forms
+
+from notifications.models import Notification
+
+
+class EditNotificationAdminForm(forms.ModelForm):
+    class Meta:
+        model = Notification
+        fields = (
+            model.user.field.name,
+            model.title.field.name,
+            model.content.field.name,
+        )
+
+
+class CreateNotificationAdminForm(forms.ModelForm):
+    class Meta:
+        model = Notification
+        fields = (
+            model.user.field.name,
+            model.title.field.name,
+            model.content.field.name,
+        )
@@ -0,0 +1,56 @@
+# Generated by Django 4.2.11 on 2024-03-31 15:06
+
+from django.conf import settings
+from django.db import migrations, models
+import django.db.models.deletion
+
+
+class Migration(migrations.Migration):
+
+    initial = True
+
+    dependencies = [
+        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name="Notification",
+            fields=[
+                (
+                    "id",
+                    models.BigAutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name="ID",
+                    ),
+                ),
+                ("title", models.CharField(max_length=150, verbose_name="заголовок")),
+                ("content", models.TextField(null=True, verbose_name="содержание")),
+                (
+                    "read",
+                    models.BooleanField(default=False, verbose_name="дата создания"),
+                ),
+                (
+                    "created_at",
+                    models.DateTimeField(
+                        auto_now_add=True, verbose_name="дата создания"
+                    ),
+                ),
+                (
+                    "user",
+                    models.ForeignKey(
+                        on_delete=django.db.models.deletion.CASCADE,
+                        related_name="notifications",
+                        to=settings.AUTH_USER_MODEL,
+                        verbose_name="пользователь",
+                    ),
+                ),
+            ],
+            options={
+                "verbose_name": "уведомление",
+                "verbose_name_plural": "уведомления",
+            },
+        ),
+    ]
@@ -0,0 +1,44 @@
+from django.conf import settings
+from django.db import models
+
+
+class NotificationManager(models.Manager):
+    def by_user(self, user_id):
+        return self.get_queryset().filter(
+            user__id=user_id,
+        )
+
+
+class Notification(models.Model):
+    user = models.ForeignKey(
+        settings.AUTH_USER_MODEL,
+        on_delete=models.CASCADE,
+        related_name="notifications",
+        verbose_name="пользователь",
+    )
+    title = models.CharField(
+        max_length=150,
+        verbose_name="заголовок",
+        null=False,
+    )
+    content = models.TextField(
+        verbose_name="содержание",
+        null=False,
+    )
+    read = models.BooleanField(
+        "дата создания",
+        default=False,
+    )
+    created_at = models.DateTimeField(
+        auto_now_add=True,
+        verbose_name="дата создания",
+    )
+
+    objects = NotificationManager()
+
+    class Meta:
+        verbose_name = "уведомление"
+        verbose_name_plural = "уведомления"
+
+    def __str__(self):
+        return self.title
@@ -0,0 +1,9 @@
+from rest_framework import serializers
+
+from notifications.models import Notification
+
+
+class NotificationSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = Notification
+        fields = ["title", "content", "read", "created_at"]
@@ -0,0 +1 @@
+# Create your tests here.
@@ -0,0 +1,14 @@
+from rest_framework import generics
+from rest_framework.permissions import IsAuthenticated
+
+from notifications.models import Notification
+from notifications.serializers import NotificationSerializer
+
+
+class UserNotificationsAPIView(generics.ListAPIView):
+    serializer_class = NotificationSerializer
+    permission_classes = [IsAuthenticated]
+
+    def get_queryset(self):
+        user = self.request.user
+        return Notification.objects.by_user(user.id)
@@ -0,0 +1,6 @@
+from django.apps import AppConfig
+
+
+class TeamsConfig(AppConfig):
+    default_auto_field = "django.db.models.BigAutoField"
+    name = "teams"
@@ -0,0 +1,96 @@
+import users.models
+from django.core import validators
+from django.db import models
+
+
+class Vacancy(models.Model):
+    name = models.CharField(
+        max_length=255,
+        verbose_name="название вакансии",
+    )
+    start_date = models.DateField(
+        verbose_name="дата начала диапазона возраста участников",
+        blank=True,
+        null=True,
+    )
+
+    end_date = models.DateField(
+        verbose_name="дата конец диапазона возраста участников",
+        blank=True,
+        null=True,
+    )
+    specialization = models.ForeignKey(
+        users.models.Specialization,
+        on_delete=models.CASCADE,
+        blank=True,
+        verbose_name="специализация",
+        null=True,
+    )
+    skills = models.ManyToManyField(
+        users.models.Skill,
+        blank=True,
+        verbose_name="Технологии",
+    )
+
+    def __str__(self):
+        return self.name
+
+
+class Team(models.Model):
+    description = models.TextField(
+        verbose_name="описание команды",
+    )
+
+    name = models.CharField(
+        verbose_name="название команды",
+        max_length=255,
+    )
+
+    members = models.ManyToManyField(
+        users.models.User,
+        blank=True,
+        unique=True,
+        verbose_name="участники",
+    )
+
+    vacancies = models.ManyToManyField(
+        Vacancy,
+        blank=True,
+        unique=True,
+        verbose_name="вакансии",
+    )
+
+    avatar = models.ImageField(
+        upload_to="teams_avatars",
+        blank=True,
+        verbose_name="аватарка",
+    )
+
+    count_of_members = models.IntegerField(
+        validators=[
+            validators.MinValueValidator(1),
+            validators.MaxLengthValidator(5),
+        ],
+        verbose_name="количество участников",
+        null=True,
+    )
+
+    country = models.CharField(
+        blank=True,
+        max_length=255,
+        verbose_name="страна",
+    )
+
+    city = models.CharField(
+        blank=True,
+        max_length=255,
+        verbose_name="город",
+    )
+
+    author = models.ForeignKey(
+        users.models.User,
+        on_delete=models.CASCADE,
+    )
+
+    def __str__(self):
+        return self.name
@@ -0,0 +1,9 @@
+from rest_framework import serializers
+
+from teams.models import Team
+
+
+class TeamSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = Team
+        fields = ["id", "name", "description"]
@@ -0,0 +1,11 @@
+from django.urls import path
+
+from .views import AddUserToTeam
+
+urlpatterns = [
+    path(
+        "add_user_to_team/<int:team_id>/<int:user_id>/",
+        AddUserToTeam.as_view(),
+        name="add_user_to_team",
+    ),
+]
@@ -0,0 +1,27 @@
+from backend.project.users.models import User
+from rest_framework import status
+from rest_framework.response import Response
+from rest_framework.views import APIView
+
+from teams.models import Team
+
+from .serializers import TeamSerializer
+
+
+class AddUserToTeam(APIView):
+    def post(self, request, team_id, user_id):  # noqa: ARG002
+        try:
+            team = Team.objects.get(id=team_id)
+            user = User.objects.get(id=user_id)
+        except Team.DoesNotExist:
+            return Response(
+                {"error": "Team not found"}, status=status.HTTP_404_NOT_FOUND
+            )
+        except User.DoesNotExist:
+            return Response(
+                {"error": "User not found"}, status=status.HTTP_404_NOT_FOUND
+            )
+
+        team.members.add(user)
+        team_serializer = TeamSerializer(team)
+        return Response(team_serializer.data, status=status.HTTP_200_OK)
@@ -0,0 +1,5 @@
+from django.contrib import admin
+
+from users.models import User
+
+admin.site.register(User)
@@ -0,0 +1,6 @@
+from django.apps import AppConfig
+
+
+class UsersConfig(AppConfig):
+    default_auto_field = "django.db.models.BigAutoField"
+    name = "users"
@@ -0,0 +1,97 @@
+# Generated by Django 5.0.3 on 2024-03-31 12:22
+
+import django.contrib.auth.models
+import django.contrib.auth.validators
+import django.core.validators
+import django.db.models.deletion
+import django.utils.timezone
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    initial = True
+
+    dependencies = [
+        ('auth', '0012_alter_user_first_name_max_length'),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='Achievements',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('name', models.CharField(max_length=255, verbose_name='Название достижения')),
+                ('info', models.TextField(max_length=255, verbose_name='Информация про достижение')),
+                ('file', models.FileField(upload_to='achievements', verbose_name='Файл достижения')),
+            ],
+        ),
+        migrations.CreateModel(
+            name='Skill',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('name', models.CharField(max_length=255, unique=True)),
+                ('level', models.IntegerField(validators=[django.core.validators.MinValueValidator(1), django.core.validators.MaxValueValidator(10)], verbose_name='уровень навыка')),
+            ],
+            options={
+                'abstract': False,
+            },
+        ),
+        migrations.CreateModel(
+            name='Specialization',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('name', models.CharField(max_length=255, unique=True)),
+            ],
+            options={
+                'abstract': False,
+            },
+        ),
+        migrations.CreateModel(
+            name='Tag',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('name', models.CharField(max_length=255, unique=True)),
+            ],
+            options={
+                'abstract': False,
+            },
+        ),
+        migrations.CreateModel(
+            name='User',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('password', models.CharField(max_length=128, verbose_name='password')),
+                ('last_login', models.DateTimeField(blank=True, null=True, verbose_name='last login')),
+                ('is_superuser', models.BooleanField(default=False, help_text='Designates that this user has all permissions without explicitly assigning them.', verbose_name='superuser status')),
+                ('username', models.CharField(error_messages={'unique': 'A user with that username already exists.'}, help_text='Required. 150 characters or fewer. Letters, digits and @/./+/-/_ only.', max_length=150, unique=True, validators=[django.contrib.auth.validators.UnicodeUsernameValidator()], verbose_name='username')),
+                ('first_name', models.CharField(blank=True, max_length=150, verbose_name='first name')),
+                ('last_name', models.CharField(blank=True, max_length=150, verbose_name='last name')),
+                ('is_staff', models.BooleanField(default=False, help_text='Designates whether the user can log into this admin site.', verbose_name='staff status')),
+                ('is_active', models.BooleanField(default=True, help_text='Designates whether this user should be treated as active. Unselect this instead of deleting accounts.', verbose_name='active')),
+                ('date_joined', models.DateTimeField(default=django.utils.timezone.now, verbose_name='date joined')),
+                ('email', models.EmailField(max_length=254, unique=True, verbose_name='электронная почта')),
+                ('birthday', models.DateField(blank=True, help_text='Введите дату рождения', null=True, verbose_name='дата рождения')),
+                ('avatar', models.ImageField(blank=True, upload_to='avatars', verbose_name='Аватарка')),
+                ('country', models.CharField(blank=True, max_length=255, verbose_name='страна')),
+                ('city', models.CharField(blank=True, max_length=255, verbose_name='город')),
+                ('bio', models.TextField(blank=True, validators=[django.core.validators.MaxLengthValidator(512)], verbose_name='обо мне')),
+                ('experience', models.IntegerField(null=True, validators=[django.core.validators.MinValueValidator(0), django.core.validators.MinValueValidator(100)], verbose_name='опыт работы')),
+                ('groups', models.ManyToManyField(blank=True, help_text='The groups this user belongs to. A user will get all permissions granted to each of their groups.', related_name='user_set', related_query_name='user', to='auth.group', verbose_name='groups')),
+                ('user_permissions', models.ManyToManyField(blank=True, help_text='Specific permissions for this user.', related_name='user_set', related_query_name='user', to='auth.permission', verbose_name='user permissions')),
+                ('achievements', models.ManyToManyField(blank=True, to='users.achievements', verbose_name='достижения')),
+                ('technologies', models.ManyToManyField(blank=True, to='users.skill', verbose_name='технологии')),
+                ('specialization', models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.CASCADE, to='users.specialization', verbose_name='специализация')),
+                ('tag', models.ManyToManyField(blank=True, to='users.tag', verbose_name='теги')),
+            ],
+            options={
+                'verbose_name': 'user',
+                'verbose_name_plural': 'users',
+                'abstract': False,
+                'swappable': 'AUTH_USER_MODEL',
+            },
+            managers=[
+                ('objects', django.contrib.auth.models.UserManager()),
+            ],
+        ),
+    ]
@@ -0,0 +1,18 @@
+# Generated by Django 5.0.3 on 2024-03-31 13:48
+
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('users', '0001_initial'),
+    ]
+
+    operations = [
+        migrations.RenameField(
+            model_name='user',
+            old_name='technologies',
+            new_name='skills',
+        ),
+    ]
@@ -0,0 +1,128 @@
+from django.contrib.auth.models import AbstractUser
+from django.core import validators
+from django.db import models
+
+
+class AbstractTag(models.Model):
+    name = models.CharField(
+        max_length=255,
+        unique=True,
+    )
+
+    class Meta:
+        abstract = True
+
+    def __str__(self):
+        return self.name
+
+
+class Tag(AbstractTag):
+    pass
+
+
+class Skill(AbstractTag):
+    level = models.IntegerField(
+        validators=[
+            validators.MinValueValidator(1),
+            validators.MaxValueValidator(10),
+        ],
+        verbose_name="уровень навыка",
+    )
+
+
+class Specialization(AbstractTag):
+    pass
+
+
+class Achievements(models.Model):
+    name = models.CharField(
+        max_length=255,
+        verbose_name="Название достижения",
+    )
+
+    info = models.TextField(
+        max_length=255,
+        verbose_name="Информация про достижение",
+    )
+
+    file = models.FileField(
+        upload_to="achievements",
+        verbose_name="Файл достижения",
+    )
+
+    def __str__(self):
+        return self.name
+
+
+class User(AbstractUser):
+    email = models.EmailField("электронная почта", unique=True)
+
+    birthday = models.DateField(
+        verbose_name="дата рождения",
+        help_text="Введите дату рождения",
+        blank=True,
+        null=True,
+    )
+
+    avatar = models.ImageField(
+        upload_to="avatars",
+        blank=True,
+        verbose_name="Аватарка",
+    )
+
+    country = models.CharField(
+        blank=True,
+        max_length=255,
+        verbose_name="страна",
+    )
+
+    city = models.CharField(
+        blank=True,
+        max_length=255,
+        verbose_name="город",
+    )
+
+    bio = models.TextField(
+        blank=True,
+        validators=[
+            validators.MaxLengthValidator(
+                512,
+            ),
+        ],
+        verbose_name="обо мне",
+    )
+
+    skills = models.ManyToManyField(
+        Skill,
+        blank=True,
+        verbose_name="технологии",
+    )
+
+    tag = models.ManyToManyField(
+        Tag,
+        blank=True,
+        verbose_name="теги",
+    )
+
+    experience = models.IntegerField(
+        validators=[
+            validators.MinValueValidator(0),
+            validators.MinValueValidator(100),
+        ],
+        verbose_name="опыт работы",
+        null=True,
+    )
+
+    achievements = models.ManyToManyField(
+        Achievements,
+        blank=True,
+        verbose_name="достижения",
+    )
+
+    specialization = models.ForeignKey(
+        Specialization,
+        on_delete=models.CASCADE,
+        blank=True,
+        verbose_name="специализация",
+        null=True,
+    )
@@ -0,0 +1,26 @@
+import rest_framework.serializers
+
+import users.models
+
+
+class UserSerializer(rest_framework.serializers.ModelSerializer):
+    class Meta:
+        model = users.models.User
+        fields = (
+            "email",
+            "birthday",
+            "country",
+            "city",
+            "bio",
+            "avatar",
+            "password",
+            "first_name",
+            "last_name",
+            "tag",
+            "specialization",
+            "experience",
+            "achievements",
+            "username",
+        )
+
+    extra_kwargs = {"password": {"write_only": True}}
@@ -0,0 +1,47 @@
+import rest_framework.generics
+import rest_framework.permissions
+import rest_framework.response
+import rest_framework.viewsets
+
+import users.models
+import users.serializers
+
+
+class UserViewSet(rest_framework.viewsets.ModelViewSet):
+    http_method_names = ("get",)
+
+    queryset = users.models.User.objects.all()
+    serializer_class = users.serializers.UserSerializer
+    permission_classes = [rest_framework.permissions.IsAuthenticated]
+
+
+class RegisterView(rest_framework.generics.CreateAPIView):
+    http_method_names = ("post",)
+    serializer_class = users.serializers.UserSerializer
+
+    def post(self, request):
+        if users.models.User.objects.filter(
+            username=request.data.get("username"),
+        ).exists():
+            return rest_framework.response.Response(
+                {
+                    "username": [
+                        "пользователь с таким именем уже существует.",
+                    ],
+                },
+                status=rest_framework.status.HTTP_409_CONFLICT,
+            )
+
+        serializer = self.get_serializer(data=request.data)
+        if serializer.is_valid():
+            serializer.save()
+
+            return rest_framework.response.Response(
+                serializer.data,
+                status=rest_framework.status.HTTP_201_CREATED,
+            )
+
+        return rest_framework.response.Response(
+            serializer.errors,
+            status=rest_framework.status.HTTP_400_BAD_REQUEST,
+        )