Merge branch 'master' of http://git.fmode.cn:3000/18079408532/lifepartner

package-lock.json

@@ -10,12 +10,12 @@
       "dependencies": {
         "@angular/animations": "^18.0.0",
         "@angular/cdk": "^17.0.0",
-        "@angular/common": "^18.0.0",
+        "@angular/common": "^18.2.13",
         "@angular/compiler": "^18.0.0",
-        "@angular/core": "^18.0.0",
+        "@angular/core": "^18.2.13",
         "@angular/forms": "^18.2.13",
         "@angular/material": "^17.0.0",
-        "@angular/platform-browser": "^18.0.0",
+        "@angular/platform-browser": "^18.2.13",
         "@angular/platform-browser-dynamic": "^18.0.0",
         "@angular/router": "^18.0.0",
         "@capacitor/app": "6.0.2",

package.json

@@ -15,12 +15,12 @@
   "dependencies": {
     "@angular/animations": "^18.0.0",
     "@angular/cdk": "^17.0.0",
-    "@angular/common": "^18.0.0",
+    "@angular/common": "^18.2.13",
     "@angular/compiler": "^18.0.0",
-    "@angular/core": "^18.0.0",
+    "@angular/core": "^18.2.13",
     "@angular/forms": "^18.2.13",
     "@angular/material": "^17.0.0",
-    "@angular/platform-browser": "^18.0.0",
+    "@angular/platform-browser": "^18.2.13",
     "@angular/platform-browser-dynamic": "^18.0.0",
     "@angular/router": "^18.0.0",
     "@capacitor/app": "6.0.2",

src/app/app.component.ts

@@ -13,7 +13,17 @@ import * as Parse from 'parse';
 export class AppComponent {
   constructor() {
     addIcons({ trash, add });
-    Parse.initialize('YOUR_APP_ID', 'YOUR_JS_KEY', undefined);
+    Parse.initialize('dev');
     (Parse as any).serverURL = 'http://dev.fmode.cn:1337/parse';
+    
+    // 恢复用户会话
+    const storedUser = localStorage.getItem('NCloud/dev/User');
+    if (storedUser) {
+      const userData = JSON.parse(storedUser);
+      Parse.User.become(userData.sessionToken).catch(error => {
+        console.error('Session token 已过期:', error);
+        localStorage.removeItem('NCloud/dev/User');
+      });
+    }
   }
-}
+}

src/app/app.routes.ts

@@ -4,5 +4,9 @@ export const routes: Routes = [
   {
     path: '',
     loadChildren: () => import('./tabs/tabs.routes').then((m) => m.routes),
+  },
+  {
+    path: 'countdown',
+    loadComponent: () => import('./countdown/countdown.page').then(m => m.CountdownPage)
   }
-];
+];

src/app/components/task-modal/task-modal.component.ts

@@ -1,16 +1,21 @@
 import { Component } from '@angular/core';
 import { CommonModule } from '@angular/common';
-import { IonicModule, ModalController } from '@ionic/angular';
 import { FormsModule } from '@angular/forms';
+import { IonHeader, IonToolbar, IonTitle, IonButtons, IonButton, IonContent, 
+         IonItem, IonLabel, IonInput, IonTextarea, IonDatetimeButton, 
+         IonModal, IonDatetime } from '@ionic/angular/standalone';
+import { ModalController, AlertController } from '@ionic/angular/standalone';
+import { Task } from '../../../lib/models/Task';
 
 @Component({
   selector: 'app-task-modal',
   template: `
     <ion-header>
       <ion-toolbar>
-        <ion-title>新建任务</ion-title>
+        <ion-title>{{ task.id ? '编辑任务' : '新建任务' }}</ion-title>
         <ion-buttons slot="end">
           <ion-button (click)="dismiss()">取消</ion-button>
+          <ion-button (click)="confirm()" [strong]="true">确定</ion-button>
         </ion-buttons>
       </ion-toolbar>
     </ion-header>
@@ -18,7 +23,12 @@ import { FormsModule } from '@angular/forms';
     <ion-content class="ion-padding">
       <ion-item>
         <ion-label position="stacked">标题</ion-label>
-        <ion-input [(ngModel)]="task.title"></ion-input>
+        <ion-input [(ngModel)]="task.title" placeholder="请输入任务标题"></ion-input>
+      </ion-item>
+
+      <ion-item>
+        <ion-label position="stacked">内容</ion-label>
+        <ion-textarea [(ngModel)]="task.content" placeholder="请输入任务内容" rows="3"></ion-textarea>
       </ion-item>
 
       <ion-item>
@@ -26,32 +36,91 @@ import { FormsModule } from '@angular/forms';
         <ion-datetime-button datetime="startTime"></ion-datetime-button>
         <ion-modal [keepContentsMounted]="true">
           <ng-template>
-            <ion-datetime id="startTime" [(ngModel)]="task.startTime"></ion-datetime>
+            <ion-datetime 
+              id="startTime"
+              presentation="date-time"
+              [preferWheel]="true"
+              [(ngModel)]="task.startTime"
+              locale="zh-CN">
+            </ion-datetime>
           </ng-template>
         </ion-modal>
       </ion-item>
 
-      <ion-button expand="block" (click)="confirm()" class="ion-margin-top">
-        创建任务
-      </ion-button>
+      <ion-item>
+        <ion-label position="stacked">结束时间</ion-label>
+        <ion-datetime-button datetime="endTime"></ion-datetime-button>
+        <ion-modal [keepContentsMounted]="true">
+          <ng-template>
+            <ion-datetime 
+              id="endTime"
+              presentation="date-time"
+              [preferWheel]="true"
+              [(ngModel)]="task.endTime"
+              locale="zh-CN">
+            </ion-datetime>
+          </ng-template>
+        </ion-modal>
+      </ion-item>
     </ion-content>
   `,
   standalone: true,
-  imports: [IonicModule, CommonModule, FormsModule]
+  imports: [
+    CommonModule,
+    FormsModule,
+    IonHeader,
+    IonToolbar,
+    IonTitle,
+    IonButtons,
+    IonButton,
+    IonContent,
+    IonItem,
+    IonLabel,
+    IonInput,
+    IonTextarea,
+    IonDatetimeButton,
+    IonModal,
+    IonDatetime
+  ]
 })
 export class TaskModalComponent {
-  task = {
-    title: '',
-    startTime: new Date().toISOString()
-  };
+  task: Task;
 
-  constructor(private modalCtrl: ModalController) {}
+  constructor(
+    private modalCtrl: ModalController,
+    private alertController: AlertController
+  ) {
+    this.task = new Task();
+  }
 
   dismiss() {
     this.modalCtrl.dismiss(null, 'cancel');
   }
 
-  confirm() {
+  async confirm() {
+    if (!this.task.title) {
+      await this.showAlert('提示', '请输入任务标题');
+      return;
+    }
+
+    if (this.task.startTime && this.task.endTime) {
+      const startTime = new Date(this.task.startTime);
+      const endTime = new Date(this.task.endTime);
+      if (endTime < startTime) {
+        await this.showAlert('提示', '结束时间不能早于开始时间');
+        return;
+      }
+    }
+
     this.modalCtrl.dismiss(this.task, 'confirm');
   }
-} 
+
+  private async showAlert(header: string, message: string) {
+    const alert = await this.alertController.create({
+      header,
+      message,
+      buttons: ['确定']
+    });
+    await alert.present();
+  }
+}

src/app/countdown/countdown.page.html

@@ -1,44 +1,30 @@
-<ion-header>
+<ion-header class="ion-no-border">
   <ion-toolbar>
     <ion-buttons slot="start">
       <ion-button (click)="exit()">
-        <ion-icon name="arrow-back-outline" slot="icon-only"></ion-icon>
+        <ion-icon name="arrow-back" size="large"></ion-icon>
       </ion-button>
     </ion-buttons>
-    <ion-title>专注计时</ion-title>
+    <ion-title color="light">专注倒计时</ion-title>
   </ion-toolbar>
 </ion-header>
 
-<ion-content class="ion-text-center">
+<ion-content class="ion-padding">
   <div class="countdown-container">
-    <div class="activity-info">
-      <ion-icon [name]="activityType"></ion-icon>
-      <h2>{{ activityName }}</h2>
+    <ion-icon [name]="activityType" class="activity-icon"></ion-icon>
+    <h2>{{ activityName }}</h2>
+    
+    <div class="timer">
+      <h1>{{ remainingTime }}</h1>
+      <ion-progress-bar [value]="progress"></ion-progress-bar>
     </div>
 
-    <div class="timer-circle">
-      <div class="progress-ring">
-        <ion-progress-bar [value]="progress"></ion-progress-bar>
-      </div>
-      <div class="time">{{ remainingTime }}</div>
-    </div>
-
-    <div class="controls">
-      <ion-button 
-        fill="clear" 
-        [class.running]="isRunning"
-        (click)="togglePause()">
-        <ion-icon 
-          [name]="isRunning ? 'pause-outline' : 'play-outline'" 
-          slot="icon-only">
-        </ion-icon>
+    <div class="control-buttons">
+      <ion-button (click)="togglePause()" fill="clear">
+        <ion-icon [name]="isRunning ? 'pause' : 'play'" size="large"></ion-icon>
       </ion-button>
-      
-      <ion-button 
-        fill="clear" 
-        (click)="reset()"
-        [disabled]="!isRunning && remainingSeconds === duration * 60">
-        <ion-icon name="stop-outline" slot="icon-only"></ion-icon>
+      <ion-button (click)="reset()" fill="clear">
+        <ion-icon name="stop" size="large"></ion-icon>
       </ion-button>
     </div>
   </div>

src/app/countdown/countdown.page.scss

