Установка разрешений для Workflow

.github/dependabot.yml

@@ -0,0 +1,6 @@
+version: 2
+updates:
+  - package-ecosystem: "cargo"
+    directory: "/"
+    schedule:
+      interval: "weekly"

.github/workflows/test.yml

@@ -0,0 +1,25 @@
+name: Tests
+
+on:
+  push:
+    branches: [ "master" ]
+  pull_request:
+    branches: [ "master" ]
+
+permissions:
+  contents: read
+
+env:
+  CARGO_TERM_COLOR: always
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+      - name: Build
+        run: cargo build --verbose
+      - name: Run tests
+        run: cargo test --verbose -p schedule_parser

.gitignore

@@ -1,3 +1,4 @@
 /target
 .~*.xls
 schedule.json
+teachers.json

Cargo.toml

@@ -3,13 +3,11 @@ members = ["lib/schedule_parser"]
 
 [package]
 name = "schedule-parser-rusted"
-version = "0.1.0"
+version = "0.2.0"
 edition = "2024"
 publish = false
 
 [dependencies]
-actix-web = "4.10.2"
 serde = { version = "1.0.219", features = ["derive"] }
-serde_repr = "0.1.20"
 serde_json = "1.0.140"
 schedule_parser = { path = "./lib/schedule_parser" }

README.md

