update employment skills and refactor

app/blueprints/skills_category_blueprint.py

@@ -5,13 +5,13 @@
     Security,
     Auth,
 )
-from app.controllers.skills_category_controller import SkillsCategoryController
+from app.controllers.skill_category_controller import SkillCategoryController
 
 url_prefix = "{}/skills_categories".format(BaseBlueprint.base_url_prefix)
 skills_category_blueprint = Blueprint(
     "skills_category", __name__, url_prefix=url_prefix
 )
-skills_category_controller = SkillsCategoryController(request)
+skills_category_controller = SkillCategoryController(request)
 
 
 @skills_category_blueprint.route("/", methods=["GET"])

app/blueprints/user_employment_blueprint.py

@@ -39,6 +39,7 @@ def get_user_employment(user_employment_id):
         "start_date|required:date",
         "end_date|required:date",
         "is_current|required",
+        "skills|optional:list_int",
     ]
 )
 @Auth.has_permission(["create_user_employment_history"])

app/controllers/skills_category_controller.py → app/controllers/skill_category_controller.py

@@ -1,16 +1,16 @@
 from app.controllers.base_controller import BaseController
-from app.repositories.skills_category_repo import SkillsCategoryRepo
+from app.repositories.skill_category_repo import SkillCategoryRepo
 from app.utils.redisset import RedisSet
 
 
-class SkillsCategoryController(BaseController):
+class SkillCategoryController(BaseController):
     def __init__(self, request):
         BaseController.__init__(self, request)
-        self.skills_category_repo = SkillsCategoryRepo()
+        self.skill_category_repo = SkillCategoryRepo()
         self.redis_set = RedisSet()
 
     def list_skills_categories(self):
-        skills_categories = self.skills_category_repo.filter_by(is_deleted=False)
+        skills_categories = self.skill_category_repo.filter_by(is_deleted=False)
 
         skills_category_list = [
             skills_category.serialize() for skills_category in skills_categories.items
@@ -24,7 +24,7 @@ def list_skills_categories(self):
         )
 
     def get_skills_category(self, skills_category_id):