@@ -1,84 +1,145 @@
+ion-content {
+  --background: linear-gradient(135deg, var(--ion-color-primary) 0%, var(--ion-color-secondary) 100%);
+}
+
+ion-header {
+  position: absolute;
+  
+  ion-toolbar {
+    --background: transparent;
+    --border-style: none;
+    --border-color: transparent;
+    --border-width: 0;
+    --padding-top: 20px;
+    
+    ion-title, ion-button, ion-icon {
+      color: white;
+    }
+    
+    ion-buttons {
+      margin-inline-start: 8px;
+    }
+    
+    ion-button::part(native) {
+      padding: 0;
+    }
+    
+    ion-icon {
+      font-size: 24px;
+      font-weight: bold;
+    }
+  }
+}
+
 .countdown-container {
-  height: 100%;
   display: flex;
   flex-direction: column;
-  justify-content: center;
   align-items: center;
-  padding: 20px;
-  background: var(--ion-background-color);
-}
-
-.activity-info {
-  margin-bottom: 40px;
+  justify-content: center;
+  height: 100%;
   text-align: center;
-  
-  ion-icon {
+  color: white;
+
+  .activity-icon {
     font-size: 64px;
-    color: var(--ion-color-primary);
+    margin-bottom: 24px;
+    padding: 20px;
+    border-radius: 50%;
+    background: rgba(255, 255, 255, 0.1);
+    backdrop-filter: blur(10px);
   }
-  
+
   h2 {
-    margin: 16px 0;
-    font-size: 28px;
-    color: var(--ion-text-color);
+    font-size: 24px;
     font-weight: 500;
+    margin-bottom: 40px;
+    text-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
   }
-}
 
-.timer-circle {
-  position: relative;
-  width: 300px;
-  height: 300px;
-  display: flex;
-  justify-content: center;
-  align-items: center;
-  margin-bottom: 40px;
-  
-  .progress-ring {
-    position: absolute;
-    width: 100%;
-    height: 100%;
-    border-radius: 50%;
-    overflow: hidden;
+  .timer {
+    background: rgba(255, 255, 255, 0.1);
+    backdrop-filter: blur(10px);
+    border-radius: 20px;
+    padding: 32px;
+    margin: 32px 0;
+    width: 80%;
+    max-width: 300px;
+    box-shadow: 0 8px 32px rgba(0, 0, 0, 0.1);
     
-    ion-progress-bar {
-      position: absolute;
-      bottom: 0;
-      width: 100%;
-      height: 100%;
-      --progress-background: var(--ion-color-primary);
-      --buffer-background: rgba(var(--ion-color-primary-rgb), 0.2);
-      transform-origin: center;
-      transform: rotate(270deg);
+    h1 {
+      font-size: 72px;
+      font-weight: bold;
+      margin-bottom: 24px;
+      font-family: 'SF Mono', 'Courier New', monospace;
+      text-shadow: 0 2px 4px rgba(0, 0, 0, 0.2);
     }
   }
-  
-  .time {
-    font-size: 56px;
-    font-weight: 300;
-    color: var(--ion-text-color);
-    z-index: 1;
+
+  .control-buttons {
+    display: flex;
+    gap: 24px;
+    margin-top: 40px;
+
+    ion-button {
+      --background: rgba(255, 255, 255, 0.1);
+      --background-hover: rgba(255, 255, 255, 0.2);
+      --background-activated: rgba(255, 255, 255, 0.15);
+      --border-radius: 50%;
+      --padding-start: 0;
+      --padding-end: 0;
+      width: 64px;
+      height: 64px;
+      margin: 0;
+
+      ion-icon {
+        font-size: 28px;
+        color: white;
+      }
+
+      &::part(native) {
+        border-radius: 50%;
+      }
+    }
   }
 }
 
-.controls {
-  display: flex;
-  gap: 20px;
-  margin-top: 20px;
+ion-progress-bar {
+  height: 8px;
+  border-radius: 4px;
+  --buffer-background: rgba(255, 255, 255, 0.2);
+  --progress-background: rgba(255, 255, 255, 0.8);
+  overflow: hidden;
+}
 
-  ion-button {
-    --padding-start: 20px;
-    --padding-end: 20px;
-    --border-radius: 50%;
-    width: 64px;
-    height: 64px;
-    
-    ion-icon {
-      font-size: 32px;
+@keyframes pulse {
+  0% {
+    transform: scale(1);
+  }
+  50% {
+    transform: scale(1.05);
+  }
+  100% {
+    transform: scale(1);
+  }
+}
+
+.timer h1 {
+  animation: pulse 2s infinite ease-in-out;
+}
+
+@media (max-width: 360px) {
+  .countdown-container {
+    .activity-icon {
+      font-size: 48px;
     }
 
-    &.running {
-      --background: var(--ion-color-danger);
+    .timer h1 {
+      font-size: 56px;
+    }
+
+    .control-buttons ion-button {
+      width: 56px;
+      height: 56px;
     }
   }
-}
+}

src/app/countdown/countdown.page.ts

@@ -1,27 +1,18 @@
 import { Component, OnInit, OnDestroy } from '@angular/core';
 import { CommonModule } from '@angular/common';
 import { FormsModule } from '@angular/forms';
-import { IonicModule, NavController, AlertController } from '@ionic/angular';
-import { ActivatedRoute } from '@angular/router';
+import { IonicModule } from '@ionic/angular';
+import { AlertController } from '@ionic/angular';
 import { addIcons } from 'ionicons';
 import { 
-  schoolOutline, 
-  briefcaseOutline, 
-  moonOutline,
-  barbellOutline,
-  bookOutline,
-  codeSlashOutline,
-  leafOutline,
-  musicalNotesOutline,
-  languageOutline,
-  pencilOutline,
-  pauseOutline,
-  playOutline,
-  stopOutline,
-  exitOutline,
-  arrowBackOutline
+  arrowBack,
+  pause, 
+  play,
+  stop
 } from 'ionicons/icons';
-import { FocusRecordService } from '../services/ncloud';
+import { ActivatedRoute } from '@angular/router';
+import { Location } from '@angular/common';
+import { FocusDataService } from '../services/focus-data.service';
 
 @Component({
   selector: 'app-countdown',
@@ -31,166 +22,176 @@ import { FocusRecordService } from '../services/ncloud';
   imports: [IonicModule, CommonModule, FormsModule]
 })
 export class CountdownPage implements OnInit, OnDestroy {
-  remainingTime: string = '';
-  activityType: string = '';
   activityName: string = '';
-  duration: number = 0;
-  timer: any;
-  isRunning: boolean = false;
-  progress: number = 1;
+  activityType: string = '';
+  progress: number = 0;
+  remainingTime: string = '';
   remainingSeconds: number = 0;
-  alertAudio: HTMLAudioElement;
+  isRunning: boolean = false;
+  duration: number = 25;
+  timer: any;
+  startTime: Date | null = null;
+  category: string = '';
+  private audio: HTMLAudioElement;
 
   constructor(
-    private route: ActivatedRoute, 
-    private navCtrl: NavController,
-    private alertController: AlertController
+    private alertController: AlertController,
+    private route: ActivatedRoute,
+    private location: Location,
+    private focusDataService: FocusDataService
   ) {
-    addIcons({
-      'school-outline': schoolOutline,
-      'briefcase-outline': briefcaseOutline,
-      'moon-outline': moonOutline,
-      'barbell-outline': barbellOutline,
-      'book-outline': bookOutline,
-      'code-slash-outline': codeSlashOutline,
-      'leaf-outline': leafOutline,
-      'musical-notes-outline': musicalNotesOutline,
-      'language-outline': languageOutline,
-      'pencil-outline': pencilOutline,
-      'pause-outline': pauseOutline,
-      'play-outline': playOutline,
-      'stop-outline': stopOutline,
-      'exit-outline': exitOutline,
-      'arrow-back-outline': arrowBackOutline
+    addIcons({ 
+      arrowBack,
+      pause, 
+      play,
+      stop
     });
-
-    this.alertAudio = new Audio('assets/alert.mp3');
+    this.audio = new Audio('assets/alert.mp3');
   }
 
   ngOnInit() {
-    console.log('CountdownPage initialized');
     this.route.queryParams.subscribe(params => {
-      console.log('Received params:', params);
-      this.activityType = params['type'];
-      this.activityName = params['name'];
-      this.duration = parseInt(params['duration']);
+      this.activityType = params['type'] || '';
+      this.activityName = params['name'] || '';
+      this.duration = parseInt(params['duration']) || 25;
+      this.category = params['category'] || '';
       this.remainingSeconds = this.duration * 60;
-      this.remainingTime = this.formatTime(this.remainingSeconds);
-      this.progress = 1;
+      this.updateRemainingTime();
+      this.startTimer();
     });
   }
 
   ngOnDestroy() {
-    this.stopTimer();
-  }
-
-  startTimer() {
-    if (this.timer) {
-      clearInterval(this.timer);
-    }
-
-    const startTime = this.duration * 60;
-    this.isRunning = true;
-    
-    this.timer = setInterval(() => {
-      if (this.remainingSeconds > 0) {
-        this.remainingSeconds--;
-        this.progress = this.remainingSeconds / startTime;
-        this.remainingTime = this.formatTime(this.remainingSeconds);
-      } else {
-        this.stopTimer();
-        this.playAlertSound();
-        this.showCompletionAlert();
-      }
-    }, 1000);
-  }
-
-  stopTimer() {
     if (this.timer) {
       clearInterval(this.timer);
-      this.timer = null;
     }
-    this.isRunning = false;
   }
 
-  formatTime(seconds: number): string {
-    const hours = Math.floor(seconds / 3600);
-    const minutes = Math.floor((seconds % 3600) / 60);
-    const secs = seconds % 60;
-    return `${this.padNumber(hours)}:${this.padNumber(minutes)}:${this.padNumber(secs)}`;
+  private updateRemainingTime() {
+    const minutes = Math.floor(this.remainingSeconds / 60);
+    const seconds = this.remainingSeconds % 60;
+    this.remainingTime = `${minutes.toString().padStart(2, '0')}:${seconds.toString().padStart(2, '0')}`;
+    this.progress = 1 - (this.remainingSeconds / (this.duration * 60));
   }
 
-  padNumber(num: number): string {
-    return num.toString().padStart(2, '0');
-  }
-
-  togglePause() {
-    if (this.isRunning) {
-      this.stopTimer();
-    } else {
-      this.startTimer();
+  startTimer() {
+    if (!this.isRunning) {
+      this.isRunning = true;
+      if (!this.startTime) {
+        this.startTime = new Date();
+      }
+      this.timer = setInterval(() => {
+        if (this.remainingSeconds > 0) {
+          this.remainingSeconds--;
+          this.updateRemainingTime();
+        } else {
+          this.completeCountdown();
+        }
+      }, 1000);
     }
   }
 
-  reset() {
-    this.stopTimer();
-    this.remainingSeconds = this.duration * 60;
-    this.remainingTime = this.formatTime(this.remainingSeconds);
-    this.progress = 1;
-  }
-
   async exit() {
     if (this.isRunning) {
       const alert = await this.alertController.create({
         header: '确认退出',
-        message: '计时正在进行中，确定要退出吗？',
+        message: '正在进行专注计时，确定要退出吗？',
         buttons: [
           {
             text: '取消',
             role: 'cancel'
           },
           {
-            text: '确定',
+            text: '退出',
             handler: () => {
-              this.stopTimer();
-              this.navCtrl.back();
+              this.saveAndExit();
             }
           }
         ]
       });
       await alert.present();
     } else {
-      this.navCtrl.back();
+      this.location.back();
+    }
+  }
+
+  togglePause() {
+    if (this.isRunning) {
+      clearInterval(this.timer);
+      this.isRunning = false;
+    } else {
+      this.startTimer();
     }
   }
 
-  async showCompletionAlert() {
+  async reset() {
     const alert = await this.alertController.create({
-      header: '专注完成！',
-      message: `恭喜你完成了 ${this.duration} 分钟的${this.activityName}`,
-      buttons: ['确定']
+      header: '确认重置',
+      message: '确定要重置计时器吗？',
+      buttons: [
+        {
+          text: '取消',
+          role: 'cancel'
+        },
+        {
+          text: '重置',
+          handler: () => {
+            clearInterval(this.timer);
+            this.remainingSeconds = this.duration * 60;
+            this.updateRemainingTime();
+            this.isRunning = false;
+            this.startTime = null;
+          }
+        }
+      ]
     });
     await alert.present();
   }
 
-  private playAlertSound() {
-    this.alertAudio.play().catch(error => {
-      console.error('Error playing alert sound:', error);
+  private async completeCountdown() {
+    clearInterval(this.timer);
+    this.isRunning = false;
+    await this.saveRecord();
+    
+    try {
+      await this.audio.play();
+    } catch (error) {
+      console.error('播放提示音失败:', error);
+    }
+    
+    const alert = await this.alertController.create({
+      header: '专注完成',
+      message: '太棒了！你完成了这次专注。',
+      buttons: [{
+        text: '确定',
+        handler: () => {
+          this.location.back();
+        }
+      }]
     });
+    await alert.present();
   }
 
-  async completeTimer() {
+  private async saveAndExit() {
+    if (this.startTime) {
+      await this.saveRecord();
+    }
+    this.location.back();
+  }
+
+  private async saveRecord() {
+    if (!this.startTime) return;
+    
+    const endTime = new Date();
+    const duration = Math.floor((endTime.getTime() - this.startTime.getTime()) / 60000);
+    
     try {
-      await FocusRecordService.createRecord({
-        duration: this.duration,
-        category: this.activityType,
-        startTime: new Date(Date.now() - this.duration * 60 * 1000),
-        endTime: new Date(),
-        completed: true
+      await this.focusDataService.addFocusRecord({
+        duration: duration,
+        category: this.category,
+        startTime: this.startTime,
+        endTime: endTime
       });
-      
-      await this.showCompletionAlert();
-      this.playAlertSound();
     } catch (error) {
       console.error('保存专注记录失败:', error);
     }

src/app/models/Task.ts

@@ -1,4 +1,4 @@
-import { CloudObject, CloudQuery } from '../../lib/ncloud';
+import { CloudObject } from '../../lib/ncloud';
 import * as Parse from 'parse';
 
 export class Task extends CloudObject {
@@ -16,6 +16,53 @@ export class Task extends CloudObject {
     this.parseObject = new Parse.Object('Task');
   }
 
+  // 创建新任务
+  static async create(data: any): Promise<Task> {
+    try {
+      const currentUser = Parse.User.current();
+      if (!currentUser) {
+        throw new Error('No user logged in');
+      }
+
+      const task = new Task();
+      
+      // 设置ACL
+      const acl = new Parse.ACL();
+      acl.setPublicReadAccess(false);
+      acl.setPublicWriteAccess(false);
+      acl.setReadAccess(currentUser.id, true);
+      acl.setWriteAccess(currentUser.id, true);
+      task.parseObject.setACL(acl);
+
+      // 设置任务数据
+      task.parseObject.set('title', data.title);
+      task.parseObject.set('content', data.content || '');
+      task.parseObject.set('startTime', data.startTime || new Date().toISOString());
+      task.parseObject.set('endTime', data.endTime || new Date().toISOString());
+      task.parseObject.set('completed', data.completed || false);
+      task.parseObject.set('userId', currentUser.id);
+      task.parseObject.set('user', currentUser);
+
+      // 保存到数据库
+      await task.parseObject.save();
+      
+      // 设置本地数据
+      task.id = task.parseObject.id;
+      task.title = data.title;
+      task.content = data.content || '';
+      task.startTime = data.startTime || new Date().toISOString();
+      task.endTime = data.endTime || new Date().toISOString();
+      task.completed = data.completed || false;
+      task.userId = currentUser.id;
+
+      return task;
+    } catch (error) {
+      console.error('Failed to create task:', error);
+      throw error;
+    }
+  }
+
+  // 获取用户的所有任务
   static async getUserTasks(userId: string): Promise<Task[]> {
     try {
       if (!userId) {
@@ -24,12 +71,20 @@ export class Task extends CloudObject {
       
       const query = new Parse.Query('Task');
       query.equalTo('userId', userId);
+      query.descending('createdAt');
       
       const results = await query.find();
       return results.map(result => {
         const task = new Task();
         task.parseObject = result;
-        Object.assign(task, result.toJSON());
+        task.id = result.id;
+        const data = result.toJSON();
+        task.title = data['title'];
+        task.content = data['content'];
+        task.startTime = data['startTime'];
+        task.endTime = data['endTime'];
+        task.completed = data['completed'];
+        task.userId = data['userId'];
         return task;
       });
     } catch (error) {
@@ -38,53 +93,52 @@ export class Task extends CloudObject {
     }
   }
 
-  static async create(data: Partial<Task>): Promise<Task> {
+  // 保存任务更新
+  async saveTask(): Promise<void> {
     try {
-      const task = new Task();
-      
-      // 处理日期
-      if (typeof data.startTime === 'string') {
-        data.startTime = new Date(data.startTime).toISOString();
-      }
-      if (typeof data.endTime === 'string') {
-        data.endTime = new Date(data.endTime).toISOString();
+      if (!this.id) {
+        throw new Error('Task ID is required for update');
       }
 
-      // 设置数据到 parseObject
-      Object.keys(data).forEach(key => {
-        task.parseObject.set(key, (data as any)[key]);
-      });
-
-      // 保存到数据库
-      await task.parseObject.save();
-      
-      // 设置本地数据
-      Object.assign(task, data);
-      task.id = task.parseObject.id;
+      // 更新所有属性到 parseObject
+      this.parseObject.set('title', this.title);
+      this.parseObject.set('content', this.content);
+      this.parseObject.set('startTime', this.startTime);
+      this.parseObject.set('endTime', this.endTime);
+      this.parseObject.set('completed', this.completed);
       
-      console.log('Task created:', task);  // 添加日志
-      return task;
+      await this.parseObject.save();
     } catch (error) {
-      console.error('Failed to create task:', error);
+      console.error('Failed to save task:', error);
       throw error;
     }
   }
 
+  // 删除任务
   async delete(): Promise<void> {
     try {
+      if (!this.id) {
+        throw new Error('Task ID is required for deletion');
+      }
       await this.parseObject.destroy();
     } catch (error) {
-      console.error('Delete failed:', error);
+      console.error('Failed to delete task:', error);
       throw error;
     }
   }
 
-  async saveTask(): Promise<void> {
-    try {
-      await this.parseObject.save();
-    } catch (error) {
-      console.error('保存任务失败:', error);
-      throw error;
-    }
+  // 从 Parse.Object 创建 Task 实例
+  static fromParseObject(parseObject: Parse.Object): Task {
+    const task = new Task();
+    task.parseObject = parseObject;
+    task.id = parseObject.id;
+    const data = parseObject.toJSON();
+    task.title = data['title'];
+    task.content = data['content'];
+    task.startTime = data['startTime'];
+    task.endTime = data['endTime'];
+    task.completed = data['completed'];
+    task.userId = data['userId'];
+    return task;
   }
-} 
+}

src/app/services/auth.service.ts

@@ -1,30 +1,46 @@
 import { Injectable } from '@angular/core';
 import * as Parse from 'parse';
-import { CloudUser } from '../../lib/ncloud';
+import { BehaviorSubject } from 'rxjs';
 
 @Injectable({
   providedIn: 'root'
 })
 export class AuthService {
-  currentUser: CloudUser | null = null;
+  private currentUserSubject = new BehaviorSubject<Parse.User | null>(null);
+  currentUser$ = this.currentUserSubject.asObservable();
 
   constructor() {
-    this.checkAuthState();
+    this.checkCurrentUser();
   }
 
-  async checkAuthState() {
-    const parseUser = Parse.User.current();
-    if (parseUser) {
-      this.currentUser = parseUser as unknown as CloudUser;
-    }
-    return this.currentUser;
+  private checkCurrentUser() {
+    const currentUser = Parse.User.current() as Parse.User | null;
+    this.currentUserSubject.next(currentUser);
   }
 
-  setCurrentUser(user: CloudUser | null) {
-    this.currentUser = user;
+  async login(username: string, password: string): Promise<Parse.User> {
+    const user = await Parse.User.logIn(username, password);
+    this.currentUserSubject.next(user);
+    return user;
+  }
+
+  async register(username: string, password: string, email: string): Promise<Parse.User> {
+    const user = new Parse.User();
+    user.set('username', username);
+    user.set('password', password);
+    user.set('email', email);
+    
+    await user.signUp();
+    this.currentUserSubject.next(user);
+    return user;
+  }
+
+  async logout() {
+    await Parse.User.logOut();
+    this.currentUserSubject.next(null);
   }
 
   isLoggedIn(): boolean {
     return Parse.User.current() !== null;
   }
-} 
+}

src/app/services/config.service.ts

@@ -0,0 +1,32 @@
+import { Injectable } from '@angular/core';
+import * as Parse from 'parse';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class ConfigService {
+  private static initialized = false;
+
+  constructor() {
+    this.initializeParse();
+  }
+
+  private initializeParse() {
+    if (!ConfigService.initialized) {
+      Parse.initialize('dev');
+      (Parse as any).serverURL = 'http://dev.fmode.cn:1337/parse';
+      
+      // 简化的错误处理
+      Parse.CoreManager.set('REQUEST_ATTEMPT_LIMIT', 1);
+      
+      ConfigService.initialized = true;
+    }
+  }
+
+  public getApiConfig() {
+    return {
+      serverUrl: Parse.serverURL,
+      appId: 'dev'
+    };
+  }
+} 

src/app/services/focus-data.service.ts

@@ -1,16 +1,82 @@
 import { Injectable } from '@angular/core';
+import * as Parse from 'parse';
 
 @Injectable({
   providedIn: 'root'
 })
 export class FocusDataService {
-  private focusRecords: { date: string, duration: number }[] = [];
+  async addFocusRecord(data: {
+    duration: number;
+    category: string;
+    startTime: Date;
+    endTime: Date;
+  }) {
+    try {
+      const FocusRecord = Parse.Object.extend('FocusRecord');
+      const record = new FocusRecord();
+      
+      record.set('duration', data.duration);
+      record.set('category', data.category);
+      record.set('startTime', data.startTime);
+      record.set('endTime', data.endTime);
+      record.set('completed', true);
+      record.set('userId', Parse.User.current()?.id);
 
-  addFocusRecord(date: string, duration: number) {
-    this.focusRecords.push({ date, duration });
+      await record.save();
+      return record;
+    } catch (error) {
+      console.error('保存专注记录失败:', error);
+      throw error;
+    }
   }
 
-  getFocusRecords() {
-    return this.focusRecords;
+  async getFocusRecords() {
+    try {
+      const query = new Parse.Query('FocusRecord');
+      query.equalTo('userId', Parse.User.current()?.id);
+      query.descending('createdAt');
+      query.limit(30); // 获取最近30天的记录
+      
+      const results = await query.find();
+      return results.map(record => ({
+        id: record.id,
+        date: record.get('startTime'),
+        duration: record.get('duration'),
+        category: record.get('category')
+      }));
+    } catch (error) {
+      console.error('获取专注记录失败:', error);
+      return [];
+    }
   }
-} 
+
+  async getWeeklyStats() {
+    try {
+      const query = new Parse.Query('FocusRecord');
+      query.equalTo('userId', Parse.User.current()?.id);
+      query.greaterThan('startTime', new Date(Date.now() - 7 * 24 * 60 * 60 * 1000));
+      query.ascending('startTime');
+      
+      const results = await query.find();
+      return results.map(record => ({
+        date: record.get('startTime'),
+        duration: record.get('duration'),
+        category: record.get('category')
+      }));
+    } catch (error) {
+      console.error('获取周统计失败:', error);
+      return [];
+    }
+  }
+
+  async deleteFocusRecord(recordId: string) {
+    try {
+      const query = new Parse.Query('FocusRecord');
+      const record = await query.get(recordId);
+      await record.destroy();
+    } catch (error) {
+      console.error('删除专注记录失败:', error);
+      throw error;
+    }
+  }
+}

src/app/services/ncloud.ts

@@ -1,52 +1,5 @@
 import * as Parse from 'parse';
-
-export class CloudObject {
-  protected parseObject: Parse.Object;
-
-  constructor() {
-    this.parseObject = new Parse.Object(this.constructor.name);
-  }
-
-  async save(): Promise<void> {
-    try {
-      await this.parseObject.save(this);
-    } catch (error) {
-      console.error('Save failed:', error);
-      throw error;
-    }
-  }
-
-  setParseObject(parseObject: Parse.Object): void {
-    this.parseObject = parseObject;
-  }
-}
-
-export class CloudQuery {
-  private query: Parse.Query;
-
-  constructor(className: string) {
-    this.query = new Parse.Query(className);
-  }
-
-  equalTo(key: string, value: any): CloudQuery {
-    this.query.equalTo(key, value);
-    return this;
-  }
-
-  async find(): Promise<CloudObject[]> {
-    try {
-      const results = await this.query.find();
-      return results.map((result: Parse.Object) => {
-        const obj = new CloudObject();
-        obj.setParseObject(result);
-        return obj;
-      });
-    } catch (error) {
-      console.error('Query failed:', error);
-      throw error;
-    }
-  }
-}
+import { CloudObject, CloudQuery } from '../../lib/ncloud';
 
 export class Task extends CloudObject {
   objectId?: string;
@@ -56,12 +9,13 @@ export class Task extends CloudObject {
   completed: boolean = false;
   startTime?: Date;
   endTime?: Date;
-  createdAt?: Date;
-  updatedAt?: Date;
+  override createdAt: Date;
+  override updatedAt: Date;
 
   constructor() {
-    super();
-    this.parseObject = new Parse.Object('Task');
+    super('Task');
+    this.createdAt = new Date();
+    this.updatedAt = new Date();
   }
 
   static fromParseObject(parseObject: Parse.Object): Task {
@@ -79,7 +33,7 @@ export class Task extends CloudObject {
     return task;
   }
 
-  override async save(): Promise<void> {
+  override async save(): Promise<this> {
     const currentUser = Parse.User.current();
     if (!currentUser) {
       throw new Error('User not logged in');
@@ -92,17 +46,18 @@ export class Task extends CloudObject {
     this.parseObject.set('startTime', this.startTime);
     this.parseObject.set('endTime', this.endTime);
 
-    // 设置 ACL
     const acl = new Parse.ACL(currentUser);
     acl.setPublicReadAccess(false);
     acl.setPublicWriteAccess(false);
     this.parseObject.setACL(acl);
 
     await super.save();
+    return this;
   }
 
-  async destroy(): Promise<void> {
+  override async destroy(): Promise<true | undefined> {
     await this.parseObject.destroy();
+    return true;
   }
 }
 
@@ -114,12 +69,13 @@ export class FocusRecord extends CloudObject {
   startTime?: Date;
   endTime?: Date;
   completed: boolean = false;
-  createdAt?: Date;
-  updatedAt?: Date;
+  override createdAt: Date;
+  override updatedAt: Date;
 
   constructor() {
-    super();
-    this.parseObject = new Parse.Object('FocusRecord');
+    super('FocusRecord');
+    this.createdAt = new Date();
+    this.updatedAt = new Date();
   }
 
   static fromParseObject(parseObject: Parse.Object): FocusRecord {
@@ -137,7 +93,7 @@ export class FocusRecord extends CloudObject {
     return record;
   }
 
-  override async save(): Promise<void> {
+  override async save(): Promise<this> {
     const currentUser = Parse.User.current();
     if (!currentUser) {
       throw new Error('User not logged in');
@@ -150,50 +106,13 @@ export class FocusRecord extends CloudObject {
     this.parseObject.set('endTime', this.endTime);
     this.parseObject.set('completed', this.completed);
 
-    // 设置 ACL
     const acl = new Parse.ACL(currentUser);
     acl.setPublicReadAccess(false);
     acl.setPublicWriteAccess(false);
     this.parseObject.setACL(acl);
 
     await super.save();
-  }
-}
-
-export class FocusRecordService {
-  static async createRecord(data: {
-    duration: number;
-    category: string;
-    startTime: Date;
-    endTime: Date;
-    completed: boolean;
-  }): Promise<FocusRecord> {
-    try {
-      const record = new FocusRecord();
-      Object.assign(record, data);
-      await record.save();
-      return record;
-    } catch (error) {
-      console.error('创建专注记录失败:', error);
-      throw error;
-    }
-  }
-
-  static async getRecords(): Promise<FocusRecord[]> {
-    try {
-      const query = new CloudQuery('FocusRecord');
-      query.equalTo('userId', Parse.User.current()?.id);
-      const results = await query.find();
-      return results.map(result => {
-        if (result instanceof Parse.Object) {
-          return FocusRecord.fromParseObject(result);
-        }
-        return result as FocusRecord;
-      });
-    } catch (error) {
-      console.error('获取专注记录失败:', error);
-      throw error;
-    }
+    return this;
   }
 }
 
@@ -203,7 +122,7 @@ export class TaskService {
       const query = new CloudQuery('Task');
       query.equalTo('user', Parse.User.current());
       const results = await query.find();
-      return results.map(result => {
+      return results.map((result: Parse.Object | Task) => {
         if (result instanceof Parse.Object) {
           return Task.fromParseObject(result);
         }
@@ -254,4 +173,41 @@ export class TaskService {
       throw error;
     }
   }
-} 
+}
+
+export class FocusRecordService {
+  static async createRecord(data: {
+    duration: number;
+    category: string;
+    startTime: Date;
+    endTime: Date;
+    completed: boolean;
+  }): Promise<FocusRecord> {
+    try {
+      const record = new FocusRecord();
+      Object.assign(record, data);
+      await record.save();
+      return record;
+    } catch (error) {
+      console.error('创建专注记录失败:', error);
+      throw error;
+    }
+  }
+
+  static async getRecords(): Promise<FocusRecord[]> {
+    try {
+      const query = new CloudQuery('FocusRecord');
+      query.equalTo('userId', Parse.User.current()?.id);
+      const results = await query.find();
+      return results.map((result: Parse.Object | FocusRecord) => {
+        if (result instanceof Parse.Object) {
+          return FocusRecord.fromParseObject(result);
+        }
+        return result as FocusRecord;
+      });
+    } catch (error) {
+      console.error('获取专注记录失败:', error);
+      throw error;
+    }
+  }
+}

src/app/tab1/tab1.page.html

@@ -1,77 +1,48 @@
-<ion-header [translucent]="true">
+<ion-header>
   <ion-toolbar>
-    <ion-title>
-      任务列表
-    </ion-title>
+    <ion-title>任务列表</ion-title>
     <ion-buttons slot="end">
-      <ion-button (click)="setOpen(true)">
-        <ion-icon name="add"></ion-icon>
+      <ion-button (click)="addTask()">
+        <ion-icon slot="icon-only" name="add-outline"></ion-icon>
       </ion-button>
     </ion-buttons>
   </ion-toolbar>
 </ion-header>
 
-<ion-content [fullscreen]="true">
-  <ion-list>
-    <ion-item *ngFor="let task of tasks">
-      <ion-checkbox slot="start" 
-                    [(ngModel)]="task.completed"
-                    (ionChange)="toggleComplete(task)">
-      </ion-checkbox>
-      <ion-label>
-        <h2>{{task.title}}</h2>
-        <p>{{task.content}}</p>
-        <p *ngIf="task.startTime">开始时间: {{task.startTime | date}}</p>
-        <p *ngIf="task.endTime">结束时间: {{task.endTime | date}}</p>
-      </ion-label>
-    </ion-item>
-  </ion-list>
+<ion-content>
+  <ion-refresher slot="fixed" (ionRefresh)="loadTasks($event)">
+    <ion-refresher-content></ion-refresher-content>
+  </ion-refresher>
 
-  <ion-modal [isOpen]="isModalOpen">
-    <ng-template>
-      <ion-header>
-        <ion-toolbar>
-          <ion-title>新建任务</ion-title>
-          <ion-buttons slot="end">
-            <ion-button (click)="setOpen(false)">关闭</ion-button>
-          </ion-buttons>
-        </ion-toolbar>
-      </ion-header>
-      <ion-content class="ion-padding">
-        <ion-item>
-          <ion-label position="stacked">标题</ion-label>
-          <ion-input [(ngModel)]="newTask.title" placeholder="输入任务标题"></ion-input>
-        </ion-item>
-        
-        <ion-item>
-          <ion-label position="stacked">描述</ion-label>
-          <ion-textarea [(ngModel)]="newTask.content" placeholder="输入任务描述"></ion-textarea>
-        </ion-item>
-        
-        <ion-item>
-          <ion-label position="stacked">开始时间</ion-label>
-          <ion-datetime-button datetime="startTime"></ion-datetime-button>
-          <ion-modal [keepContentsMounted]="true">
-            <ng-template>
-              <ion-datetime id="startTime" [(ngModel)]="newTask.startTime"></ion-datetime>
-            </ng-template>
-          </ion-modal>
-        </ion-item>
+  <ion-progress-bar type="indeterminate" *ngIf="loading"></ion-progress-bar>
 
-        <ion-item>
-          <ion-label position="stacked">结束时间</ion-label>
-          <ion-datetime-button datetime="endTime"></ion-datetime-button>
-          <ion-modal [keepContentsMounted]="true">
-            <ng-template>
-              <ion-datetime id="endTime" [(ngModel)]="newTask.endTime"></ion-datetime>
-            </ng-template>
-          </ion-modal>
-        </ion-item>
+  <ion-list>
+    <ion-item-sliding *ngFor="let task of tasks">
+      <ion-item [ngClass]="getTaskStatusClass(task)">
+        <ion-checkbox slot="start" 
+                     [(ngModel)]="task.completed" 
+                     (ionChange)="toggleComplete(task)">
+        </ion-checkbox>
+        <ion-label>
+          <div class="task-header">
+            <h2>{{ task.title }}</h2>
+            <ion-badge [color]="getTaskStatusColor(task)">
+              {{ getTaskStatusText(task) }}
+            </ion-badge>
+          </div>
+          <p>{{ task.content }}</p>
+          <p *ngIf="task.startTime || task.endTime">
+            <ion-icon name="calendar-outline"></ion-icon>
+            {{ task.startTime | date:'short' }} - {{ task.endTime | date:'short' }}
+          </p>
+        </ion-label>
+      </ion-item>
 
-        <ion-button expand="block" (click)="addTask()" class="ion-margin-top">
-          创建任务
-        </ion-button>
-      </ion-content>
-    </ng-template>
-  </ion-modal>
-</ion-content>
+      <ion-item-options side="end">
+        <ion-item-option color="danger" (click)="deleteTask(task)">
+          <ion-icon slot="icon-only" name="trash-outline"></ion-icon>
+        </ion-item-option>
+      </ion-item-options>
+    </ion-item-sliding>
+  </ion-list>
+</ion-content>

src/app/tab1/tab1.page.scss

@@ -1,41 +1,45 @@
-:host {
-  --background: #e0f7e9; /* 浅绿色背景 */
+.task-completed {
+  --background: rgba(var(--ion-color-success-rgb), 0.15);
+  --color: var(--ion-color-success-shade);
+  
+  ion-checkbox {
+      --border-color: var(--ion-color-success);
+      --background-checked: var(--ion-color-success);
+  }
 }
 
-ion-content {
-  --background: var(--background);
-  background-color: var(--background); /* 确保背景颜色应用 */
+.task-overdue {
+  --background: rgba(var(--ion-color-danger-rgb), 0.15);
+  --color: var(--ion-color-danger-shade);
+  
+  ion-checkbox {
+      --border-color: var(--ion-color-danger);
+      --background-checked: var(--ion-color-danger);
+  }
 }
 
-.task-item {
-  border-radius: 8px;
-  margin: 8px;
-  box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
-  --background: var(--task-color, #e0f7e9); /* 默认浅绿色背景 */
-  background-color: var(--background); /* 确保背景颜色应用 */
+.task-in-progress {
+  --background: rgba(var(--ion-color-primary-rgb), 0.15);
+  --color: var(--ion-color-primary-shade);
+  
+  ion-checkbox {
+      --border-color: var(--ion-color-primary);
+      --background-checked: var(--ion-color-primary);
+  }
 }
 
-.task-label h2 {
-  font-weight: bold;
-  margin: 0;
-  color: var(--ion-color-dark);
-}
-
-.task-label p {
-  margin: 0;
-  color: var(--ion-color-medium);
-}
-
-.strikethrough {
-  text-decoration: line-through;
-  color: var(--ion-color-medium);
+.task-header {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  margin-bottom: 4px;
+  
+  h2 {
+      margin: 0;
+  }
 }
 
 ion-badge {
-  font-size: 0.8em;
-}
-
-ion-toolbar {
-  --background: var(--ion-color-light);
-  --color: var(--ion-color-dark);
-}
+  font-size: 12px;
+  padding: 4px 8px;
+}

src/app/tab1/tab1.page.ts

@@ -1,10 +1,15 @@
 import { Component, OnInit } from '@angular/core';
-import { IonicModule, AlertController } from '@ionic/angular';
 import { CommonModule } from '@angular/common';
 import { FormsModule } from '@angular/forms';
+import { IonHeader, IonToolbar, IonTitle, IonContent, IonButtons, IonButton, 
+         IonIcon, IonList, IonItemSliding, IonItem, IonCheckbox, IonLabel, 
+         IonItemOptions, IonItemOption, IonProgressBar, IonRefresher, 
+         IonRefresherContent, IonBadge } from '@ionic/angular/standalone';
+import { AlertController, ModalController } from '@ionic/angular/standalone';
 import { addIcons } from 'ionicons';
-import { addOutline } from 'ionicons/icons';
-import { Task } from '../models/Task';
+import { addOutline, calendarOutline, trashOutline } from 'ionicons/icons';
+import { Task, TaskStatus } from '../../lib/models/Task';
+import { TaskModalComponent } from '../components/task-modal/task-modal.component';
 import * as Parse from 'parse';
 
 @Component({
@@ -12,98 +17,192 @@ import * as Parse from 'parse';
   templateUrl: 'tab1.page.html',
   styleUrls: ['tab1.page.scss'],
   standalone: true,
-  imports: [IonicModule, CommonModule, FormsModule]
+  imports: [
+    CommonModule, 
+    FormsModule, 
+    TaskModalComponent,
+    IonHeader, IonToolbar, IonTitle, IonContent, IonButtons, IonButton,
+    IonIcon, IonList, IonItemSliding, IonItem, IonCheckbox, IonLabel,
+    IonItemOptions, IonItemOption, IonProgressBar, IonRefresher,
+    IonRefresherContent, IonBadge
+  ]
 })
 export class Tab1Page implements OnInit {
   tasks: Task[] = [];
-  isModalOpen = false;
-  newTask: Task = new Task();
+  loading = false;
 
   constructor(
-    private alertController: AlertController
+    private alertController: AlertController,
+    private modalCtrl: ModalController
   ) {
-    addIcons({ addOutline });
+    addIcons({ addOutline, calendarOutline, trashOutline });
   }
 
   ngOnInit() {
-    this.checkLoginAndLoadTasks();
+    this.loadTasks();
   }
 
   ionViewWillEnter() {
-    this.checkLoginAndLoadTasks();
+    this.loadTasks();
   }
 
-  private async checkLoginAndLoadTasks() {
-    const currentUser = Parse.User.current();
-    console.log('Current User:', currentUser);
-    if (currentUser) {
-      await this.loadTasks();
-    }
-  }
-
-  private async loadTasks() {
+  async loadTasks(event?: any) {
     try {
-      this.tasks = await Task.getUserTasks(Parse.User.current()?.id || '');
+      this.loading = true;
+      const query = new Parse.Query('Task');
+      if (Parse.User.current()) {
+        query.equalTo('userId', Parse.User.current()?.id);
+      }
+      query.descending('createdAt');
+      
+      const results = await query.find();
+      this.tasks = results.map(result => {
+        const task = new Task();
+        task.fromParseObject(result);
+        return task;
+      });
+
+      // 根据状态排序：进行中 -> 逾期 -> 已完成
+      this.tasks.sort((a, b) => {
+        const statusOrder = {
+          [TaskStatus.InProgress]: 0,
+          [TaskStatus.Overdue]: 1,
+          [TaskStatus.Completed]: 2
+        };
+        return statusOrder[a.getStatus()] - statusOrder[b.getStatus()];
+      });
+
     } catch (error) {
       console.error('加载任务失败:', error);
+      await this.showErrorAlert('加载任务失败');
+    } finally {
+      this.loading = false;
+      if (event) {
+        event.target.complete();
+      }
     }
   }
 
   async addTask() {
-    const currentUser = Parse.User.current();
-    if (!currentUser) {
-      const alert = await this.alertController.create({
-        header: '提示',
-        message: '请先登录后再创建任务',
-        buttons: ['确定']
+    try {
+      const modal = await this.modalCtrl.create({
+        component: TaskModalComponent,
+        componentProps: {
+          task: new Task()
+        }
       });
-      await alert.present();
-      return;
-    }
+      await modal.present();
 
-    try {
-      if (!this.newTask.title) {
-        throw new Error('标题不能为空');
+      const { data: task, role } = await modal.onDidDismiss();
+      if (role === 'confirm' && task) {
+        const newTask = await Task.create({
+          title: task.title,
+          content: task.content,
+          startTime: task.startTime ? new Date(task.startTime) : undefined,
+          endTime: task.endTime ? new Date(task.endTime) : undefined,
+          completed: false,
+          userId: Parse.User.current()?.id
+        });
+        
+        this.tasks.unshift(newTask);
+        // 重新排序
+        await this.loadTasks();
       }
-
-      const newTaskData = {
-        title: this.newTask.title,
-        content: this.newTask.content || '',
-        completed: false,
-        startTime: new Date().toISOString(),
-        endTime: new Date().toISOString(),
-        userId: currentUser.id
-      };
-
-      const task = await Task.create(newTaskData);
-      console.log('Task created:', task);
-      this.tasks.push(task);
-      this.setOpen(false);
-      this.newTask = new Task();
     } catch (error) {
       console.error('创建任务失败:', error);
-      const errorAlert = await this.alertController.create({
-        header: '错误',
-        message: error instanceof Error ? error.message : '创建任务失败，请重试',
-        buttons: ['确定']
-      });
-      await errorAlert.present();
-    }
-  }
-
-  setOpen(isOpen: boolean) {
-    this.isModalOpen = isOpen;
-    if (!isOpen) {
-      this.newTask = new Task();
+      await this.showErrorAlert('创建任务失败');
     }
   }
 
   async toggleComplete(task: Task) {
-    task.completed = !task.completed;
     try {
+      task.completed = !task.completed;
       await task.saveTask();
+      
+      // 重新加载以保持正确的排序
+      await this.loadTasks();
     } catch (error) {
       console.error('更新任务失败:', error);
+      task.completed = !task.completed;
+      await this.showErrorAlert('更新任务状态失败');
+    }
+  }
+
+  async deleteTask(task: Task) {
+    const alert = await this.alertController.create({
+      header: '确认删除',
+      message: '确定要删除这个任务吗？',
+      buttons: [
+        {
+          text: '取消',
+          role: 'cancel'
+        },
+        {
+          text: '删除',
+          role: 'destructive',
+          handler: async () => {
+            try {
+              await task.delete();
+              this.tasks = this.tasks.filter(t => t.id !== task.id);
+            } catch (error) {
+              console.error('删除任务失败:', error);
+              await this.showErrorAlert('删除任务失败');
+            }
+          }
+        }
+      ]
+    });
+    await alert.present();
+  }
+
+  getTaskStatusClass(task: Task): string {
+    const status = task.getStatus();
+    switch (status) {
+      case TaskStatus.Completed:
+        return 'task-completed';
+      case TaskStatus.Overdue:
+        return 'task-overdue';
+      case TaskStatus.InProgress:
+        return 'task-in-progress';
+      default:
+        return '';
     }
   }
-}
+
+  getTaskStatusText(task: Task): string {
+    const status = task.getStatus();
+    switch (status) {
+      case TaskStatus.Completed:
+        return '已完成';
+      case TaskStatus.Overdue:
+        return '已逾期';
+      case TaskStatus.InProgress:
+        return '进行中';
+      default:
+        return '';
+    }
+  }
+
+  getTaskStatusColor(task: Task): string {
+    const status = task.getStatus();
+    switch (status) {
+      case TaskStatus.Completed:
+        return 'success';
+      case TaskStatus.Overdue:
+        return 'danger';
+      case TaskStatus.InProgress:
+        return 'primary';
+      default:
+        return 'medium';
+    }
+  }
+
+  private async showErrorAlert(message: string) {
+    const alert = await this.alertController.create({
+      header: '错误',
+      message,
+      buttons: ['确定']
+    });
+    await alert.present();
+  }
+}

src/app/tab2/tab2.page.ts

@@ -1,4 +1,4 @@
-import { Component, CUSTOM_ELEMENTS_SCHEMA } from '@angular/core';
+import { Component, CUSTOM_ELEMENTS_SCHEMA, OnInit } from '@angular/core';
 import { CommonModule } from '@angular/common';
 import { FormsModule } from '@angular/forms';
 import { IonicModule } from '@ionic/angular';
@@ -16,9 +16,14 @@ import {
   languageOutline,
   pencilOutline,
   trashOutline,
-  addOutline
+  addOutline,
+  arrowBackOutline,
+  pauseOutline,
+  playOutline,
+  stopOutline
 } from 'ionicons/icons';
 import { AlertController } from '@ionic/angular';
+import { FocusDataService } from '../services/focus-data.service';
 
 interface TimerRecord {
   id: number;
@@ -26,6 +31,7 @@ interface TimerRecord {
   startTime: string;
   endTime: string;
   duration: number;
+  parseId?: string;
 }
 
 @Component({
@@ -36,7 +42,7 @@ interface TimerRecord {
   schemas: [CUSTOM_ELEMENTS_SCHEMA],
   imports: [IonicModule, CommonModule, FormsModule]
 })
-export class Tab2Page {
+export class Tab2Page implements OnInit {
   activityTypes = [
     { id: 'study', name: '学习', icon: 'school-outline' },
     { id: 'work', name: '工作', icon: 'briefcase-outline' },
@@ -56,31 +62,51 @@ export class Tab2Page {
   currentTime: string = '00:00:00';
   records: TimerRecord[] = [];
   timer: any;
-  countdownMinutes: number = 25; // 默认25分钟
+  countdownMinutes: number = 25;
 
   constructor(
     private router: Router,
-    private alertController: AlertController
+    private alertController: AlertController,
+    private focusDataService: FocusDataService
   ) {
-    // 注册图标
     addIcons({
-      'school-outline': schoolOutline,
-      'briefcase-outline': briefcaseOutline,
-      'moon-outline': moonOutline,
-      'barbell-outline': barbellOutline,
-      'book-outline': bookOutline,
-      'code-slash-outline': codeSlashOutline,
-      'leaf-outline': leafOutline,
-      'musical-notes-outline': musicalNotesOutline,
-      'language-outline': languageOutline,
-      'pencil-outline': pencilOutline,
-      'trash-outline': trashOutline,
-      'add-outline': addOutline
+      schoolOutline,
+      briefcaseOutline,
+      moonOutline,
+      barbellOutline,
+      bookOutline,
+      codeSlashOutline,
+      leafOutline,
+      musicalNotesOutline,
+      languageOutline,
+      pencilOutline,
+      trashOutline,
+      addOutline,
+      arrowBackOutline,
+      pauseOutline,
+      playOutline,
+      stopOutline
     });
+  }
+
+  ngOnInit() {
+    this.loadRecords();
+  }
 
-    const savedRecords = localStorage.getItem('timerRecords');
-    if (savedRecords) {
-      this.records = JSON.parse(savedRecords);
+  async loadRecords() {
+    try {
+      const records = await this.focusDataService.getFocusRecords();
+      this.records = records.map(record => ({
+        id: Date.now(),
+        type: record.category,
+        startTime: record.date.toISOString(),
+        endTime: record.date.toISOString(),
+        duration: record.duration,
+        parseId: record.id
+      }));
+    } catch (error) {
+      console.error('加载记录失败:', error);
+      this.showErrorAlert('加载记录失败');
     }
   }
 
@@ -108,22 +134,34 @@ export class Tab2Page {
     }, 1000);
   }
 
-  stopTimer() {
+  async stopTimer() {
     if (this.timer) {
       clearInterval(this.timer);
       const endTime = new Date();
-      const duration = Math.floor((endTime.getTime() - this.timerStartTime!.getTime()) / 60000); // 转换为分钟
+      const duration = Math.floor((endTime.getTime() - this.timerStartTime!.getTime()) / 60000);
       
-      const record: TimerRecord = {
-        id: Date.now(),
-        type: this.selectedType,
-        startTime: this.timerStartTime!.toISOString(),
-        endTime: endTime.toISOString(),
-        duration: duration
-      };
-      
-      this.records.unshift(record);
-      this.saveRecords();
+      try {
+        const savedRecord = await this.focusDataService.addFocusRecord({
+          duration: duration,
+          category: this.selectedType,
+          startTime: this.timerStartTime!,
+          endTime: endTime
+        });
+
+        const record: TimerRecord = {
+          id: Date.now(),
+          type: this.selectedType,
+          startTime: this.timerStartTime!.toISOString(),
+          endTime: endTime.toISOString(),
+          duration: duration,
+          parseId: savedRecord.id
+        };
+        
+        this.records.unshift(record);
+      } catch (error) {
+        console.error('保存专注记录失败:', error);
+        this.showErrorAlert('保存记录失败');
+      }
       
       this.isTimerRunning = false;
       this.timerStartTime = null;
@@ -139,17 +177,12 @@ export class Tab2Page {
     
     const selectedActivity = this.activityTypes.find(t => t.id === this.selectedType);
     if (selectedActivity) {
-      console.log('Navigating to countdown with params:', {
-        type: selectedActivity.icon,
-        name: selectedActivity.name,
-        duration: this.countdownMinutes
-      });
-      
-      this.router.navigate(['/tabs/countdown'], {
+      this.router.navigate(['/countdown'], {
         queryParams: {
           type: selectedActivity.icon,
           name: selectedActivity.name,
-          duration: this.countdownMinutes
+          duration: this.countdownMinutes,
+          category: selectedActivity.id
         }
       });
     }
@@ -159,10 +192,6 @@ export class Tab2Page {
     return num.toString().padStart(2, '0');
   }
 
-  private saveRecords() {
-    localStorage.setItem('timerRecords', JSON.stringify(this.records));
-  }
-
   getTypeName(typeId: string): string {
     const type = this.activityTypes.find(t => t.id === typeId);
     return type ? type.name : '';
@@ -180,7 +209,11 @@ export class Tab2Page {
   }
 
   async deleteRecord(index: number) {
-    // 创建一个警告对话框
+    const record = this.records[index];
+    if (!record.parseId) {
+      return;
+    }
+
     const alert = await this.alertController.create({
       header: '确认删除',
       message: '你确定要删除这条记录吗？',
@@ -192,9 +225,14 @@ export class Tab2Page {
         {
           text: '删除',
           role: 'destructive',
-          handler: () => {
-            // 从数组中删除指定索引的记录
-            this.records.splice(index, 1);
+          handler: async () => {
+            try {
+              await this.focusDataService.deleteFocusRecord(record.parseId!);
+              this.records.splice(index, 1);
+            } catch (error) {
+              console.error('删除记录失败:', error);
+              this.showErrorAlert('删除记录失败');
+            }
           }
         }
       ]
@@ -202,4 +240,13 @@ export class Tab2Page {
 
     await alert.present();
   }
+
+  private async showErrorAlert(message: string) {
+    const alert = await this.alertController.create({
+      header: '错误',
+      message,
+      buttons: ['确定']
+    });
+    await alert.present();
+  }
 }

src/app/tab3/tab3.page.ts

@@ -20,9 +20,9 @@ export class Tab3Page implements OnInit {
 
   constructor(private focusDataService: FocusDataService) {}
 
-  ngOnInit() {
-    this.focusRecords = this.focusDataService.getFocusRecords();
-    console.log('Focus Records in Tab3:', this.focusRecords); // 检查数据是否正确获取
+  async ngOnInit() {
+    this.focusRecords = await this.focusDataService.getFocusRecords();
+    console.log('Focus Records in Tab3:', this.focusRecords);
     this.loadChartData();
   }
 

src/app/tab4/tab4.page.ts

@@ -1,5 +1,7 @@
 import { Component } from '@angular/core';
-import { IonHeader, IonToolbar, IonTitle, IonContent, IonCard, IonCardContent, IonButton, IonCardHeader, IonCardTitle, IonCardSubtitle, ModalController, AlertController } from '@ionic/angular/standalone';
+import { IonHeader, IonToolbar, IonTitle, IonContent, IonCard, IonCardContent, 
+         IonButton, IonCardHeader, IonCardTitle, IonCardSubtitle } from '@ionic/angular/standalone';
+import { ModalController, AlertController } from '@ionic/angular/standalone';
 
 import { Router } from '@angular/router';
 import { openUserLoginModal } from '../../lib/user/modal-user-login/modal-user-login.component';
@@ -42,43 +44,43 @@ export class Tab4Page {
     this.currentUser = new CloudUser();
   }
 
-  async login(){
-    try {
-      let user = await openUserLoginModal(this.modalCtrl);
-      if(user?.id){
-        this.currentUser = user;
-        // this.auth.setCurrentUser(user);
-      } else {
-        // 登录失败时显示提示
-        const alert = await this.alertController.create({
-          header: '登录失败',
-          message: '用户名或密码错误，请重试',
-          buttons: ['确定']
-        });
-        await alert.present();
+  async openLoginModal() {
+    const { data } = await openUserLoginModal(this.modalCtrl);
+    if (data?.role === 'confirm') {
+      const cloudUser = data.data as CloudUser;
+      if (cloudUser?.id) {
+        this.currentUser = cloudUser;
+        await this.auth.login(cloudUser.get('username'), cloudUser.get('password'));
       }
-    } catch (error) {
-      // 处理其他错误
-      const alert = await this.alertController.create({
-        header: '登录错误',
-        message: '登录过程中发生错误，请稍后重试',
-        buttons: ['确定']
-      });
-      await alert.present();
     }
   }
 
-  async signup(){
-    // 弹出注册窗口
-    let user = await openUserLoginModal(this.modalCtrl,"signup");
-    if(user?.id){
-      this.currentUser = user
+  async openSignupModal() {
+    const { data } = await openUserLoginModal(this.modalCtrl);
+    if (data?.role === 'confirm') {
+      const cloudUser = data.data as CloudUser;
+      if (cloudUser?.id) {
+        this.currentUser = cloudUser;
+        await this.auth.register(
+          cloudUser.get('username'), 
+          cloudUser.get('password'), 
+          cloudUser.get('email') || ''
+        );
+      }
+    }
+  }
+
+  async handleUserAction() {
+    const { data } = await openUserLoginModal(this.modalCtrl);
+    if (!data?.data) {
+      return;
     }
+    this.currentUser = data.data as CloudUser;
   }
 
   logout(){
-    this.currentUser?.logout();
-    this.auth.setCurrentUser(null);
+    this.currentUser?.logOut();
+    this.auth.logout();
   }
 
   editUser(){
@@ -92,129 +94,12 @@ export class Tab4Page {
     let userPrompt = ``
     if(!currentUser?.id){
       console.log("用户未登录，请登录后重试");
-      let user = await openUserLoginModal(this.modalCtrl);
-      if(!user?.id){
-        return
+      const { data } = await openUserLoginModal(this.modalCtrl);
+      if (!data?.data) {
+        return;
       }
-      currentUser = user;
+      currentUser = data.data as CloudUser;
     }
     this.editTags=ev;
   }
-
-  doctorList:Array<CloudObject> = []
-   /** 示例：问诊根据doctor拼接提示词 */
-   async loadDoctorList(){
-    let query = new CloudQuery("Doctor");
-    query.include("depart")
-    let List = await query.find()
-    for(let i = 0; i < 3; i++) {
-      this.doctorList.push(List[i])
-    }
-  }
-  
-   /** 示例：问诊根据doctor拼接提示词 */
-   async openInquiry(doctor:any){
-    // 验证用户登录
-    let userPrompt = ``
-    if(!this.currentUser?.id){
-      console.log("用户未登录，请登录后重试");
-      // let user = await openUserLoginModal(this.modalCtrl);
-      // if(!user?.id){
-      //   return
-      // }
-      // currentUser = user;
-      this.router.navigate(['/tabs/tab4'])
-      return 
-    }
-    console.log("currentUser: ",this.currentUser)
-    if(this.currentUser?.get("realname")){
-      userPrompt += `当前来访的患者，姓名：${this.currentUser?.get("realname")}`
-    }
-    if(this.currentUser?.get("gender")){
-      userPrompt += `，性别：${this.currentUser?.get("gender")}`
-    }
-    if(this.currentUser?.get("age")){
-      userPrompt += `，年龄：${this.currentUser?.get("age")}`
-    }
-
-
-    localStorage.setItem("company","E4KpGvTEto")
-
-    let consult = new CloudObject("Consultation")
-    let now = new Date();
-    let dateStr = `${now.getFullYear()}-${now.getMonth()+1}-${now.getDate()}`
-    // 对象权限的精确指定
-    let ACL:any = {
-      "*":{read:true,write:true}
-    }
-    consult.set({
-      // title:`${doctor.get('depart')?.name || ""}门诊记录${dateStr}-${doctor?.get("name")}`,
-      // doctor:doctor.toPointer(),
-      // depart:{
-      //   __type:"Pointer",
-      //   className:"Department",
-      //   objectId:doctor.get("depart")?.objectId
-      // },
-      user:this.currentUser.toPointer(),
-      ACL:ACL
-    })
-
-    let options:ChatPanelOptions = {
-      roleId:"2DXJkRsjXK",
-      onChatInit:(chat:FmodeChat)=>{
-        console.log("onChatInit");
-              console.log("预设角色",chat.role);
-              chat.role.set("name",doctor?.get("name"));
-              // chat.role.set("system","你是一名计算机老师，请根据用户提问，给出专业、简洁、准确的答案");
-              chat.role.set("title",doctor?.get("title"));
-              chat.role.set("desc",doctor?.get("desc"));
-              chat.role.set("tags",doctor?.get("qualifications"));
-              chat.role.set("avatar",doctor?.get("avatar") || "../../assets/image/doctor7.png")
-              chat.role.set("prompt",`
-# 角色设定
-您是${doctor?.get("name")}，${doctor?.get("desc")}，年龄${doctor?.get("age")}岁，需要完成一次完整的门诊服务，直接和用户打招呼，询问用户的情况。
-
-# 对话环节
-0.直接和用户打招呼（如：你好，XXX，我是···）
-- 注意：如果用户问的问题和你的${doctor?.get("specialty")}的不符，请直接引导用户去其他的科室
-1.预设的问询方式（根据不同症状来问询具体的情况）
-- 打招呼，以用户自述为主
-- 当信息充足时候，确认用户症状对应的科室，并进入下一个环节
-2.拓展的问询细节
-例如：用户反映呼吸不畅，拓展出：是否咳嗽；是否感觉痛或者痒等其他需要的问题。
-- 当问询细节补充完成后进入下一个环节
-3.初步的诊断结果，并且同时列出检查检验项目
-初步诊断：确定需要有哪些进一步检查
-检查检验：获取医学客观数据
-- 等待用户提交客观数据，进入下一阶段
-4.给出诊断方案并给出处方
-- 完成处方时，请在消息结尾附带: [处方完成]
-
-# 开始话语
-当您准备好了，可以以一个医生的身份，先向来访的用户亲切地打招呼。
-${userPrompt}
-`);
-      },
-      onMessage:(chat:FmodeChat,message:FmodeChatMessage)=>{
-        console.log("onMessage",message)
-        let content:any = message?.content
-        if(typeof content == "string"){
-          if(content?.indexOf("[处方完成]")>-1){
-            let list = chat?.messageList
-            console.log("门诊已完成")
-            consult.set({
-              allContent:list,
-              content:content,
-            })
-            consult.save();
-          }
-        }
-      },
-      onChatSaved:(chat:FmodeChat)=>{
-        console.log("onChatSaved",chat,chat?.chatSession,chat?.chatSession?.id)
-      }
-    }
-    openChatPanelModal(this.modalCtrl,options)
-  }
-
 }

src/index.html

@@ -12,12 +12,22 @@
   <meta name="format-detection" content="telephone=no" />
   <meta name="msapplication-tap-highlight" content="no" />
 
+  <!-- 添加 CSP -->
+  <meta http-equiv="Content-Security-Policy" 
+        content="default-src 'self' data: https://ssl.gstatic.com 'unsafe-eval' 'unsafe-inline' https://cdn.jsdelivr.net http://dev.fmode.cn:1337;
+                 style-src 'self' 'unsafe-inline' https://cdn.jsdelivr.net;
+                 font-src 'self' data: https://cdn.jsdelivr.net;
+                 img-src 'self' data: https: blob:;
+                 connect-src 'self' http://dev.fmode.cn:1337 ws://localhost:* wss://localhost:*;">
+
   <link rel="icon" type="image/png" href="assets/icon/favicon.png" />
 
   <!-- add to homescreen for ios -->
   <meta name="apple-mobile-web-app-capable" content="yes" />
   <meta name="apple-mobile-web-app-status-bar-style" content="black" />
 
+  <!-- 修改 ionicons 的引入方式 -->
+  <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/@ionic/core/css/ionic.bundle.css" />
   <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/ionicons@5.5.2/dist/css/ionicons.min.css">
 </head>
 
@@ -25,4 +35,4 @@
   <app-root></app-root>
 </body>
 
-</html>
+</html>

src/lib/interfaces/base.interface.ts

@@ -0,0 +1,21 @@
+export interface IBaseModel {
+    id?: string;
+    createdAt?: Date;
+    updatedAt?: Date;
+  }
+  
+  export interface IUser extends IBaseModel {
+    username: string;
+    realname?: string;
+    age?: number;
+    gender?: string;
+    avatar?: string;
+  }
+  
+  export interface ITask extends IBaseModel {
+    title: string;
+    startTime: Date;
+    endTime: Date;
+    completed: boolean;
+    userId: string;
+  }

src/lib/models/Task.ts

@@ -1,34 +1,100 @@
-import { CloudObject, CloudQuery } from '../ncloud';
+import { CloudObject } from '../ncloud';
+import * as Parse from 'parse';
+
+export enum TaskStatus {
+    InProgress = 'inProgress',
+    Completed = 'completed',
+    Overdue = 'overdue'
+}
 
 export class Task extends CloudObject {
+    title: string = '';
+    content: string = '';
+    completed: boolean = false;
+    startTime?: Date;
+    endTime?: Date;
+    userId?: string;
+
     constructor() {
         super('Task');
     }
 
-    // 创建新任务
-    static async create(data: {
-        title: string;
-        startTime: Date;
-        endTime: Date;
-        completed: boolean;
-        userId: string;
-    }) {
-        const task = new Task();
-        task.set(data);
-        await task.save();
-        return task;
+    fromParseObject(parseObject: Parse.Object) {
+        this.id = parseObject.id;
+        this.title = parseObject.get('title');
+        this.content = parseObject.get('content');
+        this.completed = parseObject.get('completed');
+        this.startTime = parseObject.get('startTime');
+        this.endTime = parseObject.get('endTime');
+        this.userId = parseObject.get('userId');
+    }
+
+    toParseObject(): any {
+        return {
+            title: this.title,
+            content: this.content,
+            completed: this.completed,
+            startTime: this.startTime,
+            endTime: this.endTime,
+            userId: this.userId
+        };
+    }
+
+    async saveTask(): Promise<void> {
+        try {
+            const data = this.toParseObject();
+            const parseObject = new Parse.Object('Task');
+            
+            if (this.id) {
+                parseObject.id = this.id;
+            }
+            
+            Object.keys(data).forEach(key => {
+                parseObject.set(key, data[key]);
+            });
+
+            await parseObject.save();
+            this.id = parseObject.id;
+        } catch (error) {
+            console.error('保存任务失败:', error);
+            throw error;
+        }
+    }
+
+    async delete(): Promise<void> {
+        try {
+            if (!this.id) return;
+            
+            const parseObject = new Parse.Object('Task');
+            parseObject.id = this.id;
+            await parseObject.destroy();
+        } catch (error) {
+            console.error('删除任务失败:', error);
+            throw error;
+        }
     }
 
-    // 获取用户的所有任务
-    static async getUserTasks(userId: string) {
-        const query = new CloudQuery('Task');
-        query.equalTo('userId', userId);
-        return await query.find();
+    getStatus(): TaskStatus {
+        if (this.completed) {
+            return TaskStatus.Completed;
+        }
+        
+        if (this.endTime && new Date() > new Date(this.endTime)) {
+            return TaskStatus.Overdue;
+        }
+        
+        return TaskStatus.InProgress;
     }
 
-    // 更新任务状态
-    async updateStatus(completed: boolean) {
-        this.set({ completed });
-        return await this.save();
+    static async create(data: Partial<Task>): Promise<Task> {
+        try {
+            const task = new Task();
+            Object.assign(task, data);
+            await task.saveTask();
+            return task;
+        } catch (error) {
+            console.error('Create task failed:', error);
+            throw error;
+        }
     }
-} 
+}

src/lib/ncloud.ts

@@ -1,9 +1,11 @@
+import * as Parse from 'parse';
+
 // CloudObject.ts
 export class CloudObject {
     className: string;
     id: string | null = null;
-    createdAt:any;
-    updatedAt:any;
+    createdAt: any;
+    updatedAt: any;
     data: Record<string, any> = {};
 
     constructor(className: string) {
@@ -16,7 +18,8 @@ export class CloudObject {
 
     set(json: Record<string, any>) {
         Object.keys(json).forEach(key => {
-            if (["objectId", "id", "createdAt", "updatedAt"].indexOf(key) > -1) {
+            if (["objectId", "id", "createdAt", "updatedAt", "ACL"].indexOf(key) > -1) {
+                if (key === "objectId") this.id = json[key];
                 return;
             }
             this.data[key] = json[key];
@@ -31,7 +34,6 @@ export class CloudObject {
         let method = "POST";
         let url = `https://dev.fmode.cn/parse/classes/${this.className}`;
 
-        // 更新
         if (this.id) {
             url += `/${this.id}`;
             method = "PUT";
@@ -51,7 +53,7 @@ export class CloudObject {
 
         const result = await response?.json();
         if (result?.error) {
-            console.error(result?.error);
+            throw new Error(result.error);
         }
         if (result?.objectId) {
             this.id = result?.objectId;
@@ -65,29 +67,33 @@ export class CloudObject {
             headers: {
                 "x-parse-application-id": "dev"
             },
-            body: null,
             method: "DELETE",
             mode: "cors",
             credentials: "omit"
         });
 
         const result = await response?.json();
-        if (result) {
-            this.id = null;
+        if (result?.error) {
+            throw new Error(result.error);
         }
+        this.id = null;
         return true;
     }
+
+    protected setParseObject(obj: Parse.Object) {
+        this.parseObject = obj;
+    }
 }
 
-// CloudQuery.ts
 export class CloudQuery {
+    private query: Parse.Query;
     className: string;
     queryParams: Record<string, any> = {};
 
     constructor(className: string) {
         this.className = className;
     }
-
+    // 作用是将查询参数转换为对象
     include(...fileds:string[]) {
         this.queryParams["include"] = fileds;
     }
@@ -112,12 +118,11 @@ export class CloudQuery {
     }
 
     equalTo(key: string, value: any) {
-        if (!this.queryParams["where"]) this.queryParams["where"] = {};
         this.queryParams["where"][key] = value;
     }
 
     async get(id: string) {
-        const url = `https://dev.fmode.cn/parse/classes/${this.className}/${id}?`;
+        const url = `http://dev.fmode.cn:1337/parse/classes/${this.className}/${id}?`;
 
         const response = await fetch(url, {
             headers: {
@@ -131,52 +136,32 @@ export class CloudQuery {
         });
 
         const json = await response?.json();
-        if (json) {
-            let existsObject = this.dataToObj(json)
+        // return json || {};
+        const exists = json?.results?.[0] || null;
+        if (exists) {
+            let existsObject = this.dataToObj(exists)
             return existsObject;
         }
         return null
-    }
 
-    async find():Promise<Array<CloudObject>> {
-        let url = `https://dev.fmode.cn/parse/classes/${this.className}?`;
-
-        let queryStr = ``
-        Object.keys(this.queryParams).forEach(key=>{
-            let paramStr = JSON.stringify(this.queryParams[key]);
-            if(key=="include"){
-                paramStr = this.queryParams[key]?.join(",")
-            }
-            if(queryStr) {
-                url += `${key}=${paramStr}`;
-            }else{
-                url += `&${key}=${paramStr}`;
-            }
-        })
-        // if (Object.keys(this.queryParams["where"]).length) {
-            
-        // }
-
-        const response = await fetch(url, {
-            headers: {
-                "if-none-match": "W/\"1f0-ghxH2EwTk6Blz0g89ivf2adBDKY\"",
-                "x-parse-application-id": "dev"
-            },
-            body: null,
-            method: "GET",
-            mode: "cors",
-            credentials: "omit"
-        });
-
-        const json = await response?.json();
-        let list = json?.results || []
-        let objList = list.map((item:any)=>this.dataToObj(item))
-        return objList || [];
     }
 
+    async find(): Promise<CloudObject[]> {
+        try {
+            const results = await this.query.find();
+            return results.map((result: Parse.Object) => {
+                const obj = new CloudObject(this.className);
+                (obj as any).parseObject = result;  // 使用类型断言
+                return obj;
+            });
+        } catch (error) {
+            console.error('Query failed:', error);
+            throw error;
+        }
+    }
 
     async first() {
-        let url = `https://dev.fmode.cn/parse/classes/${this.className}?`;
+        let url = `http://dev.fmode.cn:1337/parse/classes/${this.className}?`;
 
         if (Object.keys(this.queryParams["where"]).length) {
             const whereStr = JSON.stringify(this.queryParams["where"]);
@@ -185,36 +170,26 @@ export class CloudQuery {
 
         const response = await fetch(url, {
             headers: {
-                "if-none-match": "W/\"1f0-ghxH2EwTk6Blz0g89ivf2adBDKY\"",
                 "x-parse-application-id": "dev"
-            },
-            body: null,
-            method: "GET",
-            mode: "cors",
-            credentials: "omit"
+            }
         });
 
         const json = await response?.json();
-        const exists = json?.results?.[0] || null;
-        if (exists) {
-            let existsObject = this.dataToObj(exists)
-            return existsObject;
-        }
-        return null
-    }
-
-    dataToObj(exists:any):CloudObject{
-        let existsObject = new CloudObject(this.className);
-        existsObject.set(exists);
-        existsObject.id = exists.objectId;
-        existsObject.createdAt = exists.createdAt;
-        existsObject.updatedAt = exists.updatedAt;
-        return existsObject;
+        // const exists = json?.results?.[0] || null;
+        // if (exists) {
+        //     let existsObject = this.dataToObj(exists)
+        //     return existsObject;
+        // }
+        // return null
+        let list = json?.results || []
+        let objList = list.map((item:any)=>this.dataToObj(item))
+        return objList || [];
     }
 }
 
-// CloudUser.ts
 export class CloudUser extends CloudObject {
+    sessionToken: string | null = null;
+
     constructor() {
         super("_User"); // 假设用户类在Parse中是"_User"
         // 读取用户缓存信息
@@ -236,7 +211,7 @@ export class CloudUser extends CloudObject {
             return null;
         }
         return this;
-        // const response = await fetch(`https://dev.fmode.cn/parse/users/me`, {
+        // const response = await fetch(`http://dev.fmode.cn:1337/parse/users/me`, {
         //     headers: {
         //         "x-parse-application-id": "dev",
         //         "x-parse-session-token": this.sessionToken // 使用sessionToken进行身份验证
@@ -254,74 +229,58 @@ export class CloudUser extends CloudObject {
 
     /** 登录 */
     async login(username: string, password: string):Promise<CloudUser|null> {
-        const response = await fetch(`https://dev.fmode.cn/parse/login`, {
+        const response = await fetch(`http://dev.fmode.cn:1337/parse/login`, {
             headers: {
-                "x-parse-application-id": "dev",
-                "Content-Type": "application/json"
+                'Content-Type': 'application/json',
+                'X-Parse-Application-Id': 'dev'
             },
-            body: JSON.stringify({ username, password }),
-            method: "POST"
+            body: JSON.stringify({ username, password })
         });
 
-        const result = await response?.json();
+        const result = await response.json();
         if (result?.error) {
-            console.error(result?.error);
-            return null;
+            throw new Error(result.error);
         }
-        
-        // 设置用户信息
-        this.id = result?.objectId;
-        this.sessionToken = result?.sessionToken;
-        this.data = result; // 保存用户数据
-        // 缓存用户信息
-        console.log(result)
-        localStorage.setItem("NCloud/dev/User",JSON.stringify(result))
+
+        this.id = result.objectId;
+        this.sessionToken = result.sessionToken;
+        this.data = result;
+        localStorage.setItem("NCloud/dev/User", JSON.stringify(result));
         return this;
     }
 
-    /** 登出 */
-    async logout() {
+    async logOut() {
         if (!this.sessionToken) {
-            console.error("用户未登录");
-            return;
+            throw new Error('User not logged in');
         }
 
         const response = await fetch(`https://dev.fmode.cn/parse/logout`, {
             headers: {
-                "x-parse-application-id": "dev",
-                "x-parse-session-token": this.sessionToken
+                'X-Parse-Application-Id': 'dev',
+                'X-Parse-Session-Token': this.sessionToken
             },
-            method: "POST"
+            method: 'POST'
         });
 
-        let result = await response?.json();
-
+        const result = await response?.json();
         if (result?.error) {
             console.error(result?.error);
-            if(result?.error=="Invalid session token"){
-                this.clearUserCache()
-                return true;
-            }
             return false;
         }
 
-        this.clearUserCache()
-        return true;
-    }
-    clearUserCache(){
         // 清除用户信息
         localStorage.removeItem("NCloud/dev/User")
         this.id = null;
         this.sessionToken = null;
         this.data = {};
+        return true;
     }
 
-    /** 注册 */
     async signUp(username: string, password: string, additionalData: Record<string, any> = {}) {
         const userData = {
             username,
             password,
-            ...additionalData // 合并额外的用户数据
+            ...additionalData // 合并额外的用户��据
         };
 
         const response = await fetch(`https://dev.fmode.cn/parse/users`, {
@@ -335,23 +294,19 @@ export class CloudUser extends CloudObject {
 
         const result = await response?.json();
         if (result?.error) {
-            console.error(result?.error);
-            return null;
+            throw new Error(result.error);
         }
 
-        // 设置用户信息
-        // 缓存用户信息
-        console.log(result)
-        localStorage.setItem("NCloud/dev/User",JSON.stringify(result))
         this.id = result?.objectId;
         this.sessionToken = result?.sessionToken;
-        this.data = result; // 保存用户数据
+        this.data = result;
+        localStorage.setItem("NCloud/dev/User", JSON.stringify(result));
         return this;
     }
 
     override async save() {
         let method = "POST";
-        let url = `https://dev.fmode.cn/parse/users`;
+        let url = `http://dev.fmode.cn:1337/parse/users`;
     
         // 更新用户信息
         if (this.id) {
@@ -371,21 +326,23 @@ export class CloudUser extends CloudObject {
             "x-parse-session-token": this.sessionToken, // 添加sessionToken以进行身份验证
         }
         const response = await fetch(url, {
-            headers: headersOptions,
-            body: body,
-            method: method,
+            headers: {
+                "content-type": "application/json;charset=UTF-8",
+                "x-parse-application-id": "dev",
+                "x-parse-session-token": this.sessionToken
+            },
+            body: JSON.stringify(data),
+            method: "PUT",
             mode: "cors",
             credentials: "omit"
         });
-    
+
         const result = await response?.json();
         if (result?.error) {
-            console.error(result?.error);
+            throw new Error(result.error);
         }
-        if (result?.objectId) {
-            this.id = result?.objectId;
-        }
-        localStorage.setItem("NCloud/dev/User",JSON.stringify(this.data))
+        
+        localStorage.setItem("NCloud/dev/User", JSON.stringify(this.data));
         return this;
     }
 }

src/lib/services/task.service.ts

@@ -0,0 +1,26 @@
+import { Injectable } from '@angular/core';
+import { Task } from '../models/Task';
+import { ITask } from '../interfaces/base.interface';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class TaskService {
+  async createTask(taskData: Partial<ITask>): Promise<Task | null> {
+    try {
+      return await Task.create(taskData as any);
+    } catch (error) {
+      console.error('Create task failed:', error);
+      return null;
+    }
+  }
+
+  async getUserTasks(userId: string): Promise<Task[]> {
+    try {
+      return await Task.getUserTasks(userId);
+    } catch (error) {
+      console.error('Get user tasks failed:', error);
+      return [];
+    }
+  }
+}

src/lib/services/user.service.ts

@@ -0,0 +1,32 @@
+import { Injectable } from '@angular/core';
+import { CloudUser } from '../ncloud';
+import { IUser } from '../interfaces/base.interface';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class UserService {
+  private currentUser: CloudUser | null = null;
+
+  async getCurrentUser(): Promise<CloudUser | null> {
+    if (!this.currentUser) {
+      this.currentUser = new CloudUser();
+      await this.currentUser.current();
+    }
+    return this.currentUser;
+  }
+
+  async updateUserProfile(userData: Partial<IUser>): Promise<boolean> {
+    try {
+      const user = await this.getCurrentUser();
+      if (!user) return false;
+      
+      user.set(userData);
+      await user.save();
+      return true;
+    } catch (error) {
+      console.error('Update user profile failed:', error);
+      return false;
+    }
+  }
+}

src/lib/user/modal-user-edit/modal-user-edit.component.ts

@@ -1,7 +1,11 @@
-import { Input, OnInit } from '@angular/core';
-import { Component } from '@angular/core';
-import { IonHeader, IonToolbar, IonTitle, IonContent, IonCard, IonCardContent, IonButton, IonCardHeader, IonCardTitle, IonCardSubtitle, ModalController, IonInput, IonItem, IonSegment, IonSegmentButton, IonLabel } from '@ionic/angular/standalone';
+import { Component, OnInit } from '@angular/core';
+import { IonHeader, IonToolbar, IonTitle, IonContent, IonCard, IonCardContent, 
+         IonButton, IonCardHeader, IonCardTitle, IonCardSubtitle, IonInput, 
+         IonItem, IonSegment, IonSegmentButton, IonLabel } from '@ionic/angular/standalone';
+import { ModalController } from '@ionic/angular/standalone';
 import { CloudUser } from '../../ncloud';
+import { CommonModule } from '@angular/common';
+import { FormsModule } from '@angular/forms';
 
 @Component({
   selector: 'app-modal-user-edit',
@@ -9,11 +13,24 @@ import { CloudUser } from '../../ncloud';
   styleUrls: ['./modal-user-edit.component.scss'],
   standalone: true,
   imports: [
-    IonHeader, IonToolbar, IonTitle, IonContent, 
-    IonCard,IonCardContent,IonButton,IonCardHeader,IonCardTitle,IonCardSubtitle,
-    IonInput,IonItem,
-    IonSegment,IonSegmentButton,IonLabel
-  ],
+    CommonModule,
+    FormsModule,
+    IonHeader,
+    IonToolbar,
+    IonTitle,
+    IonContent,
+    IonCard,
+    IonCardContent,
+    IonButton,
+    IonCardHeader,
+    IonCardTitle,
+    IonCardSubtitle,
+    IonInput,
+    IonItem,
+    IonSegment,
+    IonSegmentButton,
+    IonLabel
+  ]
 })
 export class ModalUserEditComponent  implements OnInit {
 
@@ -49,18 +66,10 @@ export class ModalUserEditComponent  implements OnInit {
   }
 }
 
-export async function openUserEditModal(modalCtrl:ModalController):Promise<CloudUser|null>{
-  const modal = await modalCtrl.create({
-    component: ModalUserEditComponent,
-    breakpoints:[0.7,1.0],
-    initialBreakpoint:0.7
+export async function openUserEditModal(modalController: ModalController) {
+  const modal = await modalController.create({
+    component: ModalUserEditComponent
   });
-  modal.present();
-
-  const { data, role } = await modal.onWillDismiss();
-
-  if (role === 'confirm') {
-    return data;
-  }
-  return null
+  await modal.present();
+  return modal.onDidDismiss();
 }

src/lib/user/modal-user-login/modal-user-login.component.ts

@@ -1,7 +1,13 @@
-import { Input, OnInit } from '@angular/core';
 import { Component } from '@angular/core';
-import { IonHeader, IonToolbar, IonTitle, IonContent, IonCard, IonCardContent, IonButton, IonCardHeader, IonCardTitle, IonCardSubtitle, ModalController, IonInput, IonItem, IonSegment, IonSegmentButton, IonLabel, AlertController } from '@ionic/angular/standalone';
+import { IonContent, IonHeader, IonToolbar, IonTitle, IonButtons, IonButton, 
+         IonItem, IonLabel, IonInput, IonSegment, IonSegmentButton,
+         IonCard, IonCardHeader, IonCardTitle, IonCardSubtitle, 
+         IonCardContent } from '@ionic/angular/standalone';
+import { ModalController, AlertController } from '@ionic/angular/standalone';
+import { FormsModule } from '@angular/forms';
+import { CommonModule } from '@angular/common';
 import { CloudUser } from '../../ncloud';
+import * as Parse from 'parse';
 
 @Component({
   selector: 'app-modal-user-login',
@@ -9,50 +15,51 @@ import { CloudUser } from '../../ncloud';
   styleUrls: ['./modal-user-login.component.scss'],
   standalone: true,
   imports: [
-    IonHeader, IonToolbar, IonTitle, IonContent, 
-    IonCard, IonCardContent, IonButton, IonCardHeader, IonCardTitle, IonCardSubtitle,
-    IonInput, IonItem, IonSegment, IonSegmentButton, IonLabel
-  ],
+    CommonModule,
+    FormsModule,
+    IonContent,
+    IonHeader,
+    IonToolbar,
+    IonTitle,
+    IonButtons,
+    IonButton,
+    IonItem,
+    IonLabel,
+    IonInput,
+    IonSegment,
+    IonSegmentButton,
+    IonCard,
+    IonCardHeader,
+    IonCardTitle,
+    IonCardSubtitle,
+    IonCardContent
+  ]
 })
-export class ModalUserLoginComponent implements OnInit {
-  @Input()
-  type: "login"|"signup" = "login"
-  
-  typeChange(ev: any) {
-    this.type = ev?.detail?.value || ev?.value || 'login'
-  }
-  
-  username: string = ""
-  usernameChange(ev: any) {
-    this.username = ev?.detail?.value
-  }
-  
-  password: string = ""
-  passwordChange(ev: any) {
-    this.password = ev?.detail?.value
-  }
-  
-  password2: string = ""
-  password2Change(ev: any) {
-    this.password2 = ev?.detail?.value
-  }
-  
+export class ModalUserLoginComponent {
+  username: string = '';
+  password: string = '';
+  password2: string = '';
+  type: 'login' | 'signup' = 'login';
+
   constructor(
     private modalCtrl: ModalController,
-    private alertCtrl: AlertController
-  ) {
-    console.log(this.type)
+    private alertController: AlertController
+  ) {}
+
+  typeChange(event: any) {
+    this.type = event.detail.value;
   }
 
-  ngOnInit() {}
+  usernameChange(event: any) {
+    this.username = event.detail.value;
+  }
 
-  async showAlert(header: string, message: string) {
-    const alert = await this.alertCtrl.create({
-      header,
-      message,
-      buttons: ['确定']
-    });
-    await alert.present();
+  passwordChange(event: any) {
+    this.password = event.detail.value;
+  }
+
+  password2Change(event: any) {
+    this.password2 = event.detail.value;
   }
 
   async login() {
@@ -61,66 +68,63 @@ export class ModalUserLoginComponent implements OnInit {
       return;
     }
 
-    let user: any = new CloudUser();
     try {
-      user = await user.login(this.username, this.password);
-      if (user?.id) {
-        this.modalCtrl.dismiss(user, "confirm");
-        console.log("登录成功");
+      const user = await Parse.User.logIn(this.username, this.password);
+      if (user) {
+        await Parse.User.become(user.getSessionToken());
+        const cloudUser = new CloudUser();
+        cloudUser.setParseObject(user);
+        this.modalCtrl.dismiss(cloudUser, "confirm");
       } else {
         await this.showAlert('登录失败', '用户名或密码错误');
       }
     } catch (error) {
+      console.error("Login error:", error);
       await this.showAlert('错误', '登录过程中发生错误，请稍后重试');
     }
   }
 
   async signup() {
     if (!this.username || !this.password || !this.password2) {
-      await this.showAlert('提示', '请填写完整的注册信息');
+      await this.showAlert('提示', '请输入完整信息');
       return;
     }
-    
-    if (this.password != this.password2) {
-      await this.showAlert('提示', '两次输入的密码不一致，请重新输入');
+
+    if (this.password !== this.password2) {
+      await this.showAlert('提示', '两次输入的密码不一致');
       return;
     }
 
     try {
-      let user: any = new CloudUser();
-      user = await user.signUp(this.username, this.password);
-      if (user) {
-        await this.showAlert('成功', '注册成功，请登录');
-        this.type = "login";
-        console.log("注册成功请登录");
-      } else {
-        await this.showAlert('注册失败', '注册失败，请稍后重试');
-      }
-    } catch (error: any) {
-      let message = '注册过程中发生错误，请稍后重试';
-      if (error.code === 202) {
-        message = '用户名已存在，请更换用户名';
-      }
-      await this.showAlert('错误', message);
+      const user = new Parse.User();
+      user.set("username", this.username);
+      user.set("password", this.password);
+
+      await user.signUp();
+      const cloudUser = new CloudUser();
+      cloudUser.setParseObject(user);
+      this.modalCtrl.dismiss(cloudUser, "confirm");
+    } catch (error) {
+      console.error("Signup error:", error);
+      await this.showAlert('错误', '注册失败，请稍后重试');
     }
   }
+
+  private async showAlert(header: string, message: string) {
+    const alert = await this.alertController.create({
+      header,
+      message,
+      buttons: ['确定']
+    });
+    await alert.present();
+  }
 }
 
-export async function openUserLoginModal(modalCtrl: ModalController, type: "login"|"signup" = "login"): Promise<CloudUser|null> {
-  const modal = await modalCtrl.create({
-    component: ModalUserLoginComponent,
-    componentProps: {
-      type: type
-    },
-    breakpoints: [0.5, 0.7],
-    initialBreakpoint: 0.5
+// 导出打开模态框的函数
+export async function openUserLoginModal(modalController: ModalController) {
+  const modal = await modalController.create({
+    component: ModalUserLoginComponent
   });
-  modal.present();
-
-  const { data, role } = await modal.onWillDismiss();
-
-  if (role === 'confirm') {
-    return data;
-  }
-  return null;
+  await modal.present();
+  return modal.onDidDismiss();
 }

src/models/Task.ts

@@ -1,86 +0,0 @@
-import Parse from 'parse';
-
-export class Task {
-  id?: string;
-  title: string = '';
-  content: string = '';
-  startTime?: Date;
-  endTime?: Date;
-  completed: boolean = false;
-  userId?: string;
-
-  constructor(data?: any) {
-    if (data) {
-      this.id = data.id || data.objectId;
-      this.title = data.title || '';
-      this.content = data.content || '';
-      this.startTime = data.startTime ? new Date(data.startTime) : undefined;
-      this.endTime = data.endTime ? new Date(data.endTime) : undefined;
-      this.completed = data.completed || false;
-      this.userId = data.userId;
-    }
-  }
-
-  static async create(data: any) {
-    const currentUser = Parse.User.current();
-    console.log('Current user:', currentUser);
-    console.log('Session token:', currentUser?.getSessionToken());
-
-    if (!currentUser) {
-      throw new Error('No user logged in');
-    }
-
-    const task = new Parse.Object('Task');
-    const acl = new Parse.ACL();
-    
-    // 设置该任务的访问控制
-    acl.setPublicReadAccess(false);
-    acl.setPublicWriteAccess(false);
-    acl.setReadAccess(currentUser.id, true);
-    acl.setWriteAccess(currentUser.id, true);
-    
-    task.setACL(acl);
-    
-    // 设置任务数据
-    Object.keys(data).forEach(key => {
-      task.set(key, data[key]);
-    });
-
-    // 设置用户关联
-    task.set('user', currentUser);
-
-    try {
-      const savedTask = await task.save();
-      console.log('Task saved successfully:', savedTask);
-      return savedTask;
-    } catch (error) {
-      console.error('Failed to create task:', error);
-      throw error;
-    }
-  }
-
-  static async getUserTasks(userId: string) {
-    const query = new Parse.Query('Task');
-    query.equalTo('userId', userId);
-    query.descending('createdAt');
-    
-    try {
-      const results = await query.find();
-      return results.map(task => new Task({
-        id: task.id,
-        ...task.toJSON()
-      }));
-    } catch (error) {
-      console.error('Error fetching tasks:', error);
-      throw error;
-    }
-  }
-
-  async save() {
-    if (!this.id) return;
-    const task = new Parse.Object('Task');
-    task.id = this.id;
-    task.set('completed', this.completed);
-    await task.save();
-  }
-}