add exp company category group_count

src/backend/dao.py

@@ -29,6 +29,8 @@ def match_field(field: str) -> Column[str]:
             return Job.welfare
         case "salary":
             return Job.salary
+        case "category":
+            return Job.category
         case _:
             logging.error("Invalid field name")
             return Job.city
@@ -40,7 +42,14 @@ def get(session: Session, offset=0, limit=100) -> List[Job]:
 
 
 def group_count(session: Session, key: str) -> dict[str, int]:
-    valid_keys = ["city", "education", "salary"]
+    valid_keys = [
+        "city",
+        "education",
+        "salary",
+        "category",
+        "company_name",
+        "experience",
+    ]
     if key not in valid_keys:
         return {}
     group_by_column = match_field(key)

src/backend/models.py

@@ -19,3 +19,4 @@ class Job(Base):
     financing_stage = Column(String(128))
     company_size = Column(String(128))
     welfare = Column(String(128))
+    category = Column(String(128))

src/backend/routers.py

@@ -52,7 +52,9 @@ async def get_jobs_search(keyword: str, session: Session = Depends(get_session))
 position_cached = cache(services.get_position_analysis)
 language_cached = cache(services.get_language_analysis)
 salary_cached = cache(services.get_salary_analysis)
-
+company_cached = cache(services.get_company_analysis)
+category_cached = cache(services.get_category_analysis)
+experience_cached = cache(services.get_experience_analysis)
 
 @router.get("/analyze/{item}", response_model=dict[str, int])
 async def get_analyze(item: str, session: Session = Depends(get_session)):
@@ -67,5 +69,12 @@ async def get_analyze(item: str, session: Session = Depends(get_session)):
             return language_cached(session)
         case "salary":
             return salary_cached(session)
+        case "company_name":
+            return company_cached(session)
+        case "category":
+            return category_cached(session)
+        case "experience":
+            return experience_cached(session)
         case _:
+            print("invalid path parameters")
             return {"error": 404}

src/backend/schemas.py

@@ -17,6 +17,7 @@ class JobSchema(BaseModel):
     financing_stage: Annotated[str, StringConstraints(max_length=128)]
     company_size: Annotated[str, StringConstraints(max_length=128)]
     welfare: Annotated[str, StringConstraints(max_length=128)]
+    category: Annotated[str, StringConstraints(max_length=128)]
 
 
 class SimpleJobSchema(BaseModel):
@@ -34,3 +35,4 @@ class SimpleJobSchema(BaseModel):
     # financing_stage: Annotated[str, StringConstraints(max_length=128)]
     # company_size: Annotated[str, StringConstraints(max_length=128)]
     # welfare: Annotated[str, StringConstraints(max_length=128)]
+    category: Annotated[str, StringConstraints(max_length=128)]

src/backend/services.py

@@ -19,11 +19,15 @@ def get_count_by_list(session: Session, pattern: list[str]) -> dict[str, int]:
 
 
 def get_city_analysis(session: Session) -> dict[str, int]:
-    return dao.group_count(session, "city")
+    data = dao.group_count(session, "city")
+    data = sorted(data.items(), lambda x: x[1], reverse=True)
+    return dict(data[:20])
 
 
 def get_education_analysis(session: Session) -> dict[str, int]:
-    return dao.group_count(session, "education")
+    data = dao.group_count(session, "education")
+    data = sorted(data.items(), lambda x: x[1], reverse=True)
+    return data
 
 
 def get_position_analysis(session: Session) -> dict[str, int]:
@@ -129,5 +133,26 @@ def get_salary_analysis(session: Session):
     return {str(k) + "k": v for k, v in histogram.items()}
 
 
+def get_company_analysis(session: Session):
+    data = dao.group_count(session, "company_name")
+    data = sorted(data.items(), key=lambda it: it[1], reverse=True)
+    return dict(data[:10])
+
+
+def get_category_analysis(session: Session):
+    data = dao.group_count(session, "category")
+    data = sorted(data.items(), key=lambda it: it[1], reverse=True)
+    return dict(data[:10])
+
+
+def get_experience_analysis(session: Session):
+    data = dao.group_count(session, "experience")
+    resp = dict()
+    for k, v in data.items():
+        index = k.replace("经验", "")
+        resp[index] = v
+    return {k: v for k, v in resp.items()}
+
+
 def job_search(keyword: str, session: Session):
     return dao.search(session, keyword)