-        skills_category = self.skills_category_repo.get(skills_category_id)
+        skills_category = self.skill_category_repo.get(skills_category_id)
         if skills_category:
             return self.handle_response(
                 "OK", payload={"skills_category": skills_category.serialize()}
@@ -35,11 +35,11 @@ def get_skills_category(self, skills_category_id):
 
     def create_skills_category(self):
         name, help_ = self.request_params("name", "help")
-        skills_category1 = self.skills_category_repo.find_first(name=name)
+        skills_category1 = self.skill_category_repo.find_first(name=name)
 
         if not skills_category1:
             try:
-                skills_category = self.skills_category_repo.new_skills_category(
+                skills_category = self.skill_category_repo.new_skill_category(
                     name=name, help_=help_
                 )
                 return self.handle_response(
@@ -58,11 +58,11 @@ def create_skills_category(self):
 
     def update_skills_category(self, skills_category_id):
         name, help_ = self.request_params("name", "help")
-        skills_category = self.skills_category_repo.get(skills_category_id)
+        skills_category = self.skill_category_repo.get(skills_category_id)
         if skills_category:
             updates = {}
             if name:
-                skills_category1 = self.skills_category_repo.find_first(name=name)
+                skills_category1 = self.skill_category_repo.find_first(name=name)
                 if skills_category1:
                     return self.handle_response(
                         "Skills Category with this name already exists", status_code=400
@@ -71,7 +71,7 @@ def update_skills_category(self, skills_category_id):
             if help_:
                 updates["help"] = help_
 
-            self.skills_category_repo.update(skills_category, **updates)
+            self.skill_category_repo.update(skills_category, **updates)
             return self.handle_response(
                 "OK", payload={"skills_category": skills_category.serialize()}
             )
@@ -80,11 +80,11 @@ def update_skills_category(self, skills_category_id):
         )
 
     def delete_skills_category(self, skills_category_id):
-        skills_category = self.skills_category_repo.get(skills_category_id)
+        skills_category = self.skill_category_repo.get(skills_category_id)
         if skills_category:
             updates = {}
             updates["is_deleted"] = True
-            self.skills_category_repo.update(skills_category, **updates)
+            self.skill_category_repo.update(skills_category, **updates)
             return self.handle_response(
                 "skills category deleted", payload={"status": "success"}
             )

app/controllers/user_employment_controller.py

@@ -1,23 +1,44 @@
 import datetime
 
 from app.controllers.base_controller import BaseController
-from app.repositories import UserRepo
-from app.repositories.user_employment_repo import UserEmploymentRepo
+from app.repositories import (
+    UserRepo,
+    SkillRepo,
+    UserEmploymentRepo,
+    UserEmploymentSkillRepo,
+)
 
 
 class UserEmploymentController(BaseController):
     def __init__(self, request):
         BaseController.__init__(self, request)
         self.user_repo = UserRepo()
         self.user_employment_repo = UserEmploymentRepo()
+        self.user_employment_skill_repo = UserEmploymentSkillRepo()
+        self.skill_repo = SkillRepo()
+
+    def _get_employment_skills(self, employment_id):
+        skills_list = []
+        skills = self.user_employment_skill_repo.get_unpaginated(
+            user_employment_id=employment_id
+        )
+        for skill in skills:
+            skill_data = self.skill_repo.find_first(id=skill)
+            skill_dict = skill_data.serialize()
+            skill_dict["name"] = skill_data.name
+            skills_list.append(skill_dict)
+        return skills_list
 
     def list_user_employment_history(self, user_id):
         user_employments = self.user_employment_repo.get_unpaginated(user_id=user_id)
 
-        user_employment_list = [
-            user_employment.serialize() for user_employment in user_employments
-        ]
-
+        user_employment_list = []
+        for user_employment in user_employments:
+            user_employment_dict = user_employment.serialize()
+            user_employment_dict["skills"] = self._get_employment_skills(
+                user_employment.id
+            )
+            user_employment_list.append(user_employment_dict)
         return self.handle_response(
             "OK",
             payload={
@@ -27,9 +48,14 @@ def list_user_employment_history(self, user_id):
 
     def get_user_employment(self, user_employment_id):
         user_employment = self.user_employment_repo.get(user_employment_id)
+
         if user_employment:
+            user_employment_dict = user_employment.serialize()
+            user_employment_dict["skills"] = self._get_employment_skills(
+                user_employment.id
+            )
             return self.handle_response(
-                "OK", payload={"user_employment": user_employment.serialize()}
+                "OK", payload={"user_employment": user_employment_dict}
             )
         return self.handle_response(
             "Invalid User Employment or Missing user_employment_id", status_code=400
@@ -43,13 +69,15 @@ def create_user_employment(self):
             start_date,
             end_date,
             is_current,
+            skills,
         ) = self.request_params(
             "user_id",
             "institution_name",
             "job_title",
             "start_date",
             "end_date",
             "is_current",
+            "skills",
         )
         try:
 
@@ -69,14 +97,35 @@ def create_user_employment(self):
                 end_date=end_date,
                 is_current=is_current,
             )
+            skills_dict = self._process_skills(user_employment.id, skills)
+
+            user_employment_serialized = user_employment.serialize()
+            user_employment_serialized["skills"] = skills_dict
             return self.handle_response(
                 "OK",
-                payload={"user_employment": user_employment.serialize()},
+                payload={"user_employment": user_employment_serialized},
                 status_code=201,
             )
         except Exception as e:
             return self.handle_response("Error processing: " + str(e), status_code=400)
 
+    def _process_skills(self, user_employment_id, skills):
+        skills_dict = []
+
+        if skills is not None:
+
+            for skill in skills:
+                user_employment_skills = (
+                    self.user_employment_skill_repo.new_user_employment_skill(
+                        user_employment_id=user_employment_id, skill_id=skill
+                    )
+                )
+                skill_data = self.skill_repo.find_first(id=skill)
+                user_employment_skill_dict = user_employment_skills.serialize()
+                user_employment_skill_dict["name"] = skill_data.name
+                skills_dict.append(user_employment_skill_dict)
+        return skills_dict
+
     def update_user_employment(self, update_id):
         (
             user_id,
@@ -86,6 +135,7 @@ def update_user_employment(self, update_id):
             start_date,
             end_date,
             is_current,
+            skills,
         ) = self.request_params(
             "user_id",
             "user_employment_id",
@@ -94,6 +144,7 @@ def update_user_employment(self, update_id):
             "start_date",
             "end_date",
             "is_current",
+            "skills",
         )
         if update_id != user_employment_id:
             return self.handle_response(
@@ -116,9 +167,14 @@ def update_user_employment(self, update_id):
             }
 
             self.user_employment_repo.update(user_employment, **updates)
+            skills_dict = self._process_skills(user_employment.id, skills)
+            user_employment_serialized = user_employment.serialize()
+            user_employment_serialized["skills"] = skills_dict
             return self.handle_response(
-                "OK", payload={"user_employment": user_employment.serialize()}
+                "OK",
+                payload={"user_employment": user_employment_serialized},
             )
+
         return self.handle_response(
             "Invalid or incorrect user_employment_id provided", status_code=400
         )

app/models/__init__.py

@@ -7,10 +7,10 @@
 from .user_role import UserRole
 from .user import User
 from .skill import Skill
-from .skills_category import SkillsCategory
+from .skill_category import SkillCategory
 from .user_education import UserEducation
 from .user_employment import UserEmployment
-from .user_employment_skills import UserEmploymentSkill
+from .user_employment_skill import UserEmploymentSkill
 from .user_project import UserProject
 from .user_skills import UserSkills
 from .location import Location
@@ -21,7 +21,7 @@
     "UserRole",
     "Activity",
     "User",
-    "SkillsCategory",
+    "SkillCategory",
     "Skill",
     "UserSkills",
     "UserProject",
@@ -44,7 +44,7 @@
     UserRole,
     User,
     Skill,
-    SkillsCategory,
+    SkillCategory,
     Location,
 ]
 tables_logged_after_every_update = [
@@ -58,7 +58,7 @@
     UserRole,
     User,
     Skill,
-    SkillsCategory,
+    SkillCategory,
     Location,
 ]
 tables_logged_after_every_delete = [
@@ -72,7 +72,7 @@
     UserRole,
     User,
     Skill,
-    SkillsCategory,
+    SkillCategory,
     Location,
 ]
 generate_id_tables = (User,)

app/models/skill.py

@@ -7,7 +7,7 @@ class Skill(BaseModel):
     __tablename__ = "skills"
 
     name = db.Column(db.String(100), nullable=False)
-    skills_category_id = db.Column(db.Integer(), db.ForeignKey("skill_categories.id"))
-    skills_category = db.relationship("SkillsCategory", lazy=False)
+    skill_category_id = db.Column(db.Integer(), db.ForeignKey("skill_categories.id"))
+    skill_category = db.relationship("SkillCategory", lazy=False)
     is_active = db.Column(db.Boolean, default=True, nullable=True)
     is_deleted = db.Column(db.Boolean, default=False, nullable=True)

app/models/skills_category.py → app/models/skill_category.py

@@ -1,11 +1,12 @@
 from .base_model import BaseModel, db
 
 
-class SkillsCategory(BaseModel):
+class SkillCategory(BaseModel):
 
     __tablename__ = "skill_categories"
 
     name = db.Column(db.String(100), nullable=False)
     help = db.Column(db.Text(), nullable=True)
     is_active = db.Column(db.Boolean, default=True, nullable=True)
     is_deleted = db.Column(db.Boolean, default=False, nullable=True)
+    skills = db.relationship("Skill", backref="skill_categories", lazy=True)

app/models/user.py

@@ -18,6 +18,6 @@ class User(BaseModel):
     image_url = db.Column(db.String, nullable=True)
     gender = db.Column(db.Enum(Gender), nullable=True)
     date_of_birth = db.Column(db.Date(), nullable=False)
-    user_role = db.relationship("UserRole", lazy=True)
+    user_role = db.relationship("UserRole", backref="user_roles", lazy=True)
     is_active = db.Column(db.Boolean, default=True, nullable=True)
     is_deleted = db.Column(db.Boolean, default=True, nullable=True)

app/models/user_employment.py

@@ -12,3 +12,6 @@ class UserEmployment(BaseModel):
     user_id = db.Column(db.Integer(), db.ForeignKey("users.id"))
     user = db.relationship("User", lazy=False)
     is_current = db.Column(db.Boolean, default=False, nullable=True)
+    skills = db.relationship(
+        "UserEmploymentSkill", backref="user_employment_skills", lazy=True
+    )

app/models/user_employment_skills.py → app/models/user_employment_skill.py

@@ -6,7 +6,7 @@ class UserEmploymentSkill(BaseModel):
 
     __tablename__ = "user_employment_skills"
 
-    user_employement_id = db.Column(db.Integer(), db.ForeignKey("user_employments.id"))
-    user_employement = db.relationship("UserEmployment", lazy=False)
+    user_employment_id = db.Column(db.Integer(), db.ForeignKey("user_employments.id"))
+    user_employment = db.relationship("UserEmployment", lazy=False)
     skill_id = db.Column(db.Integer(), db.ForeignKey("skills.id"))
     skill = db.relationship("Skill", lazy=False)

app/repositories/__init__.py

@@ -4,4 +4,7 @@
 from .user_repo import UserRepo
 from .user_role_repo import UserRoleRepo
 from .permission_repo import PermissionRepo
-from .skills_category_repo import SkillsCategoryRepo
+from .skill_category_repo import SkillCategoryRepo
+from .skill_repo import SkillRepo
+from .user_employment_repo import UserEmploymentRepo
+from .user_employment_skill_repo import UserEmploymentSkillRepo

app/repositories/skill_category_repo.py

@@ -0,0 +1,15 @@
+from app.repositories.base_repo import BaseRepo
+from app.models.skill_category import SkillCategory
+
+
+class SkillCategoryRepo(BaseRepo):
+    def __init__(self):
+        BaseRepo.__init__(self, SkillCategory)
+
+    def new_skill_category(self, name, help_=None, is_active=True, is_deleted=False):
+        skills_category = SkillCategory(
+            name=name, help=help_, is_active=is_active, is_deleted=is_deleted
+        )
+
+        skills_category.save()
+        return skills_category

app/repositories/skill_repo.py

@@ -0,0 +1,18 @@
+from app.repositories.base_repo import BaseRepo
+from app.models.skill import Skill
+
+
+class SkillRepo(BaseRepo):
+    def __init__(self):
+        BaseRepo.__init__(self, Skill)
+
+    def new_skill(self, name, skill_category_id, is_active=True, is_deleted=False):
+        new_skill = Skill(
+            name=name,
+            skill_category_id=skill_category_id,
+            is_active=is_active,
+            is_deleted=is_deleted,
+        )
+
+        new_skill.save()
+        return new_skill