[init] Initial commit

backend/.dockerignore

@@ -0,0 +1,3 @@
+# Folders
+venv/
+__pycache__/

backend/.gitignore

@@ -0,0 +1,164 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+*.sqlite3
+*.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+# Django stuff
+cache
+media

backend/Dockerfile

@@ -0,0 +1,9 @@
+FROM python:3.12-slim
+
+WORKDIR /app
+
+COPY requirements/prod.txt .
+
+RUN pip install --no-cache-dir -r prod.txt
+
+COPY . .

backend/Makefile

@@ -0,0 +1,37 @@
+dump:
+	@cd project && python -Xutf8 manage.py dumpdata users --format json --indent 4 -o fixtures/users.json
+
+load:
+	@cd project && python -Xutf8 manage.py loaddata fixtures/users.json
+
+mig:
+	@cd project && python manage.py makemigrations
+	@cd project && python manage.py migrate
+
+check: test
+	@ruff check
+
+test:
+	@cd project && python manage.py test
+
+run:
+	@cd project && python manage.py runserver
+
+su:
+	@cd project && python manage.py createsuperuser
+
+loc-m:
+	@cd project && django-admin makemessages -l ru -l en
+
+loc-c:
+	@cd project && django-admin compilemessages
+
+help:
+	@cd project && python manage.py help
+
+fix:
+	ruff check --fix
+	sort-requirements requirements/prod.txt requirements/test.txt requirements/dev.txt
+
+req:
+	@pip install -r requirements/dev.txt

backend/README.md

@@ -0,0 +1 @@
+# SkillHub Backend folder

backend/project/config/asgi.py

@@ -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()

backend/project/config/settings.py

@@ -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()

backend/project/config/urls.py

@@ -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),
+        ),
+    )

backend/project/config/wsgi.py

@@ -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()

backend/project/manage.py

@@ -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()

backend/project/notifications/admin.py

@@ -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)

backend/project/notifications/apps.py

@@ -0,0 +1,6 @@
+from django.apps import AppConfig
+
+
+class NotificationsConfig(AppConfig):
+    default_auto_field = "django.db.models.BigAutoField"
+    name = "notifications"

backend/project/notifications/forms.py

@@ -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,
+        )

backend/project/notifications/migrations/0001_initial.py

@@ -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": "уведомления",
+            },
+        ),
+    ]

backend/project/notifications/models.py

@@ -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

backend/project/notifications/serializers.py

@@ -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"]

backend/project/notifications/tests.py

@@ -0,0 +1 @@
+# Create your tests here.

backend/project/notifications/views.py

@@ -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)

backend/project/teams/apps.py

@@ -0,0 +1,6 @@
+from django.apps import AppConfig
+
+
+class TeamsConfig(AppConfig):
+    default_auto_field = "django.db.models.BigAutoField"
+    name = "teams"

backend/project/teams/models.py

@@ -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

backend/project/teams/serializer.py

@@ -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"]

backend/project/teams/urls.py

@@ -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",
+    ),
+]

backend/project/teams/views.py

@@ -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)

backend/project/users/admin.py

@@ -0,0 +1,5 @@
+from django.contrib import admin
+
+from users.models import User
+
+admin.site.register(User)

backend/project/users/apps.py

@@ -0,0 +1,6 @@
+from django.apps import AppConfig
+
+
+class UsersConfig(AppConfig):
+    default_auto_field = "django.db.models.BigAutoField"
+    name = "users"

backend/project/users/migrations/0001_initial.py

@@ -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()),
+            ],
+        ),
+    ]

backend/project/users/migrations/0002_rename_technologies_user_skills.py

@@ -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',
+        ),
+    ]

backend/project/users/models.py

@@ -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,
+    )

backend/project/users/serializers.py

@@ -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}}

backend/project/users/views.py

@@ -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,
+        )

backend/pyproject.toml

@@ -0,0 +1,14 @@
+[tool.ruff]
+line-length = 79
+indent-width = 4
+exclude = ["migrations", "venv", ".venv"]
+
+[tool.ruff.lint]
+select = ["ALL"]
+ignore = ["D", "ANN", "EXE002", "RUF012", "RUF001", "COM812", "ISC001"]
+
+[tool.ruff.format]
+quote-style = "double"
+indent-style = "space"
+skip-magic-trailing-comma = false
+line-ending = "auto"

backend/requirements/dev.txt

@@ -0,0 +1,6 @@
+black
+sort-requirements
+ruff==0.3.4
+
+-r prod.txt
+-r test.txt

backend/requirements/prod.txt

@@ -0,0 +1,10 @@
+django==4.2.11
+environs==11.0.0
+gunicorn==21.2.0
+python-dotenv==1.0.1
+psycopg2-binary==2.9.9
+djangorestframework==3.15.1
+djangorestframework-simplejwt==5.3.1
+django-filter==24.2
+Pillow==10.2.0
+drf-yasg==1.21.7

backend/requirements/test.txt

@@ -0,0 +1 @@
+django-debug-toolbar==4.3.0

backend/template.env

@@ -0,0 +1,18 @@
+# For django app
+
+DJANGO_SECRET_KEY = your-secret-key
+DJANGO_DEBUG = False
+DJANGO_ALLOWED_HOSTS = 127.0.0.1,localhost
+DJANGO_INTERNAL_IPS = 127.0.0.1,localhost
+DJANGO_CSRF_TRUSTED_ORIGINS = http://127.0.0.1:8000,localhost
+
+# For docker(remove if you want to keep defaults)
+
+POSTGRES_PORT = <port_to_be_forwared> # default: 5432
+POSTGRES_DB = <db_name> # default: postgres
+POSTGRES_USER = <postgres_user> # default: postgres
+POSTGRES_PASSWORD = <password> # default: postgres
+
+PGADMIN_PORT = <port_to_be_forwared> # default: 5050
+PGADMIN_EMAIL = <email> # default: admin@mail.com
+PGADMIN_PASSWORD = <password> # default: admin