@@ -0,0 +1,3 @@
+# API для получения расписания политехникума
+
+[![Rust](https://github.com/n08i40k/schedule-parser-rusted/actions/workflows/test.yml/badge.svg)](https://github.com/n08i40k/schedule-parser-rusted/actions/workflows/test.yml)

lib/schedule_parser/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "schedule_parser"
-version = "0.1.0"
+version = "0.2.0"
 edition = "2024"
 
 [lib]

lib/schedule_parser/src/lib/lib.rs

@@ -1,6 +1,6 @@
 use crate::LessonParseResult::{Lessons, Street};
 use crate::schema::LessonType::Break;
-use crate::schema::{Day, Group, Lesson, LessonSubGroup, LessonTime, LessonType};
+use crate::schema::{Day, Lesson, LessonSubGroup, LessonTime, LessonType, ScheduleEntity};
 use calamine::{Reader, Xls, open_workbook};
 use chrono::{Duration, NaiveDateTime};
 use fuzzy_matcher::FuzzyMatcher;
@@ -470,7 +470,80 @@ fn parse_name_and_subgroups(name: &String) -> (String, Vec<LessonSubGroup>) {
     (lesson_name, subgroups)
 }
 
-pub fn parse_xls(path: &Path) -> HashMap<String, Group> {
+fn convert_groups_to_teachers(
+    groups: &HashMap<String, ScheduleEntity>,
+) -> HashMap<String, ScheduleEntity> {
+    let mut teachers: HashMap<String, ScheduleEntity> = HashMap::new();
+
+    let empty_days: Vec<Day> = groups
+        .values()
+        .next()
+        .unwrap()
+        .days
+        .iter()
+        .map(|day| Day {
+            name: day.name.clone(),
+            street: day.street.clone(),
+            date: day.date.clone(),
+            lessons: vec![],
+        })
+        .collect();
+
+    for group in groups.values() {
+        for (index, day) in group.days.iter().enumerate() {
+            for group_lesson in &day.lessons {
+                if group_lesson.lesson_type == Break {
+                    continue;
+                }
+
+                if group_lesson.subgroups.is_none() {
+                    continue;
+                }
+
+                let subgroups = group_lesson.subgroups.as_ref().unwrap();
+
+                for subgroup in subgroups {
+                    if subgroup.teacher == "Ошибка в расписании" {
+                        continue;
+                    }
+
+                    if !teachers.contains_key(&subgroup.teacher) {
+                        teachers.insert(
+                            subgroup.teacher.clone(),
+                            ScheduleEntity {
+                                name: subgroup.teacher.clone(),
+                                days: empty_days.to_vec(),
+                            },
+                        );
+                    }
+
+                    let teacher_day = teachers
+                        .get_mut(&subgroup.teacher)
+                        .unwrap()
+                        .days
+                        .get_mut(index)
+                        .unwrap();
+
+                    teacher_day.lessons.push({
+                        let mut lesson = group_lesson.clone();
+                        lesson.group = Some(group.name.clone());
+
+                        lesson
+                    });
+                }
+            }
+        }
+    }
+
+    teachers
+}
+
+pub fn parse_xls(
+    path: &Path,
+) -> (
+    HashMap<String, ScheduleEntity>,
+    HashMap<String, ScheduleEntity>,
+) {
     let mut workbook: Xls<_> = open_workbook(path).expect("Can't open workbook");
 
     let worksheet: WorkSheet = workbook
@@ -482,13 +555,13 @@ pub fn parse_xls(path: &Path) -> HashMap<String, Group> {
 
     let (days_markup, groups_markup) = parse_skeleton(&worksheet);
 
-    let mut groups: HashMap<String, Group> = HashMap::new();
+    let mut groups: HashMap<String, ScheduleEntity> = HashMap::new();
     let mut days_times: Vec<Vec<InternalTime>> = Vec::new();
 
     let saturday_end_row = worksheet.end().unwrap().0;
 
     for group_markup in groups_markup {
-        let mut group = Group {
+        let mut group = ScheduleEntity {
             name: group_markup.name,
             days: Vec::new(),
         };
@@ -612,7 +685,7 @@ pub fn parse_xls(path: &Path) -> HashMap<String, Group> {
         groups.insert(group.name.clone(), group);
     }
 
-    groups
+    (convert_groups_to_teachers(&groups), groups)
 }
 
 #[cfg(test)]
@@ -622,6 +695,8 @@ mod tests {
     #[test]
     fn it_works() {
         let result = parse_xls(Path::new("../../schedule.xls"));
-        assert_ne!(result.len(), 0);
+        
+        assert_ne!(result.0.len(), 0);
+        assert_ne!(result.1.len(), 0);
     }
 }

lib/schedule_parser/src/lib/schema.rs

@@ -1,9 +1,9 @@
 use chrono::{DateTime, Utc};
 use serde::{Deserialize, Serialize};
-use std::collections::HashMap;
 use serde_repr::{Deserialize_repr, Serialize_repr};
+use std::collections::HashMap;
 
-#[derive(Serialize, Deserialize, Debug)]
+#[derive(Serialize, Deserialize, Debug, Clone)]
 pub struct LessonTime {
     pub start: DateTime<Utc>,
     pub end: DateTime<Utc>,
@@ -22,7 +22,7 @@ pub enum LessonType {
     ExamDefault,     // Экзамен
 }
 
-#[derive(Serialize, Deserialize, Debug)]
+#[derive(Serialize, Deserialize, Debug, Clone)]
 pub struct LessonSubGroup {
     pub number: u8,
 
@@ -31,7 +31,7 @@ pub struct LessonSubGroup {
     pub teacher: String,
 }
 
-#[derive(Serialize, Deserialize, Debug)]
+#[derive(Serialize, Deserialize, Debug, Clone)]
 pub struct Lesson {
     /**
      * Тип занятия
@@ -67,7 +67,7 @@ pub struct Lesson {
     pub group: Option<String>,
 }
 
-#[derive(Serialize, Deserialize, Debug)]
+#[derive(Serialize, Deserialize, Debug, Clone)]
 pub struct Day {
     pub name: String,
 
@@ -79,7 +79,7 @@ pub struct Day {
 }
 
 #[derive(Serialize, Deserialize, Debug)]
-pub struct Group {
+pub struct ScheduleEntity {
     pub name: String,
 
     pub days: Vec<Day>,
@@ -90,8 +90,18 @@ pub struct Schedule {
     #[serde(rename = "updatedAt")]
     pub updated_at: DateTime<Utc>,
 
-    pub groups: HashMap<String, Group>,
+    pub groups: HashMap<String, ScheduleEntity>,
 
     #[serde(rename = "updatedGroups")]
     pub updated_groups: Vec<Vec<usize>>,
 }
+
+#[derive(Serialize, Deserialize, Debug)]
+pub struct TeacherSchedule {
+    #[serde(rename = "updatedAt")]
+    pub updated_at: DateTime<Utc>,
+
+    pub teacher: ScheduleEntity,
+
+    pub updated: Vec<usize>,
+}

src/main.rs

@@ -3,13 +3,21 @@ use std::path::Path;
 use schedule_parser::parse_xls;
 
 fn main() {
-    let groups = parse_xls(Path::new("./schedule.xls"));
+    let (teachers, groups) = parse_xls(Path::new("./schedule.xls"));
 
     fs::write(
         "./schedule.json",
         serde_json::to_string_pretty(&groups)
-            .expect("Failed to serialize schedule!")
+            .expect("Failed to serialize schedule")
             .as_bytes(),
     )
     .expect("Failed to write schedule");
+    
+    fs::write(
+        "./teachers.json",
+        serde_json::to_string_pretty(&teachers)
+            .expect("Failed to serialize teachers schedule")
+            .as_bytes(),
+    )
+    .expect("Failed to write teachers schedule");
 }