diff --git a/.reuse/dep5 b/.reuse/dep5
index 76c2567e4..84ebf5d88 100644
--- a/.reuse/dep5
+++ b/.reuse/dep5
@@ -14,7 +14,7 @@ Copyright: UnionTech Software Technology Co., Ltd.
 License: GPL-3.0-or-later
 
 # Project file 
-Files: *.pro *.prf *.pri *.txt *.cmake
+Files: *.pro *.prf *.pri *.txt *.cmake *CMakeLists.txt .tx/*
 Copyright: None
 License: CC0-1.0
 
diff --git a/calendar-common/src/compatibledata.cpp b/calendar-common/src/compatibledata.cpp
index 956976e3f..f277d641e 100644
--- a/calendar-common/src/compatibledata.cpp
+++ b/calendar-common/src/compatibledata.cpp
@@ -5,6 +5,7 @@
 #include "compatibledata.h"
 #include "units.h"
 #include "icalformat.h"
+#include "commondef.h"
 
 #include <QJsonObject>
 #include <QJsonDocument>
@@ -22,6 +23,7 @@ const QMap<int, QString> mTypeMap {{1, "107c369e-b13a-4d45-9ff3-de4eb3c0475b"},
  */
 QJsonObject JobToObject(const DSchedule::Ptr &job)
 {
+    // qCDebug(CommonLogger) << "JobToObject, job summary:" << (job ? job->summary() : "null");
     QJsonObject obj;
 
     obj.insert("ID", job->compatibleID());
@@ -48,15 +50,18 @@ QJsonObject JobToObject(const DSchedule::Ptr &job)
 
 QString DDE_Calendar::getNewTypeIDByOldTypeID(int oldTypeID)
 {
+    qCDebug(CommonLogger) << "DDE_Calendar::getNewTypeIDByOldTypeID, oldTypeID:" << oldTypeID;
     if (mTypeMap.contains(oldTypeID)) {
         return mTypeMap.value(oldTypeID);
     } else {
+        qCWarning(CommonLogger) << "Old type ID not found, returning default";
         return mTypeMap.value(3);
     }
 }
 
 int DDE_Calendar::getOldTypeIDByNewTypeID(const QString &newTypeID)
 {
+    qCDebug(CommonLogger) << "DDE_Calendar::getOldTypeIDByNewTypeID, newTypeID:" << newTypeID;
     int oldTypeID = 0;
     QMap<int, QString>::const_iterator constIter = mTypeMap.constBegin();
 
@@ -66,11 +71,13 @@ int DDE_Calendar::getOldTypeIDByNewTypeID(const QString &newTypeID)
             break;
         }
     }
+    qCDebug(CommonLogger) << "DDE_Calendar::getOldTypeIDByNewTypeID, oldTypeID:" << oldTypeID;
     return oldTypeID == 0 ? 3 : oldTypeID;
 }
 
 QString DDE_Calendar::getExternalSchedule(const DSchedule::Map &scheduleMap)
 {
+    qCDebug(CommonLogger) << "DDE_Calendar::getExternalSchedule, map size:" << scheduleMap.size();
     QString strJson;
     QJsonDocument doc;
     QJsonArray jsonarr;
@@ -94,6 +101,7 @@ QString DDE_Calendar::getExternalSchedule(const DSchedule::Map &scheduleMap)
 
 void DDE_Calendar::setAlarmByOldRemind(const DSchedule::Ptr &schedule, const QString &remind)
 {
+    qCDebug(CommonLogger) << "DDE_Calendar::setAlarmByOldRemind, remind:" << remind;
     //提醒规则
     QStringList strList = remind.split(";", Qt::SkipEmptyParts);
 
@@ -106,6 +114,7 @@ void DDE_Calendar::setAlarmByOldRemind(const DSchedule::Ptr &schedule, const QSt
         alarm->setDisplayAlarm(schedule->summary());
 
         if (schedule->allDay()) {
+            qCDebug(CommonLogger) << "Setting alarm for all-day event";
             //提前多少秒
             int offset = 0;
             if (strList.size() > 1) {
@@ -115,6 +124,7 @@ void DDE_Calendar::setAlarmByOldRemind(const DSchedule::Ptr &schedule, const QSt
             KCalendarCore::Duration duration(-(24 * 60 * 60 * remindNum - offset));
             alarm->setStartOffset(duration);
         } else {
+            qCDebug(CommonLogger) << "Setting alarm for timed event";
             KCalendarCore::Duration duration(-(60 * remindNum));
             alarm->setStartOffset(duration);
         }
@@ -124,6 +134,7 @@ void DDE_Calendar::setAlarmByOldRemind(const DSchedule::Ptr &schedule, const QSt
 
 QString DDE_Calendar::getOldRemindByAlarm(const DSchedule::AlarmType &alarmType)
 {
+    qCDebug(CommonLogger) << "DDE_Calendar::getOldRemindByAlarm, alarmType:" << alarmType;
     QString _resultStr {""};
     switch (alarmType) {
     case DSchedule::Alarm_Begin:
@@ -171,10 +182,12 @@ QString DDE_Calendar::getOldRemindByAlarm(const DSchedule::AlarmType &alarmType)
 
 DSchedule::Ptr DDE_Calendar::getScheduleByExported(const QString &scheduleStr)
 {
+    qCDebug(CommonLogger) << "DDE_Calendar::getScheduleByExported";
     QJsonParseError json_error;
     QJsonDocument jsonDoc(QJsonDocument::fromJson(scheduleStr.toLocal8Bit(), &json_error));
 
     if (json_error.error != QJsonParseError::NoError) {
+        qCWarning(CommonLogger) << "JSON parse error:" << json_error.errorString();
         return nullptr;
     }
     QJsonObject rootObj = jsonDoc.object();
@@ -225,6 +238,7 @@ DSchedule::Ptr DDE_Calendar::getScheduleByExported(const QString &scheduleStr)
 
 void DDE_Calendar::setRRuleByOldRRule(const DSchedule::Ptr &schedule, const QString &rrule)
 {
+    qCDebug(CommonLogger) << "DDE_Calendar::setRRuleByOldRRule, rrule:" << rrule;
     //重复规则
     KCalendarCore::Recurrence *recurrence = schedule->recurrence();
     KCalendarCore::ICalFormat ical;
@@ -237,6 +251,7 @@ void DDE_Calendar::setRRuleByOldRRule(const DSchedule::Ptr &schedule, const QStr
 
 void DDE_Calendar::setExDate(const DSchedule::Ptr &schedule, const QJsonArray &ignore)
 {
+    qCDebug(CommonLogger) << "DDE_Calendar::setExDate, ignore count:" << ignore.size();
     KCalendarCore::Recurrence *recurrence = schedule->recurrence();
 
     foreach (auto ignoreTime, ignore) {
diff --git a/calendar-common/src/daccount.cpp b/calendar-common/src/daccount.cpp
index cdb3bbf73..dc7126c08 100644
--- a/calendar-common/src/daccount.cpp
+++ b/calendar-common/src/daccount.cpp
@@ -28,156 +28,176 @@ DAccount::DAccount(DAccount::Type type)
     , m_intervalTime(0)
     , m_isExpandDisplay(true)
 {
+    qCDebug(CommonLogger) << "DAccount::DAccount, type:" << type;
 }
 
 QString DAccount::displayName() const
 {
+    // qCDebug(CommonLogger) << "DAccount::displayName";
     return m_displayName;
 }
 
 void DAccount::setDisplayName(const QString &displayName)
 {
-    qCDebug(ServiceLogger) << "Setting display name for account" << m_accountID << "from" << m_displayName << "to" << displayName;
+    // qCDebug(CommonLogger) << "Setting display name for account" << m_accountID << "from" << m_displayName << "to" << displayName;
     m_displayName = displayName;
 }
 
 QString DAccount::accountID() const
 {
+    // qCDebug(CommonLogger) << "DAccount::accountID";
     return m_accountID;
 }
 
 void DAccount::setAccountID(const QString &accountID)
 {
-    qCDebug(ServiceLogger) << "Setting account ID from" << m_accountID << "to" << accountID;
+    qCDebug(CommonLogger) << "Setting account ID from" << m_accountID << "to" << accountID;
     m_accountID = accountID;
 }
 
 QString DAccount::accountName() const
 {
+    // qCDebug(CommonLogger) << "DAccount::accountName";
     return m_accountName;
 }
 
 void DAccount::setAccountName(const QString &accountName)
 {
-    qCDebug(ServiceLogger) << "Setting account name for" << m_accountID << "from" << m_accountName << "to" << accountName;
+    // qCDebug(CommonLogger) << "Setting account name for" << m_accountID << "from" << m_accountName << "to" << accountName;
     m_accountName = accountName;
 }
 
 QString DAccount::dbusPath() const
 {
+    // qCDebug(CommonLogger) << "DAccount::dbusPath";
     return m_dbusPath;
 }
 
 void DAccount::setDbusPath(const QString &dbusPath)
 {
-    qCDebug(ServiceLogger) << "Setting DBus path for account" << m_accountID << "from" << m_dbusPath << "to" << dbusPath;
+    // qCDebug(CommonLogger) << "Setting DBus path for account" << m_accountID << "from" << m_dbusPath << "to" << dbusPath;
     m_dbusPath = dbusPath;
 }
 
 DAccount::Type DAccount::accountType() const
 {
+    // qCDebug(CommonLogger) << "DAccount::accountType";
     return m_accountType;
 }
 
 void DAccount::setAccountType(const Type &accountType)
 {
+    // qCDebug(CommonLogger) << "DAccount::setAccountType, accountType:" << accountType;
     m_accountType = accountType;
 }
 
 bool DAccount::isExpandDisplay() const
 {
+    // qCDebug(CommonLogger) << "DAccount::isExpandDisplay";
     return m_isExpandDisplay;
 }
 
 void DAccount::setIsExpandDisplay(bool isExpandDisplay)
 {
+    // qCDebug(CommonLogger) << "DAccount::setIsExpandDisplay, isExpandDisplay:" << isExpandDisplay;
     m_isExpandDisplay = isExpandDisplay;
 }
 
 bool DAccount::isNetWorkAccount()
 {
+    // qCDebug(CommonLogger) << "DAccount::isNetWorkAccount";
     return m_accountType != Type::Account_Local;
 }
 
 int DAccount::syncTag() const
 {
+    // qCDebug(CommonLogger) << "DAccount::syncTag";
     return m_syncTag;
 }
 
 void DAccount::setSyncTag(int syncTag)
 {
+    // qCDebug(CommonLogger) << "DAccount::setSyncTag, syncTag:" << syncTag;
     m_syncTag = syncTag;
 }
 
 DAccount::AccountSyncState DAccount::syncState() const
 {
+    // qCDebug(CommonLogger) << "DAccount::syncState";
     return m_syncState;
 }
 
 void DAccount::setSyncState(AccountSyncState syncState)
 {
+    // qCDebug(CommonLogger) << "DAccount::setSyncState, syncState:" << syncState;
     m_syncState = syncState;
 }
 
 QString DAccount::avatar() const
 {
+    // qCDebug(CommonLogger) << "DAccount::avatar";
     return m_avatar;
 }
 
 void DAccount::setAvatar(const QString &avatar)
 {
-    qCDebug(ServiceLogger) << "Setting avatar for account" << m_accountID;
+    // qCDebug(CommonLogger) << "Setting avatar for account" << m_accountID;
     m_avatar = avatar;
 }
 
 QString DAccount::description() const
 {
+    // qCDebug(CommonLogger) << "DAccount::description";
     return m_description;
 }
 
 void DAccount::setDescription(const QString &description)
 {
-    qCDebug(ServiceLogger) << "Setting description for account" << m_accountID;
+    // qCDebug(CommonLogger) << "Setting description for account" << m_accountID;
     m_description = description;
 }
 
 QDateTime DAccount::dtCreate() const
 {
+    // qCDebug(CommonLogger) << "DAccount::dtCreate";
     return m_dtCreate;
 }
 
 void DAccount::setDtCreate(const QDateTime &dtCreate)
 {
-    qCDebug(ServiceLogger) << "Setting creation time for account" << m_accountID << "to" << dtCreate.toString();
+    // qCDebug(CommonLogger) << "Setting creation time for account" << m_accountID << "to" << dtCreate.toString();
     m_dtCreate = dtCreate;
 }
 
 QDateTime DAccount::dtDelete() const
 {
+    // qCDebug(CommonLogger) << "DAccount::dtDelete";
     return m_dtDelete;
 }
 
 void DAccount::setDtDelete(const QDateTime &dtDelete)
 {
-    qCDebug(ServiceLogger) << "Setting deletion time for account" << m_accountID << "to" << dtDelete.toString();
+    // qCDebug(CommonLogger) << "DAccount::setDtDelete, dtDelete:" << dtDelete;
     m_dtDelete = dtDelete;
 }
 
 QDateTime DAccount::dtUpdate() const
 {
+    // qCDebug(CommonLogger) << "DAccount::dtUpdate";
     return m_dtUpdate;
 }
 
 void DAccount::setDtUpdate(const QDateTime &dtUpdate)
 {
-    qCDebug(ServiceLogger) << "Setting update time for account" << m_accountID << "to" << dtUpdate.toString();
+    // qCDebug(CommonLogger) << "DAccount::setDtUpdate, dtUpdate:" << dtUpdate;
     m_dtUpdate = dtUpdate;
 }
 
 bool DAccount::toJsonString(const DAccount::Ptr &account, QString &jsonStr)
 {
+    // qCDebug(CommonLogger) << "DAccount::toJsonString";
     if (account.isNull()) {
-        qCWarning(ServiceLogger) << "Cannot convert null account to JSON";
+        qCWarning(CommonLogger) << "Cannot convert null account to JSON";
         return false;
     }
     QJsonObject rootObj;
@@ -205,15 +225,16 @@ bool DAccount::toJsonString(const DAccount::Ptr &account, QString &jsonStr)
 
 bool DAccount::fromJsonString(Ptr &account, const QString &jsonStr)
 {
+    qCDebug(CommonLogger) << "DAccount::fromJsonString";
     if (account.isNull()) {
-        qCDebug(ServiceLogger) << "Creating new account instance for JSON parsing";
+        qCDebug(CommonLogger) << "Creating new account instance for JSON parsing";
         account = DAccount::Ptr(new DAccount);
     }
 
     QJsonParseError jsonError;
     QJsonDocument jsonDoc(QJsonDocument::fromJson(jsonStr.toLocal8Bit(), &jsonError));
     if (jsonError.error != QJsonParseError::NoError) {
-        qCWarning(ServiceLogger) << "Failed to parse account JSON. Error:" << jsonError.errorString();
+        qCWarning(CommonLogger) << "Failed to parse account JSON. Error:" << jsonError.errorString();
         return false;
     }
     QJsonObject rootObj = jsonDoc.object();
@@ -273,6 +294,7 @@ bool DAccount::fromJsonString(Ptr &account, const QString &jsonStr)
 
 bool DAccount::toJsonListString(const DAccount::List &accountList, QString &jsonStr)
 {
+    qCDebug(CommonLogger) << "DAccount::toJsonListString, list size:" << accountList.size();
     QJsonArray jsArr;
     foreach (auto account, accountList) {
         QJsonObject jsonAccount;
@@ -291,10 +313,11 @@ bool DAccount::toJsonListString(const DAccount::List &accountList, QString &json
 
 bool DAccount::fromJsonListString(List &accountList, const QString &jsonStr)
 {
+    qCDebug(CommonLogger) << "DAccount::fromJsonListString";
     QJsonParseError jsonError;
     QJsonDocument jsonDoc(QJsonDocument::fromJson(jsonStr.toLocal8Bit(), &jsonError));
     if (jsonError.error != QJsonParseError::NoError) {
-        qCWarning(ServiceLogger) << "Failed to parse account list JSON. Error:" << jsonError.errorString();
+        qCWarning(CommonLogger) << "Failed to parse account list JSON. Error:" << jsonError.errorString();
         return false;
     }
 
@@ -308,7 +331,7 @@ bool DAccount::fromJsonListString(List &accountList, const QString &jsonStr)
             if (fromJsonString(account, strAcc)) {
                 accountList.append(account);
             } else {
-                qCWarning(ServiceLogger) << "Failed to parse account JSON:" << strAcc;
+                qCWarning(CommonLogger) << "Failed to parse account JSON:" << strAcc;
             }
         }
     }
@@ -317,79 +340,91 @@ bool DAccount::fromJsonListString(List &accountList, const QString &jsonStr)
 
 QString DAccount::dbName() const
 {
+    // qCDebug(CommonLogger) << "DAccount::dbName";
     return m_dbName;
 }
 
 void DAccount::setDbName(const QString &dbName)
 {
-    qCDebug(ServiceLogger) << "Setting database name for account" << m_accountID << "from" << m_dbName << "to" << dbName;
+    // qCDebug(CommonLogger) << "Setting database name for account" << m_accountID << "from" << m_dbName << "to" << dbName;
     m_dbName = dbName;
 }
 
 QString DAccount::cloudPath() const
 {
+    // qCDebug(CommonLogger) << "DAccount::cloudPath";
     return m_cloudPath;
 }
 
 void DAccount::setCloudPath(const QString &cloudPath)
 {
-    qCDebug(ServiceLogger) << "Setting cloud path for account" << m_accountID << "from" << m_cloudPath << "to" << cloudPath;
+    // qCDebug(CommonLogger) << "Setting cloud path for account" << m_accountID << "from" << m_cloudPath << "to" << cloudPath;
     m_cloudPath = cloudPath;
 }
 
 DAccount::SyncFreqType DAccount::syncFreq() const
 {
+    // qCDebug(CommonLogger) << "DAccount::syncFreq";
     return m_syncFreq;
 }
 
 void DAccount::setSyncFreq(SyncFreqType syncFreq)
 {
+    // qCDebug(CommonLogger) << "DAccount::setSyncFreq, syncFreq:" << syncFreq;
     m_syncFreq = syncFreq;
 }
 
 int DAccount::intervalTime() const
 {
+    // qCDebug(CommonLogger) << "DAccount::intervalTime";
     return m_intervalTime;
 }
 
 void DAccount::setIntervalTime(int intervalTime)
 {
+    // qCDebug(CommonLogger) << "DAccount::setIntervalTime, intervalTime:" << intervalTime;
     m_intervalTime = intervalTime;
 }
 
 QString DAccount::dbusInterface() const
 {
+    // qCDebug(CommonLogger) << "DAccount::dbusInterface";
     return m_dbusInterface;
 }
 
 void DAccount::setDbusInterface(const QString &dbusInterface)
 {
+    qCDebug(CommonLogger) << "DAccount::setDbusInterface, dbusInterface:" << dbusInterface;
     m_dbusInterface = dbusInterface;
 }
 
 DAccount::AccountStates DAccount::accountState() const
 {
+    // qCDebug(CommonLogger) << "DAccount::accountState";
     return m_accountState;
 }
 
 void DAccount::setAccountState(const AccountStates &accountState)
 {
+    qCDebug(CommonLogger) << "DAccount::setAccountState, accountState:" << accountState;
     m_accountState = accountState;
 }
 
 QDateTime DAccount::dtLastSync() const
 {
+    // qCDebug(CommonLogger) << "DAccount::dtLastSync";
     return m_dtLastSync;
 }
 
 void DAccount::setDtLastSync(const QDateTime &dtLastSync)
 {
-    qCDebug(ServiceLogger) << "Setting last sync time for account" << m_accountID << "to" << dtLastSync.toString();
+    // qCDebug(CommonLogger) << "DAccount::setDtLastSync, dtLastSync:" << dtLastSync;
     m_dtLastSync = dtLastSync;
 }
 
 QString DAccount::syncFreqToJsonString(const DAccount::Ptr &account)
 {
+    qCDebug(CommonLogger) << "DAccount::syncFreqToJsonString";
     QJsonObject rootObj;
     rootObj.insert("syncFreq", account->syncFreq());
     rootObj.insert("m_intervalTime", account->intervalTime());
@@ -400,10 +435,11 @@ QString DAccount::syncFreqToJsonString(const DAccount::Ptr &account)
 
 void DAccount::syncFreqFromJsonString(const DAccount::Ptr &account, const QString &syncFreqStr)
 {
+    qCDebug(CommonLogger) << "DAccount::syncFreqFromJsonString";
     QJsonParseError jsonError;
     QJsonDocument jsonDoc(QJsonDocument::fromJson(syncFreqStr.toLocal8Bit(), &jsonError));
     if (jsonError.error != QJsonParseError::NoError) {
-        qCWarning(ServiceLogger) << "Failed to parse sync frequency JSON. Error:" << jsonError.errorString();
+        qCWarning(CommonLogger) << "Failed to parse sync frequency JSON. Error:" << jsonError.errorString();
         return;
     }
 
diff --git a/calendar-common/src/dbustimedate.cpp b/calendar-common/src/dbustimedate.cpp
index 4a255773d..a6da8ec31 100644
--- a/calendar-common/src/dbustimedate.cpp
+++ b/calendar-common/src/dbustimedate.cpp
@@ -48,13 +48,14 @@ inline const char *getTimedateInterface()
 DBusTimedate::DBusTimedate(QObject *parent)
     : QDBusAbstractInterface(NETWORK_DBUS_NAME, NETWORK_DBUS_PATH, NETWORK_DBUS_INTEERFACENAME, QDBusConnection::sessionBus(), parent)
 {
+    qCDebug(CommonLogger) << "DBusTimedate::DBusTimedate";
     //关联后端dbus触发信号
     if (!QDBusConnection::sessionBus().connect(NETWORK_DBUS_NAME,
                                                NETWORK_DBUS_PATH,
                                                "org.freedesktop.DBus.Properties",
                                                QLatin1String("PropertiesChanged"), this,
                                                SLOT(propertiesChanged(QDBusMessage)))) {
-        qCWarning(ServiceLogger) << "Failed to connect to PropertiesChanged signal:" << this->lastError().message();
+        qCWarning(CommonLogger) << "Failed to connect to PropertiesChanged signal:" << this->lastError().message();
     }
 
     m_hasDateTimeFormat = getHasDateTimeFormat();
@@ -62,18 +63,21 @@ DBusTimedate::DBusTimedate(QObject *parent)
 
 int DBusTimedate::shortTimeFormat()
 {
+    qCDebug(CommonLogger) << "DBusTimedate::shortTimeFormat";
     //如果存在对应的时间设置则获取，否则默认为4
     return m_hasDateTimeFormat ? getPropertyByName("ShortTimeFormat").toInt() : 4;
 }
 
 int DBusTimedate::shortDateFormat()
 {
+    qCDebug(CommonLogger) << "DBusTimedate::shortDateFormat";
     //如果存在对应的时间设置则获取，否则默认为1
     return m_hasDateTimeFormat ? getPropertyByName("ShortDateFormat").toInt() : 1;
 }
 
 Qt::DayOfWeek DBusTimedate::weekBegins()
 {
+    qCDebug(CommonLogger) << "DBusTimedate::weekBegins";
     if (m_hasDateTimeFormat) {
         // WeekBegins是从0开始的，加1才能对应DayOfWeek
         return Qt::DayOfWeek(getPropertyByName("WeekBegins").toInt() + 1);
@@ -83,16 +87,17 @@ Qt::DayOfWeek DBusTimedate::weekBegins()
 
 void DBusTimedate::propertiesChanged(const QDBusMessage &msg)
 {
+    qCDebug(CommonLogger) << "DBusTimedate::propertiesChanged";
     QList<QVariant> arguments = msg.arguments();
     // 参数固定长度
     if (3 != arguments.count()) {
-        qCWarning(ServiceLogger) << "Invalid number of arguments in PropertiesChanged signal:" << arguments.count();
+        qCWarning(CommonLogger) << "Invalid number of arguments in PropertiesChanged signal:" << arguments.count();
         return;
     }
 
     QString interfaceName = msg.arguments().at(0).toString();
     if (interfaceName != this->interface()) {
-        qCDebug(ServiceLogger) << "Ignoring PropertiesChanged for interface:" << interfaceName;
+        qCDebug(CommonLogger) << "Ignoring PropertiesChanged for interface:" << interfaceName;
         return;
     }
 
@@ -100,8 +105,10 @@ void DBusTimedate::propertiesChanged(const QDBusMessage &msg)
     QStringList keys = changedProps.keys();
     foreach (const QString &prop, keys) {
         if (prop == "ShortTimeFormat") {
+            qCDebug(CommonLogger) << "ShortTimeFormat changed";
             emit ShortTimeFormatChanged(changedProps[prop].toInt());
         } else if (prop == "ShortDateFormat") {
+            qCDebug(CommonLogger) << "ShortDateFormat changed";
             emit ShortDateFormatChanged(changedProps[prop].toInt());
         }
     }
@@ -109,12 +116,14 @@ void DBusTimedate::propertiesChanged(const QDBusMessage &msg)
 
 QVariant DBusTimedate::getPropertyByName(const char *porpertyName)
 {
+    qCDebug(CommonLogger) << "DBusTimedate::getPropertyByName, propertyName:" << porpertyName;
     QDBusInterface dbusinterface(this->service(), this->path(), this->interface(), QDBusConnection::sessionBus(), this);
     return dbusinterface.property(porpertyName);
 }
 
 bool DBusTimedate::getHasDateTimeFormat()
 {
+    qCDebug(CommonLogger) << "DBusTimedate::getHasDateTimeFormat";
     QDBusMessage msg = QDBusMessage::createMethodCall(NETWORK_DBUS_NAME,
                                                       NETWORK_DBUS_PATH,
                                                       "org.freedesktop.DBus.Introspectable",
@@ -126,7 +135,7 @@ bool DBusTimedate::getHasDateTimeFormat()
         QVariant variant = reply.arguments().first();
         return variant.toString().contains("\"ShortDateFormat\"");
     } else {
-        qCWarning(ServiceLogger) << "Failed to check DateTime format support:" << reply.errorMessage();
+        qCWarning(CommonLogger) << "Failed to check DateTime format support:" << reply.errorMessage();
         return false;
     }
 }
diff --git a/calendar-common/src/dcalendargeneralsettings.cpp b/calendar-common/src/dcalendargeneralsettings.cpp
index 71a74fd7d..dd57cf147 100644
--- a/calendar-common/src/dcalendargeneralsettings.cpp
+++ b/calendar-common/src/dcalendargeneralsettings.cpp
@@ -14,41 +14,49 @@ DCalendarGeneralSettings::DCalendarGeneralSettings()
     : m_firstDayOfWeek(Qt::Sunday)
     , m_timeShowType(TwentyFour)
 {
+    qCDebug(CommonLogger) << "DCalendarGeneralSettings::DCalendarGeneralSettings (default)";
 }
 
 DCalendarGeneralSettings::DCalendarGeneralSettings(const DCalendarGeneralSettings &setting)
     : m_firstDayOfWeek(setting.firstDayOfWeek())
     , m_timeShowType(setting.timeShowType())
 {
+    qCDebug(CommonLogger) << "DCalendarGeneralSettings::DCalendarGeneralSettings (copy)";
 }
 
 DCalendarGeneralSettings *DCalendarGeneralSettings::clone() const
 {
+    // qCDebug(CommonLogger) << "DCalendarGeneralSettings::clone";
     return new DCalendarGeneralSettings(*this);
 }
 
 Qt::DayOfWeek DCalendarGeneralSettings::firstDayOfWeek() const
 {
+    // qCDebug(CommonLogger) << "DCalendarGeneralSettings::firstDayOfWeek";
     return m_firstDayOfWeek;
 }
 
 void DCalendarGeneralSettings::setFirstDayOfWeek(const Qt::DayOfWeek &firstDayOfWeek)
 {
+    // qCDebug(CommonLogger) << "DCalendarGeneralSettings::setFirstDayOfWeek, day:" << firstDayOfWeek;
     m_firstDayOfWeek = firstDayOfWeek;
 }
 
 DCalendarGeneralSettings::TimeShowType DCalendarGeneralSettings::timeShowType() const
 {
+    // qCDebug(CommonLogger) << "DCalendarGeneralSettings::timeShowType";
     return m_timeShowType;
 }
 
 void DCalendarGeneralSettings::setTimeShowType(const TimeShowType &timeShowType)
 {
+    // qCDebug(CommonLogger) << "DCalendarGeneralSettings::setTimeShowType, type:" << timeShowType;
     m_timeShowType = timeShowType;
 }
 
 void DCalendarGeneralSettings::toJsonString(const Ptr &cgSet, QString &jsonStr)
 {
+    qCDebug(CommonLogger) << "DCalendarGeneralSettings::toJsonString";
     QJsonObject rootObject;
     rootObject.insert("firstDayOfWeek", cgSet->firstDayOfWeek());
     rootObject.insert("TimeShowType", cgSet->timeShowType());
@@ -59,6 +67,7 @@ void DCalendarGeneralSettings::toJsonString(const Ptr &cgSet, QString &jsonStr)
 
 bool DCalendarGeneralSettings::fromJsonString(Ptr &cgSet, const QString &jsonStr)
 {
+    qCDebug(CommonLogger) << "DCalendarGeneralSettings::fromJsonString";
     QJsonParseError jsonError;
     QJsonDocument jsonDoc(QJsonDocument::fromJson(jsonStr.toLocal8Bit(), &jsonError));
     if (jsonError.error != QJsonParseError::NoError) {
@@ -68,10 +77,12 @@ bool DCalendarGeneralSettings::fromJsonString(Ptr &cgSet, const QString &jsonStr
 
     QJsonObject rootObj = jsonDoc.object();
     if (rootObj.contains("firstDayOfWeek")) {
+        qCDebug(CommonLogger) << "Setting first day of week to" << rootObj.value("firstDayOfWeek").toInt();
         cgSet->setFirstDayOfWeek(static_cast<Qt::DayOfWeek>(rootObj.value("firstDayOfWeek").toInt()));
     }
 
     if (rootObj.contains("TimeShowType")) {
+        qCDebug(CommonLogger) << "Setting time show type to" << rootObj.value("TimeShowType").toInt();
         cgSet->setTimeShowType(static_cast<TimeShowType>(rootObj.value("TimeShowType").toInt()));
     }
     return true;
diff --git a/calendar-common/src/dschedule.cpp b/calendar-common/src/dschedule.cpp
index ecda985dc..bab36331d 100644
--- a/calendar-common/src/dschedule.cpp
+++ b/calendar-common/src/dschedule.cpp
@@ -24,6 +24,7 @@ DSchedule::DSchedule()
     , m_scheduleTypeID("")
     , m_compatibleID(0)
 {
+    qCDebug(CommonLogger) << "DSchedule constructor called.";
 }
 
 DSchedule::DSchedule(const DSchedule &schedule)
@@ -32,6 +33,7 @@ DSchedule::DSchedule(const DSchedule &schedule)
     , m_scheduleTypeID("")
     , m_compatibleID(0)
 {
+    qCDebug(CommonLogger) << "DSchedule copy constructor called for schedule:" << schedule.summary();
     this->setScheduleTypeID(schedule.scheduleTypeID());
 }
 
@@ -41,52 +43,63 @@ DSchedule::DSchedule(const KCalendarCore::Event &event)
     , m_scheduleTypeID("")
     , m_compatibleID(0)
 {
+    qCDebug(CommonLogger) << "DSchedule constructor from KCalendarCore::Event called for event:" << event.summary();
 }
 
 DSchedule *DSchedule::clone() const
 {
+    // qCDebug(CommonLogger) << "Cloning DSchedule:" << summary();
     return new DSchedule(*this);
 }
 
 QString DSchedule::scheduleTypeID() const
 {
+    // qCDebug(CommonLogger) << "Getting scheduleTypeID:" << m_scheduleTypeID;
     return m_scheduleTypeID;
 }
 
 void DSchedule::setScheduleTypeID(const QString &typeID)
 {
+    // qCDebug(CommonLogger) << "Setting scheduleTypeID to:" << typeID;
     m_scheduleTypeID = typeID;
 }
 
 bool DSchedule::isMoved()
 {
+    // qCDebug(CommonLogger) << "Checking if schedule is moved:" << m_moved;
     return this->m_moved;
 }
 
 void DSchedule::setMoved(bool moved)
 {
+    // qCDebug(CommonLogger) << "Setting moved status to:" << moved;
     this->m_moved = moved;
 }
 
 bool DSchedule::isValid() const
 {
     //TODO:添加判断日程是否有效
+    // qCDebug(CommonLogger) << "Checking if schedule is valid.";
     return true;
 }
 
 bool DSchedule::isMultiDay() const
 {
     //如果日期不一致则为跨天日程
-    return dtStart().date() != dtEnd().date();
+    bool multiDay = dtStart().date() != dtEnd().date();
+    // qCDebug(CommonLogger) << "Checking if schedule is multi-day:" << multiDay;
+    return multiDay;
 }
 
 bool DSchedule::operator==(const DSchedule &schedule) const
 {
+    // qCDebug(CommonLogger) << "Comparing schedules with operator==";
     return this->instanceIdentifier() == schedule.instanceIdentifier();
 }
 
 bool operator<(const DSchedule::Ptr &s1, const DSchedule::Ptr &s2)
 {
+    // qCDebug(CommonLogger) << "Comparing DSchedule::Ptr with operator<";
     if (s1.isNull() || s2.isNull()) {
         return false;
     }
@@ -95,6 +108,7 @@ bool operator<(const DSchedule::Ptr &s1, const DSchedule::Ptr &s2)
 
 bool DSchedule::operator<(const DSchedule &schedule) const
 {
+    // qCDebug(CommonLogger) << "Comparing schedules with operator<";
     if (this->allDay() != schedule.allDay()) {
         return this->allDay() > schedule.allDay();
     }
@@ -112,9 +126,10 @@ bool DSchedule::operator<(const DSchedule &schedule) const
 
 void DSchedule::setAlarmType(const DSchedule::AlarmType &alarmType)
 {
+    // qCDebug(CommonLogger) << "Setting alarm type to:" << static_cast<int>(alarmType);
     //如果提醒规则没有变化则退出
     if (alarmType == getAlarmType()) {
-        qCDebug(ServiceLogger) << "Alarm type unchanged, skipping update";
+        qCDebug(CommonLogger) << "Alarm type unchanged, skipping update";
         return;
     }
 
@@ -122,7 +137,7 @@ void DSchedule::setAlarmType(const DSchedule::AlarmType &alarmType)
     this->clearAlarms();
     //如果为从不则退出
     if (alarmType == AlarmType::Alarm_None || alarmType == AlarmType::Alarm_AllDay_None) {
-        qCDebug(ServiceLogger) << "Setting alarm type to None, clearing all alarms";
+        qCDebug(CommonLogger) << "Setting alarm type to None, clearing all alarms";
         return;
     }
 
@@ -137,7 +152,7 @@ void DSchedule::setAlarmType(const DSchedule::AlarmType &alarmType)
             KCalendarCore::Duration duration(iter.key());
             alarm->setStartOffset(duration);
             addAlarm(alarm);
-            qCDebug(ServiceLogger) << "Added alarm with offset:" << iter.key() << "seconds";
+            qCDebug(CommonLogger) << "Added alarm with offset:" << iter.key() << "seconds";
             break;
         }
     }
@@ -145,6 +160,7 @@ void DSchedule::setAlarmType(const DSchedule::AlarmType &alarmType)
 
 DSchedule::AlarmType DSchedule::getAlarmType()
 {
+    // qCDebug(CommonLogger) << "Getting alarm type for schedule:" << summary();
     AlarmType alarmType = allDay() ? Alarm_AllDay_None : Alarm_None;
     KCalendarCore::Alarm::List alarmList = this->alarms();
     if (alarmList.size() > 0) {
@@ -154,13 +170,15 @@ DSchedule::AlarmType DSchedule::getAlarmType()
             alarmType = alarmMap[duration.asSeconds()];
         }
     }
+    // qCDebug(CommonLogger) << "Found alarm type:" << static_cast<int>(alarmType);
     return alarmType;
 }
 
 void DSchedule::setRRuleType(const DSchedule::RRuleType &rtype)
 {
+    // qCDebug(CommonLogger) << "Setting RRule type to:" << static_cast<int>(rtype);
     if (getRRuleType() == rtype) {
-        qCDebug(ServiceLogger) << "Recurrence rule type unchanged, skipping update";
+        qCDebug(CommonLogger) << "Recurrence rule type unchanged, skipping update";
         return;
     }
 
@@ -189,6 +207,7 @@ void DSchedule::setRRuleType(const DSchedule::RRuleType &rtype)
     }
 
     if (!rules.isEmpty()) {
+        // qCDebug(CommonLogger) << "Applying recurrence rule:" << rules;
         KCalendarCore::Recurrence *recurrence = this->recurrence();
         KCalendarCore::RecurrenceRule *rrule = new KCalendarCore::RecurrenceRule();
 
@@ -201,6 +220,7 @@ void DSchedule::setRRuleType(const DSchedule::RRuleType &rtype)
 
 DSchedule::RRuleType DSchedule::getRRuleType()
 {
+    // qCDebug(CommonLogger) << "Getting RRule type for schedule:" << summary();
     RRuleType rtype = RRule_None;
     if (this->recurs()) {
         KCalendarCore::RecurrenceRule *rrule = this->recurrence()->defaultRRuleConst();
@@ -226,25 +246,28 @@ DSchedule::RRuleType DSchedule::getRRuleType()
             break;
         }
     }
+    // qCDebug(CommonLogger) << "Found RRule type:" << static_cast<int>(rtype);
     return rtype;
 }
 
 int DSchedule::numberOfRepetitions(const Ptr &scheudle, const QDateTime &datetime)
 {
+    // qCDebug(CommonLogger) << "Calculating number of repetitions for schedule" << scheudle->summary() << "until" << datetime;
     return scheudle->recurrence()->durationTo(datetime);
 }
 
 bool DSchedule::fromJsonString(DSchedule::Ptr &schedule, const QString &json)
 {
+    // qCDebug(CommonLogger) << "Parsing schedule from JSON string:" << json;
     if (schedule.isNull()) {
-        qCDebug(ServiceLogger) << "Creating new schedule instance for JSON parsing";
+        // qCDebug(CommonLogger) << "Creating new schedule instance for JSON parsing";
         schedule = DSchedule::Ptr(new DSchedule);
     }
 
     QJsonParseError jsonError;
     QJsonDocument jsonDoc(QJsonDocument::fromJson(json.toLocal8Bit(), &jsonError));
     if (jsonError.error != QJsonParseError::NoError) {
-        qCWarning(ServiceLogger) << "Failed to parse schedule JSON. Error:" << jsonError.errorString();
+        qCWarning(CommonLogger) << "Failed to parse schedule JSON. Error:" << jsonError.errorString();
         return false;
     }
 
@@ -262,15 +285,16 @@ bool DSchedule::fromJsonString(DSchedule::Ptr &schedule, const QString &json)
             resBool = true;
         }
     } else {
-        qCWarning(ServiceLogger) << "No schedule data found in JSON";
+        qCWarning(CommonLogger) << "No schedule data found in JSON";
     }
     return resBool;
 }
 
 bool DSchedule::toJsonString(const DSchedule::Ptr &schedule, QString &json)
 {
+    // qCDebug(CommonLogger) << "Converting schedule to JSON string:" << schedule->summary();
     if (schedule.isNull()) {
-        qCWarning(ServiceLogger) << "Cannot convert null schedule to JSON";
+        qCWarning(CommonLogger) << "Cannot convert null schedule to JSON";
         return false;
     }
 
@@ -281,11 +305,13 @@ bool DSchedule::toJsonString(const DSchedule::Ptr &schedule, QString &json)
     QJsonDocument jsonDoc;
     jsonDoc.setObject(rootObject);
     json = QString::fromUtf8(jsonDoc.toJson(QJsonDocument::Compact));
+    // qCDebug(CommonLogger) << "Resulting JSON:" << json;
     return true;
 }
 
 bool DSchedule::fromIcsString(Ptr &schedule, const QString &string)
 {
+    // qCDebug(CommonLogger) << "Parsing schedule from ICS string:" << string;
     bool resBool = false;
     KCalendarCore::ICalFormat icalformat;
     QTimeZone timezone = QDateTime::currentDateTime().timeZone();
@@ -294,16 +320,18 @@ bool DSchedule::fromIcsString(Ptr &schedule, const QString &string)
         KCalendarCore::Event::List eventList = _cal->events();
         if (eventList.size() > 0) {
             schedule = DSchedule::Ptr(new DSchedule(*eventList.at(0).data())); // eventList.at(0).staticCast<DSchedule>();
+            // qCDebug(CommonLogger) << "Successfully parsed schedule:" << schedule->summary();
             resBool = true;
         }
     } else {
-        qCWarning(ServiceLogger) << "Failed to parse ICS string";
+        qCWarning(CommonLogger) << "Failed to parse ICS string";
     }
     return resBool;
 }
 
 QString DSchedule::toIcsString(const DSchedule::Ptr &schedule)
 {
+    // qCDebug(CommonLogger) << "Converting schedule to ICS string:" << schedule->summary();
     KCalendarCore::ICalFormat icalformat;
     KCalendarCore::MemoryCalendar::Ptr _cal(new KCalendarCore::MemoryCalendar(nullptr));
     _cal->addEvent(schedule);
@@ -312,11 +340,12 @@ QString DSchedule::toIcsString(const DSchedule::Ptr &schedule)
 
 QMap<QDate, DSchedule::List> DSchedule::fromMapString(const QString &json)
 {
+    // qCDebug(CommonLogger) << "Parsing schedule map from JSON string:" << json;
     QMap<QDate, DSchedule::List> scheduleMap;
     QJsonParseError jsonError;
     QJsonDocument jsonDoc(QJsonDocument::fromJson(json.toLocal8Bit(), &jsonError));
     if (jsonError.error != QJsonParseError::NoError) {
-        qCWarning(ServiceLogger) << "Failed to parse schedule map JSON. Error:" << jsonError.errorString();
+        qCWarning(CommonLogger) << "Failed to parse schedule map JSON. Error:" << jsonError.errorString();
         return scheduleMap;
     }
 
@@ -337,11 +366,13 @@ QMap<QDate, DSchedule::List> DSchedule::fromMapString(const QString &json)
             }
         }
     }
+    // qCDebug(CommonLogger) << "Parsed" << scheduleMap.size() << "dates from schedule map JSON.";
     return scheduleMap;
 }
 
 QString DSchedule::toMapString(const QMap<QDate, DSchedule::List> &scheduleMap)
 {
+    // qCDebug(CommonLogger) << "Converting schedule map to JSON string, containing" << scheduleMap.size() << "dates.";
     QJsonArray rootArray;
     QMap<QDate, DSchedule::List>::const_iterator iter = scheduleMap.constBegin();
     for (; iter != scheduleMap.constEnd(); ++iter) {
@@ -363,6 +394,7 @@ QString DSchedule::toMapString(const QMap<QDate, DSchedule::List> &scheduleMap)
 
 QPair<QString, DSchedule::List> DSchedule::fromListString(const QString &json)
 {
+    // qCDebug(CommonLogger) << "Parsing schedule list from JSON string:" << json;
     QPair<QString, DSchedule::List> schedulePair;
     QJsonParseError jsonError;
     QJsonDocument jsonDoc(QJsonDocument::fromJson(json.toLocal8Bit(), &jsonError));
@@ -387,11 +419,13 @@ QPair<QString, DSchedule::List> DSchedule::fromListString(const QString &json)
     }
     schedulePair.second = scheduleList;
 
+    // qCDebug(CommonLogger) << "Parsed" << scheduleList.size() << "schedules from list string for query:" << schedulePair.first;
     return schedulePair;
 }
 
 QString DSchedule::toListString(const QString &query, const DSchedule::List &scheduleList)
 {
+    // qCDebug(CommonLogger) << "Converting schedule list to JSON string for query:" << query << "with" << scheduleList.size() << "schedules.";
     QJsonObject jsonObj;
     jsonObj.insert("query", query);
     QJsonArray jsonArray;
@@ -410,6 +444,7 @@ QString DSchedule::toListString(const QString &query, const DSchedule::List &sch
 
 void DSchedule::expendRecurrence(DSchedule::Map &scheduleMap, const DSchedule::Ptr &schedule, const QDateTime &dtStart, const QDateTime &dtEnd)
 {
+    // qCDebug(CommonLogger) << "Expanding recurrence for schedule:" << schedule->summary() << "from" << dtStart << "to" << dtEnd;
     QDateTime queryDtStart = dtStart;
     //如果日程为全天日程，则查询的开始时间设置为0点，因为全天日程的开始和结束时间都是0点
     if(schedule->allDay()){
@@ -420,6 +455,7 @@ void DSchedule::expendRecurrence(DSchedule::Map &scheduleMap, const DSchedule::P
         //获取日程的开始结束时间差
         qint64 interval = schedule->dtStart().secsTo(schedule->dtEnd());
         QList<QDateTime> dtList = schedule->recurrence()->timesInInterval(queryDtStart, dtEnd);
+        // qCDebug(CommonLogger) << "Found" << dtList.size() << "recurrence instances.";
         foreach (auto &dt, dtList) {
             QDateTime scheduleDtEnd = dt.addSecs(interval);
             DSchedule::Ptr newSchedule = DSchedule::Ptr(schedule->clone());
@@ -433,6 +469,7 @@ void DSchedule::expendRecurrence(DSchedule::Map &scheduleMap, const DSchedule::P
             scheduleMap[dt.date()].append(newSchedule);
         }
     } else {
+        // qCDebug(CommonLogger) << "Schedule does not recur, checking if it falls within the interval.";
         if (!(schedule->dtStart() > dtEnd || schedule->dtEnd() < queryDtStart)) {
             scheduleMap[schedule->dtStart().date()].append(schedule);
         }
@@ -441,6 +478,7 @@ void DSchedule::expendRecurrence(DSchedule::Map &scheduleMap, const DSchedule::P
 
 QMap<QDate, DSchedule::List> DSchedule::convertSchedules(const DScheduleQueryPar::Ptr &queryPar, const DSchedule::List &scheduleList)
 {
+    // qCDebug(CommonLogger) << "Converting" << scheduleList.size() << "schedules based on query parameters.";
     QDateTime dtStart = queryPar->dtStart();
     QDateTime dtEnd = queryPar->dtEnd();
     bool extend = queryPar->queryType() == DScheduleQueryPar::Query_None;
@@ -451,8 +489,10 @@ QMap<QDate, DSchedule::List> DSchedule::convertSchedules(const DScheduleQueryPar
         qint64 interval = schedule->dtStart().secsTo(schedule->dtEnd());
         //如果存在重复日程
         if (schedule->recurs()) {
+            // qCDebug(CommonLogger) << "Processing recurring schedule:" << schedule->summary();
             //如果为农历日程
             if (schedule->lunnar()) {
+                // qCDebug(CommonLogger) << "Processing lunar recurring schedule.";
                 //农历重复日程计算
                 LunarDateInfo lunardate(schedule->recurrence()->defaultRRuleConst(), interval);
 
@@ -478,10 +518,12 @@ QMap<QDate, DSchedule::List> DSchedule::convertSchedules(const DScheduleQueryPar
                     scheduleMap[recurDateTime.date()].append(newSchedule);
                 }
             } else {
+                // qCDebug(CommonLogger) << "Processing Gregorian recurring schedule.";
                 //非农历日程
                 expendRecurrence(scheduleMap, schedule, dtStart, dtEnd);
             }
         } else {
+            // qCDebug(CommonLogger) << "Processing non-recurring schedule:" << schedule->summary();
             //普通日程
             //如果在查询时间范围内
             QDateTime queryDtStart = dtStart;
@@ -491,6 +533,7 @@ QMap<QDate, DSchedule::List> DSchedule::convertSchedules(const DScheduleQueryPar
             }
             if (!(schedule->dtEnd() < queryDtStart || schedule->dtStart() > dtEnd)) {
                 if (extend && schedule->isMultiDay()) {
+                    // qCDebug(CommonLogger) << "Expanding multi-day schedule.";
                     //需要扩展的天数
                     int extenddays = static_cast<int>(schedule->dtStart().daysTo(schedule->dtEnd()));
                     for (int i = 0; i <= extenddays; ++i) {
@@ -506,6 +549,7 @@ QMap<QDate, DSchedule::List> DSchedule::convertSchedules(const DScheduleQueryPar
 
     //如果为查询前N个日程，则取前N个日程
     if (queryPar->queryType() == DScheduleQueryPar::Query_Top) {
+        // qCDebug(CommonLogger) << "Filtering for top" << queryPar->queryTop() << "schedules.";
         int scheduleNum = 0;
         DSchedule::Map filterSchedule;
         DSchedule::Map::const_iterator iter = scheduleMap.constBegin();
@@ -527,15 +571,18 @@ QMap<QDate, DSchedule::List> DSchedule::convertSchedules(const DScheduleQueryPar
         scheduleMap = filterSchedule;
     }
 
+    // qCDebug(CommonLogger) << "Conversion finished, returning" << scheduleMap.size() << "dates with schedules.";
     return scheduleMap;
 }
 
 QMap<QDate, DSchedule::List> DSchedule::fromQueryResult(const QString &query)
 {
+    // qCDebug(CommonLogger) << "Parsing schedules from query result:" << query;
     QMap<QDate, DSchedule::List> scheduleMap;
     QPair<QString, DSchedule::List> pair = fromListString(query);
     DScheduleQueryPar::Ptr queryPar = DScheduleQueryPar::fromJsonString(pair.first);
     if (queryPar.isNull()) {
+        qCWarning(CommonLogger) << "Failed to parse query parameters from query result.";
         return scheduleMap;
     }
 
@@ -545,11 +592,13 @@ QMap<QDate, DSchedule::List> DSchedule::fromQueryResult(const QString &query)
 
 bool operator==(const DSchedule::Ptr &s1, const DSchedule::Ptr &s2)
 {
+    // qCDebug(CommonLogger) << "Comparing DSchedule::Ptr with operator==";
     return s1.isNull() || s2.isNull() ? s1.isNull() && s2.isNull() : s1->instanceIdentifier() == s2->instanceIdentifier();
 }
 
 QMap<int, DSchedule::AlarmType> DSchedule::getAlarmMap()
 {
+    // qCDebug(CommonLogger) << "Getting alarm map.";
     static QMap<int, DSchedule::AlarmType> alarmMap {
         {0, Alarm_Begin},
         {-15 * Duration_Min, Alarm_15Min_Front},
@@ -567,27 +616,31 @@ QMap<int, DSchedule::AlarmType> DSchedule::getAlarmMap()
 
 QString DSchedule::fileName() const
 {
+    // qCDebug(CommonLogger) << "Getting file name:" << m_fileName;
     return m_fileName;
 }
 
 void DSchedule::setFileName(const QString &fileName)
 {
-    qCDebug(ServiceLogger) << "Setting file name for schedule" << summary() << "from" << m_fileName << "to" << fileName;
+    // qCDebug(CommonLogger) << "Setting file name for schedule" << summary() << "from" << m_fileName << "to" << fileName;
     m_fileName = fileName;
 }
 
 int DSchedule::compatibleID() const
 {
+    // qCDebug(CommonLogger) << "Getting compatible ID:" << m_compatibleID;
     return m_compatibleID;
 }
 
 void DSchedule::setcompatibleID(int compatibleID)
 {
+    // qCDebug(CommonLogger) << "Setting compatible ID to:" << compatibleID;
     m_compatibleID = compatibleID;
 }
 
 QDebug operator<<(QDebug debug, const DSchedule &scheduleJsonData)
 {
+    // qCDebug(CommonLogger) << "Streaming DSchedule to QDebug.";
     QDebugStateSaver saver(debug);
     debug.noquote() << "dtStart:" << dtToString(scheduleJsonData.dtStart())
                     << " ,dtEnd:" << dtToString(scheduleJsonData.dtEnd())
diff --git a/calendar-common/src/dschedulequerypar.cpp b/calendar-common/src/dschedulequerypar.cpp
index d04a7074d..3f8c06dee 100644
--- a/calendar-common/src/dschedulequerypar.cpp
+++ b/calendar-common/src/dschedulequerypar.cpp
@@ -17,44 +17,52 @@ DScheduleQueryPar::DScheduleQueryPar()
     , m_rruleType(RRule_None)
     , m_queryType(Query_None)
 {
+    qCDebug(CommonLogger) << "DScheduleQueryPar constructor called.";
 }
 
 QDateTime DScheduleQueryPar::dtStart() const
 {
+    // qCDebug(CommonLogger) << "Getting dtStart:" << m_dtStart;
     return m_dtStart;
 }
 
 void DScheduleQueryPar::setDtStart(const QDateTime &dtStart)
 {
+    // qCDebug(CommonLogger) << "Setting dtStart to:" << dtStart;
     m_dtStart = dtStart;
 }
 
 QDateTime DScheduleQueryPar::dtEnd() const
 {
+    // qCDebug(CommonLogger) << "Getting dtEnd:" << m_dtEnd;
     return m_dtEnd;
 }
 
 void DScheduleQueryPar::setDtEnd(const QDateTime &dtEnd)
 {
+    // qCDebug(CommonLogger) << "Setting dtEnd to:" << dtEnd;
     m_dtEnd = dtEnd;
 }
 
 QString DScheduleQueryPar::key() const
 {
+    // qCDebug(CommonLogger) << "Getting key:" << m_key;
     return m_key;
 }
 
 void DScheduleQueryPar::setKey(const QString &key)
 {
+    // qCDebug(CommonLogger) << "Setting key to:" << key;
     m_key = key;
 }
 
 DScheduleQueryPar::Ptr DScheduleQueryPar::fromJsonString(const QString &queryStr)
 {
+    // qCDebug(CommonLogger) << "Parsing DScheduleQueryPar from JSON string:" << queryStr;
     QJsonParseError jsonError;
     QJsonDocument jsonDoc(QJsonDocument::fromJson(queryStr.toLocal8Bit(), &jsonError));
     if (jsonError.error != QJsonParseError::NoError) {
-        qCWarning(ServiceLogger) << "Failed to parse query parameters JSON. Error:" << jsonError.errorString() 
+        qCWarning(CommonLogger) << "Failed to parse query parameters JSON. Error:" << jsonError.errorString() 
                                  << "Query string:" << queryStr;
         return nullptr;
     }
@@ -89,13 +97,15 @@ DScheduleQueryPar::Ptr DScheduleQueryPar::fromJsonString(const QString &queryStr
     default:
         break;
     }
+    // qCDebug(CommonLogger) << "Successfully parsed DScheduleQueryPar from JSON.";
     return queryPar;
 }
 
 QString DScheduleQueryPar::toJsonString(const DScheduleQueryPar::Ptr &queryPar)
 {
+    // qCDebug(CommonLogger) << "Converting DScheduleQueryPar to JSON string.";
     if (queryPar.isNull()) {
-        qCWarning(ServiceLogger) << "Cannot convert null query parameters to JSON";
+        qCWarning(CommonLogger) << "Cannot convert null query parameters to JSON";
         return QString();
     }
 
@@ -117,35 +127,43 @@ QString DScheduleQueryPar::toJsonString(const DScheduleQueryPar::Ptr &queryPar)
 
     QJsonDocument jsonDoc;
     jsonDoc.setObject(jsonObj);
-    return QString::fromUtf8(jsonDoc.toJson(QJsonDocument::Compact));
+    QString jsonString = QString::fromUtf8(jsonDoc.toJson(QJsonDocument::Compact));
+    // qCDebug(CommonLogger) << "Resulting DScheduleQueryPar JSON:" << jsonString;
+    return jsonString;
 }
 
 DScheduleQueryPar::QueryType DScheduleQueryPar::queryType() const
 {
+    // qCDebug(CommonLogger) << "Getting queryType:" << m_queryType;
     return m_queryType;
 }
 
 void DScheduleQueryPar::setQueryType(const QueryType &queryType)
 {
+    // qCDebug(CommonLogger) << "Setting queryType to:" << queryType;
     m_queryType = queryType;
 }
 
 int DScheduleQueryPar::queryTop() const
 {
+    // qCDebug(CommonLogger) << "Getting queryTop:" << m_queryTop;
     return m_queryTop;
 }
 
 void DScheduleQueryPar::setQueryTop(int queryTop)
 {
+    // qCDebug(CommonLogger) << "Setting queryTop to:" << queryTop;
     m_queryTop = queryTop;
 }
 
 DScheduleQueryPar::RRuleType DScheduleQueryPar::rruleType() const
 {
+    // qCDebug(CommonLogger) << "Getting rruleType:" << m_rruleType;
     return m_rruleType;
 }
 
 void DScheduleQueryPar::setRruleType(const RRuleType &rruleType)
 {
+    // qCDebug(CommonLogger) << "Setting rruleType to:" << rruleType;
     m_rruleType = rruleType;
 }
diff --git a/calendar-common/src/dscheduletype.cpp b/calendar-common/src/dscheduletype.cpp
index 3121b3f21..aa6098063 100644
--- a/calendar-common/src/dscheduletype.cpp
+++ b/calendar-common/src/dscheduletype.cpp
@@ -16,6 +16,7 @@
 DScheduleType::DScheduleType()
     : DScheduleType("")
 {
+    // qCDebug(CommonLogger) << "DScheduleType default constructor called.";
 }
 
 DScheduleType::DScheduleType(const QString &accountID)
@@ -31,192 +32,203 @@ DScheduleType::DScheduleType(const QString &accountID)
     , m_deleted(0)
     , m_syncTag(0)
 {
+    // qCDebug(CommonLogger) << "DScheduleType constructor called with accountID:" << accountID;
 }
 
 QString DScheduleType::accountID() const
 {
+    // qCDebug(CommonLogger) << "Getting accountID.";
     return m_accountID;
 }
 
 void DScheduleType::setAccountID(const QString &accountID)
 {
-    qCDebug(ServiceLogger) << "Setting account ID from" << m_accountID << "to" << accountID;
+    // qCDebug(CommonLogger) << "Setting account ID to:" << accountID;
     m_accountID = accountID;
 }
 
 DScheduleType::Privileges DScheduleType::privilege() const
 {
+    // qCDebug(CommonLogger) << "Getting privilege.";
     return m_privilege;
 }
 
 void DScheduleType::setPrivilege(const Privileges &privilege)
 {
-    qCDebug(ServiceLogger) << "Setting privilege from" << static_cast<int>(m_privilege) 
-                          << "to" << static_cast<int>(privilege);
+    // qCDebug(CommonLogger) << "Setting privilege to:" << static_cast<int>(privilege);
     m_privilege = privilege;
 }
 
 DTypeColor DScheduleType::typeColor() const
 {
+    // qCDebug(CommonLogger) << "Getting typeColor.";
     return m_typeColor;
 }
 
 void DScheduleType::setTypeColor(const DTypeColor &typeColor)
 {
-    qCDebug(ServiceLogger) << "Setting type color - ID:" << typeColor.colorID() 
-                          << "Code:" << typeColor.colorCode() 
-                          << "Privilege:" << static_cast<int>(typeColor.privilege());
+    // qCDebug(CommonLogger) << "Setting type color - ID:" << typeColor.colorID() 
+    //                       << "Code:" << typeColor.colorCode() 
+    //                       << "Privilege:" << static_cast<int>(typeColor.privilege());
     m_typeColor = typeColor;
 }
 
 void DScheduleType::setColorID(const QString &colorID)
 {
-    qCDebug(ServiceLogger) << "Setting color ID from" << m_typeColor.colorID() << "to" << colorID;
+    // qCDebug(CommonLogger) << "Setting color ID to:" << colorID;
     m_typeColor.setColorID(colorID);
 }
 
 QString DScheduleType::getColorID() const
 {
+    // qCDebug(CommonLogger) << "Getting colorID.";
     return m_typeColor.colorID();
 }
 
 void DScheduleType::setColorCode(const QString &colorCode)
 {
-    qCDebug(ServiceLogger) << "Setting color code from" << m_typeColor.colorCode() << "to" << colorCode;
+    // qCDebug(CommonLogger) << "Setting color code to:" << colorCode;
     m_typeColor.setColorCode(colorCode);
 }
 
 QString DScheduleType::getColorCode() const
 {
+    // qCDebug(CommonLogger) << "Getting color code.";
     return m_typeColor.colorCode();
 }
 
 QString DScheduleType::typeID() const
 {
+    // qCDebug(CommonLogger) << "Getting typeID.";
     return m_typeID;
 }
 
 void DScheduleType::setTypeID(const QString &typeID)
 {
-    qCDebug(ServiceLogger) << "Setting type ID from" << m_typeID << "to" << typeID;
+    // qCDebug(CommonLogger) << "Setting type ID to:" << typeID;
     m_typeID = typeID;
 }
 
 QString DScheduleType::displayName() const
 {
+    // qCDebug(CommonLogger) << "Getting display name.";
     return m_displayName;
 }
 
 void DScheduleType::setDisplayName(const QString &displayName)
 {
-    qCDebug(ServiceLogger) << "Setting display name from" << m_displayName << "to" << displayName;
+    // qCDebug(CommonLogger) << "Setting display name to:" << displayName;
     m_displayName = displayName;
 }
 
 DScheduleType::ShowState DScheduleType::showState() const
 {
+    // qCDebug(CommonLogger) << "Getting show state.";
     return m_showState;
 }
 
 void DScheduleType::setShowState(const ShowState &showState)
 {
-    qCDebug(ServiceLogger) << "Setting show state from" << static_cast<int>(m_showState) 
-                          << "to" << static_cast<int>(showState);
+    // qCDebug(CommonLogger) << "Setting show state to:" << static_cast<int>(showState);
     m_showState = showState;
 }
 
 QString DScheduleType::typeName() const
 {
+    // qCDebug(CommonLogger) << "Getting type name.";
     return m_typeName;
 }
 
 void DScheduleType::setTypeName(const QString &typeName)
 {
-    qCDebug(ServiceLogger) << "Setting type name from" << m_typeName << "to" << typeName;
+    // qCDebug(CommonLogger) << "Setting type name to:" << typeName;
     m_typeName = typeName;
 }
 
 QString DScheduleType::typePath() const
 {
+    // qCDebug(CommonLogger) << "Getting type path.";
     return m_typePath;
 }
 
 void DScheduleType::setTypePath(const QString &typePath)
 {
-    qCDebug(ServiceLogger) << "Setting type path from" << m_typePath << "to" << typePath;
+    // qCDebug(CommonLogger) << "Setting type path to:" << typePath;
     m_typePath = typePath;
 }
 
 QString DScheduleType::description() const
 {
+    // qCDebug(CommonLogger) << "Getting description.";
     return m_description;
 }
 
 void DScheduleType::setDescription(const QString &description)
 {
-    qCDebug(ServiceLogger) << "Setting description from" << m_description << "to" << description;
+    // qCDebug(CommonLogger) << "Setting description to:" << description;
     m_description = description;
 }
 
 QDateTime DScheduleType::dtCreate() const
 {
+    // qCDebug(CommonLogger) << "Getting dtCreate.";
     return m_dtCreate;
 }
 
 void DScheduleType::setDtCreate(const QDateTime &dtCreate)
 {
-    qCDebug(ServiceLogger) << "Setting creation date from" << m_dtCreate.toString() 
-                          << "to" << dtCreate.toString();
+    // qCDebug(CommonLogger) << "Setting creation date to:" << dtCreate.toString();
     m_dtCreate = dtCreate;
 }
 
 QDateTime DScheduleType::dtUpdate() const
 {
+    // qCDebug(CommonLogger) << "Getting dtUpdate.";
     return m_dtUpdate;
 }
 
 void DScheduleType::setDtUpdate(const QDateTime &dtUpdate)
 {
-    qCDebug(ServiceLogger) << "Setting update date from" << m_dtUpdate.toString() 
-                          << "to" << dtUpdate.toString();
+    // qCDebug(CommonLogger) << "Setting update date to:" << dtUpdate.toString();
     m_dtUpdate = dtUpdate;
 }
 
 QDateTime DScheduleType::dtDelete() const
 {
+    // qCDebug(CommonLogger) << "Getting dtDelete.";
     return m_dtDelete;
 }
 
 void DScheduleType::setDtDelete(const QDateTime &dtDelete)
 {
-    qCDebug(ServiceLogger) << "Setting delete date from" << m_dtDelete.toString() 
-                          << "to" << dtDelete.toString();
+    // qCDebug(CommonLogger) << "Setting delete date to:" << dtDelete.toString();
     m_dtDelete = dtDelete;
 }
 
 int DScheduleType::deleted() const
 {
+    // qCDebug(CommonLogger) << "Getting deleted status.";
     return m_deleted;
 }
 
 void DScheduleType::setDeleted(int deleted)
 {
-    qCDebug(ServiceLogger) << "Setting deleted status from" << m_deleted << "to" << deleted;
+    qCDebug(CommonLogger) << "Setting deleted status to:" << deleted;
     m_deleted = deleted;
 }
 
 bool DScheduleType::fromJsonString(DScheduleType::Ptr &scheduleType, const QString &jsonStr)
 {
-    qCDebug(ServiceLogger) << "Parsing schedule type from JSON string";
+    qCDebug(CommonLogger) << "Parsing schedule type from JSON string";
     if (scheduleType.isNull()) {
-        qCDebug(ServiceLogger) << "Creating new schedule type instance for JSON parsing";
+        qCDebug(CommonLogger) << "Creating new schedule type instance for JSON parsing";
         scheduleType = DScheduleType::Ptr(new DScheduleType);
     }
     //反序列化
     QJsonParseError jsonError;
     QJsonDocument jsonDoc(QJsonDocument::fromJson(jsonStr.toLocal8Bit(), &jsonError));
     if (jsonError.error != QJsonParseError::NoError) {
-        qCWarning(ServiceLogger) << "Failed to parse schedule type JSON. Error:" << jsonError.errorString();
+        qCWarning(CommonLogger) << "Failed to parse schedule type JSON. Error:" << jsonError.errorString();
         return false;
     }
 
@@ -283,14 +295,15 @@ bool DScheduleType::fromJsonString(DScheduleType::Ptr &scheduleType, const QStri
     if (rootObj.contains("isDeleted")) {
         scheduleType->setDeleted(rootObj.value("isDeleted").toInt());
     }
+    qCDebug(CommonLogger) << "Successfully parsed schedule type from JSON.";
     return true;
 }
 
 bool DScheduleType::toJsonString(const DScheduleType::Ptr &scheduleType, QString &jsonStr)
 {
-    qCDebug(ServiceLogger) << "Converting schedule type to JSON string";
+    qCDebug(CommonLogger) << "Converting schedule type to JSON string";
     if (scheduleType.isNull()) {
-        qCWarning(ServiceLogger) << "Cannot convert null schedule type to JSON";
+        qCWarning(CommonLogger) << "Cannot convert null schedule type to JSON";
         return false;
     }
     //序列化
@@ -318,16 +331,17 @@ bool DScheduleType::toJsonString(const DScheduleType::Ptr &scheduleType, QString
     QJsonDocument jsonDoc;
     jsonDoc.setObject(rootObject);
     jsonStr = QString::fromUtf8(jsonDoc.toJson(QJsonDocument::Compact));
+    qCDebug(CommonLogger) << "Successfully converted schedule type to JSON:" << jsonStr;
     return true;
 }
 
 bool DScheduleType::fromJsonListString(DScheduleType::List &stList, const QString &jsonStr)
 {
-    qCDebug(ServiceLogger) << "Parsing schedule type list from JSON string";
+    qCDebug(CommonLogger) << "Parsing schedule type list from JSON string";
     QJsonParseError jsonError;
     QJsonDocument jsonDoc(QJsonDocument::fromJson(jsonStr.toLocal8Bit(), &jsonError));
     if (jsonError.error != QJsonParseError::NoError) {
-        qCWarning(ServiceLogger) << "Failed to parse schedule type list JSON. Error:" << jsonError.errorString();
+        qCWarning(CommonLogger) << "Failed to parse schedule type list JSON. Error:" << jsonError.errorString();
         return false;
     }
 
@@ -403,11 +417,13 @@ bool DScheduleType::fromJsonListString(DScheduleType::List &stList, const QStrin
             stList.append(scheduleType);
         }
     }
+    qCDebug(CommonLogger) << "Successfully parsed" << stList.count() << "schedule types from JSON list.";
     return true;
 }
 
 bool DScheduleType::toJsonListString(const DScheduleType::List &stList, QString &jsonStr)
 {
+    qCDebug(CommonLogger) << "Converting schedule type list to JSON string," << stList.count() << "items.";
     //序列化
     QJsonObject rootObject;
     QJsonArray jsonArray;
@@ -439,33 +455,37 @@ bool DScheduleType::toJsonListString(const DScheduleType::List &stList, QString
     QJsonDocument jsonDoc;
     jsonDoc.setObject(rootObject);
     jsonStr = QString::fromUtf8(jsonDoc.toJson(QJsonDocument::Compact));
+    qCDebug(CommonLogger) << "Successfully converted schedule type list to JSON.";
     return true;
 }
 
 int DScheduleType::syncTag() const
 {
+    // qCDebug(CommonLogger) << "Getting sync tag.";
     return m_syncTag;
 }
 
 void DScheduleType::setSyncTag(int syncTag)
 {
-    qCDebug(ServiceLogger) << "Setting sync tag from" << m_syncTag << "to" << syncTag;
+    // qCDebug(CommonLogger) << "Setting sync tag to:" << syncTag;
     m_syncTag = syncTag;
 }
 
 bool operator<(const DScheduleType::Ptr &st1, const DScheduleType::Ptr &st2)
 {
+    // qCDebug(CommonLogger) << "Comparing schedule types.";
     //权限不一致权限小的排在前面
     if (st1->privilege() != st2->privilege()) {
-        qCDebug(ServiceLogger) << "Comparing privileges - st1:" << static_cast<int>(st1->privilege()) 
+        qCDebug(CommonLogger) << "Comparing privileges - st1:" << static_cast<int>(st1->privilege()) 
                               << "st2:" << static_cast<int>(st2->privilege());
         return st1->privilege() < st2->privilege();
     }
     //权限一一致的创建时间早的排在前面
     if (st1->dtCreate() != st2->dtCreate()) {
-        qCDebug(ServiceLogger) << "Comparing creation dates - st1:" << st1->dtCreate().toString() 
+        qCDebug(CommonLogger) << "Comparing creation dates - st1:" << st1->dtCreate().toString() 
                               << "st2:" << st2->dtCreate().toString();
         return st1->dtCreate() < st2->dtCreate();
     }
+    // qCDebug(CommonLogger) << "Comparing schedule types - st1:" << st1->typeID() << "st2:" << st2->typeID();
     return true;
 }
diff --git a/calendar-common/src/dtypecolor.cpp b/calendar-common/src/dtypecolor.cpp
index 4c3727246..d4c1514fd 100644
--- a/calendar-common/src/dtypecolor.cpp
+++ b/calendar-common/src/dtypecolor.cpp
@@ -17,6 +17,7 @@ DTypeColor::DTypeColor()
     , m_colorCode("")
     , m_privilege(PriUser)
 {
+    // qCDebug(CommonLogger) << "DTypeColor constructor called.";
 }
 
 DTypeColor::DTypeColor(const DTypeColor &typeColor)
@@ -25,50 +26,60 @@ DTypeColor::DTypeColor(const DTypeColor &typeColor)
     , m_privilege(typeColor.privilege())
     , m_dtCreate(typeColor.dtCreate())
 {
+    // qCDebug(CommonLogger) << "DTypeColor copy constructor called.";
 }
 
 QString DTypeColor::colorCode() const
 {
+    // qCDebug(CommonLogger) << "Getting color code:" << m_colorCode;
     return m_colorCode;
 }
 
 void DTypeColor::setColorCode(const QString &colorCode)
 {
+    // qCDebug(CommonLogger) << "Setting color code to:" << colorCode;
     m_colorCode = colorCode;
 }
 
 QString DTypeColor::colorID() const
 {
+    // qCDebug(CommonLogger) << "Getting color ID:" << m_colorID;
     return m_colorID;
 }
 
 void DTypeColor::setColorID(const QString &colorID)
 {
+    // qCDebug(CommonLogger) << "Setting color ID to:" << colorID;
     m_colorID = colorID;
 }
 
 DTypeColor::Privilege DTypeColor::privilege() const
 {
+    // qCDebug(CommonLogger) << "Getting privilege:" << m_privilege;
     return m_privilege;
 }
 
 void DTypeColor::setPrivilege(const Privilege &privilege)
 {
+    // qCDebug(CommonLogger) << "Setting privilege to:" << privilege;
     m_privilege = privilege;
 }
 
 bool DTypeColor::isSysColorInfo()
 {
+    // qCDebug(CommonLogger) << "Checking if color is system color info.";
     return this->privilege() == PriSystem;
 }
 
 bool DTypeColor::operator!=(const DTypeColor &color) const
 {
+    // qCDebug(CommonLogger) << "Executing inequality operator.";
     return this->colorID() != color.colorID() || this->colorCode() != this->colorCode() || this->privilege() != this->privilege();
 }
 
 DTypeColor::List DTypeColor::fromJsonString(const QString &colorJson)
 {
+    // qCDebug(CommonLogger) << "Parsing color list from JSON string.";
     DTypeColor::List colorList;
     QJsonParseError jsonError;
     QJsonDocument jsonDoc(QJsonDocument::fromJson(colorJson.toLocal8Bit(), &jsonError));
@@ -78,18 +89,23 @@ DTypeColor::List DTypeColor::fromJsonString(const QString &colorJson)
     }
     QJsonArray rootArr = jsonDoc.array();
     foreach (auto json, rootArr) {
+        // qCDebug(CommonLogger) << "Processing a JSON object from the array.";
         QJsonObject colorObj = json.toObject();
         DTypeColor::Ptr typeColor = DTypeColor::Ptr(new DTypeColor);
         if (colorObj.contains("colorID")) {
+            // qCDebug(CommonLogger) << "Found and setting colorID.";
             typeColor->setColorID(colorObj.value("colorID").toString());
         }
         if (colorObj.contains("colorCode")) {
+            // qCDebug(CommonLogger) << "Found and setting colorCode.";
             typeColor->setColorCode(colorObj.value("colorCode").toString());
         }
         if (colorObj.contains("privilege")) {
+            // qCDebug(CommonLogger) << "Found and setting privilege.";
             typeColor->setPrivilege(static_cast<Privilege>(colorObj.value("privilege").toInt()));
         }
         if (colorObj.contains("dtCreate")) {
+            // qCDebug(CommonLogger) << "Found and setting dtCreate.";
             typeColor->setDtCreate(dtFromString(colorObj.value("dtCreate").toString()));
         }
         colorList.append(typeColor);
@@ -99,8 +115,10 @@ DTypeColor::List DTypeColor::fromJsonString(const QString &colorJson)
 
 QString DTypeColor::toJsonString(const DTypeColor::List &colorList)
 {
+    // qCDebug(CommonLogger) << "Converting color list to JSON string.";
     QJsonArray rootArr;
     foreach (auto color, colorList) {
+        // qCDebug(CommonLogger) << "Processing a color object for JSON conversion.";
         QJsonObject colorObj;
         colorObj.insert("colorID", color->colorID());
         colorObj.insert("colorCode", color->colorCode());
@@ -115,22 +133,28 @@ QString DTypeColor::toJsonString(const DTypeColor::List &colorList)
 
 QDateTime DTypeColor::dtCreate() const
 {
+    // qCDebug(CommonLogger) << "Getting dtCreate:" << m_dtCreate;
     return m_dtCreate;
 }
 
 void DTypeColor::setDtCreate(const QDateTime &dtCreate)
 {
+    // qCDebug(CommonLogger) << "Setting dtCreate to:" << dtCreate;
     m_dtCreate = dtCreate;
 }
 
 bool operator<(const DTypeColor::Ptr &tc1, const DTypeColor::Ptr &tc2)
 {
+    // qCDebug(CommonLogger) << "Executing less-than operator.";
     if (tc1->privilege() != tc2->privilege()) {
+        // qCDebug(CommonLogger) << "Comparing by privilege.";
         return tc1->privilege() < tc2->privilege();
     }
 
     if (tc1->dtCreate() != tc2->dtCreate()) {
+        // qCDebug(CommonLogger) << "Comparing by dtCreate.";
         return tc1->dtCreate() < tc2->dtCreate();
     }
+    // qCDebug(CommonLogger) << "Defaulting to true in less-than comparison.";
     return true;
 }
diff --git a/calendar-common/src/huangliData/dbusdatastruct.cpp b/calendar-common/src/huangliData/dbusdatastruct.cpp
index 8df2d219b..7b45006cc 100644
--- a/calendar-common/src/huangliData/dbusdatastruct.cpp
+++ b/calendar-common/src/huangliData/dbusdatastruct.cpp
@@ -3,6 +3,7 @@
 // SPDX-License-Identifier: LGPL-3.0-or-later
 
 #include "dbusdatastruct.h"
+#include "commondef.h"
 
 #include <QJsonParseError>
 #include <QJsonDocument>
@@ -10,12 +11,14 @@
 
 void CaLunarDayInfo::registerMetaType()
 {
+    qCDebug(CommonLogger) << "Registering CaLunarDayInfo meta type.";
     qRegisterMetaType<CaLunarDayInfo>();
     qDBusRegisterMetaType<CaLunarDayInfo>();
 }
 
 QDebug operator<<(QDebug argument, const CaLunarDayInfo &what)
 {
+    // qCDebug(CommonLogger) << "Streaming CaLunarDayInfo to QDebug.";
     argument << what.mGanZhiYear << what.mGanZhiMonth << what.mGanZhiDay;
     argument << what.mLunarMonthName << what.mLunarDayName;
     argument << what.mLunarLeapMonth;
@@ -28,6 +31,7 @@ QDebug operator<<(QDebug argument, const CaLunarDayInfo &what)
 
 QDBusArgument &operator<<(QDBusArgument &argument, const CaLunarDayInfo &what)
 {
+    // qCDebug(CommonLogger) << "Streaming CaLunarDayInfo to QDBusArgument.";
     argument.beginStructure();
     argument << what.mGanZhiYear << what.mGanZhiMonth << what.mGanZhiDay;
     argument << what.mLunarMonthName << what.mLunarDayName;
@@ -42,6 +46,7 @@ QDBusArgument &operator<<(QDBusArgument &argument, const CaLunarDayInfo &what)
 
 const QDBusArgument &operator>>(const QDBusArgument &argument, CaLunarDayInfo &what)
 {
+    // qCDebug(CommonLogger) << "Streaming CaLunarDayInfo from QDBusArgument.";
     argument.beginStructure();
     argument >> what.mGanZhiYear >> what.mGanZhiMonth >> what.mGanZhiDay;
     argument >> what.mLunarMonthName >> what.mLunarDayName;
@@ -56,12 +61,14 @@ const QDBusArgument &operator>>(const QDBusArgument &argument, CaLunarDayInfo &w
 
 void CaLunarMonthInfo::registerMetaType()
 {
+    // qCDebug(CommonLogger) << "Registering CaLunarMonthInfo meta type.";
     qRegisterMetaType<CaLunarMonthInfo>();
     qDBusRegisterMetaType<CaLunarMonthInfo>();
 }
 
 QDebug operator<<(QDebug argument, const CaLunarMonthInfo &what)
 {
+    // qCDebug(CommonLogger) << "Streaming CaLunarMonthInfo to QDebug.";
     argument << what.mFirstDayWeek << what.mDays;
     argument << what.mCaLunarDayInfo;
 
@@ -70,6 +77,7 @@ QDebug operator<<(QDebug argument, const CaLunarMonthInfo &what)
 
 QDBusArgument &operator<<(QDBusArgument &argument, const CaLunarMonthInfo &what)
 {
+    // qCDebug(CommonLogger) << "Streaming CaLunarMonthInfo to QDBusArgument.";
     argument.beginStructure();
     argument << what.mFirstDayWeek << what.mDays;
     argument << what.mCaLunarDayInfo;
@@ -80,6 +88,7 @@ QDBusArgument &operator<<(QDBusArgument &argument, const CaLunarMonthInfo &what)
 
 const QDBusArgument &operator>>(const QDBusArgument &argument, CaLunarMonthInfo &what)
 {
+    // qCDebug(CommonLogger) << "Streaming CaLunarMonthInfo from QDBusArgument.";
     argument.beginStructure();
     argument >> what.mFirstDayWeek >> what.mDays;
     argument >> what.mCaLunarDayInfo;
@@ -90,12 +99,14 @@ const QDBusArgument &operator>>(const QDBusArgument &argument, CaLunarMonthInfo
 
 void CaHuangLiDayInfo::registerMetaType()
 {
+    // qCDebug(CommonLogger) << "Registering CaHuangLiDayInfo meta type.";
     qRegisterMetaType<CaHuangLiDayInfo>();
     qDBusRegisterMetaType<CaHuangLiDayInfo>();
 }
 
 QString CaHuangLiDayInfo::toJson()
 {
+    // qCDebug(CommonLogger) << "Converting CaHuangLiDayInfo to JSON string.";
     QJsonDocument doc;
     QJsonObject obj;
 
@@ -120,10 +131,12 @@ QString CaHuangLiDayInfo::toJson()
 
 void CaHuangLiDayInfo::strJsonToInfo(const QString &strJson, bool &isVaild)
 {
+    // qCDebug(CommonLogger) << "Parsing CaHuangLiDayInfo from JSON string.";
     isVaild = true;
     QJsonParseError json_error;
     QJsonDocument jsonDoc(QJsonDocument::fromJson(strJson.toLocal8Bit(), &json_error));
     if (json_error.error != QJsonParseError::NoError) {
+        qCDebug(CommonLogger) << "JSON parse error:" << json_error.errorString();
         isVaild = false;
         return ;
     }
@@ -133,50 +146,65 @@ void CaHuangLiDayInfo::strJsonToInfo(const QString &strJson, bool &isVaild)
 
 void CaHuangLiDayInfo::jsonObjectToInfo(const QJsonObject &jsonObject)
 {
+    // qCDebug(CommonLogger) << "Parsing CaHuangLiDayInfo from JSON object.";
     //因为是预先定义好的JSON数据格式，所以这里可以这样读取int
     if (jsonObject.contains("Suit")) {
+        // qCDebug(CommonLogger) << "Found and setting Suit.";
         this->mSuit = jsonObject.value("Suit").toString();
     }
     if (jsonObject.contains("Avoid")) {
+        // qCDebug(CommonLogger) << "Found and setting Avoid.";
         this->mAvoid = jsonObject.value("Avoid").toString();
     }
     if (jsonObject.contains("Worktime")) {
+        // qCDebug(CommonLogger) << "Found and setting Worktime.";
         this->mWorktime = jsonObject.value("Worktime").toInt();
     }
     if (jsonObject.contains("LunarFestival")) {
+        // qCDebug(CommonLogger) << "Found and setting LunarFestival.";
         this->mLunarFestival = jsonObject.value("LunarFestival").toString();
     }
     if (jsonObject.contains("SolarFestival")) {
+        // qCDebug(CommonLogger) << "Found and setting SolarFestival.";
         this->mSolarFestival = jsonObject.value("SolarFestival").toString();
     }
     if (jsonObject.contains("Term")) {
+        // qCDebug(CommonLogger) << "Found and setting Term.";
         this->mTerm = jsonObject.value("Term").toString();
     }
     if (jsonObject.contains("Zodiac")) {
+        // qCDebug(CommonLogger) << "Found and setting Zodiac.";
         this->mZodiac = jsonObject.value("Zodiac").toString();
     }
     if (jsonObject.contains("LunarLeapMonth")) {
+        // qCDebug(CommonLogger) << "Found and setting LunarLeapMonth.";
         this->mLunarLeapMonth = jsonObject.value("LunarLeapMonth").toInt();
     }
     if (jsonObject.contains("LunarDayName")) {
+        // qCDebug(CommonLogger) << "Found and setting LunarDayName.";
         this->mLunarDayName = jsonObject.value("LunarDayName").toString();
     }
     if (jsonObject.contains("LunarMonthName")) {
+        // qCDebug(CommonLogger) << "Found and setting LunarMonthName.";
         this->mLunarMonthName = jsonObject.value("LunarMonthName").toString();
     }
     if (jsonObject.contains("GanZhiDay")) {
+        // qCDebug(CommonLogger) << "Found and setting GanZhiDay.";
         this->mGanZhiDay = jsonObject.value("GanZhiDay").toString();
     }
     if (jsonObject.contains("GanZhiMonth")) {
+        // qCDebug(CommonLogger) << "Found and setting GanZhiMonth.";
         this->mGanZhiMonth = jsonObject.value("GanZhiMonth").toString();
     }
     if (jsonObject.contains("GanZhiYear")) {
+        // qCDebug(CommonLogger) << "Found and setting GanZhiYear.";
         this->mGanZhiYear = jsonObject.value("GanZhiYear").toString();
     }
 }
 
 QDebug operator<<(QDebug argument, const CaHuangLiDayInfo &what)
 {
+    // qCDebug(CommonLogger) << "Streaming CaHuangLiDayInfo to QDebug.";
     argument << what.mSuit << what.mAvoid;
     argument << what.mWorktime;
     argument << what.mLunarFestival << what.mSolarFestival;
@@ -189,6 +217,7 @@ QDebug operator<<(QDebug argument, const CaHuangLiDayInfo &what)
 
 QDBusArgument &operator<<(QDBusArgument &argument, const CaHuangLiDayInfo &what)
 {
+    // qCDebug(CommonLogger) << "Streaming CaHuangLiDayInfo to QDBusArgument.";
     argument.beginStructure();
     argument << what.mSuit << what.mAvoid;
     argument << what.mWorktime;
@@ -203,6 +232,7 @@ QDBusArgument &operator<<(QDBusArgument &argument, const CaHuangLiDayInfo &what)
 
 const QDBusArgument &operator>>(const QDBusArgument &argument, CaHuangLiDayInfo &what)
 {
+    // qCDebug(CommonLogger) << "Streaming CaHuangLiDayInfo from QDBusArgument.";
     argument.beginStructure();
     argument >> what.mSuit >> what.mAvoid;
     argument >> what.mWorktime;
@@ -217,18 +247,21 @@ const QDBusArgument &operator>>(const QDBusArgument &argument, CaHuangLiDayInfo
 
 void CaHuangLiMonthInfo::registerMetaType()
 {
+    // qCDebug(CommonLogger) << "Registering CaHuangLiMonthInfo meta type.";
     qRegisterMetaType<CaHuangLiMonthInfo>();
     qDBusRegisterMetaType<CaHuangLiMonthInfo>();
 }
 
 QString CaHuangLiMonthInfo::toJson()
 {
+    // qCDebug(CommonLogger) << "Converting CaHuangLiMonthInfo to JSON string.";
     QJsonArray daysarr;
     QJsonDocument doc;
     QJsonObject obj;
     obj.insert("Days", mDays);
     obj.insert("FirstDayWeek", mFirstDayWeek);
     foreach (CaHuangLiDayInfo dayinfo, mCaLunarDayInfo) {
+        // qCDebug(CommonLogger) << "Processing a day's info for JSON conversion.";
         QJsonObject dayobj;
         dayobj.insert("Suit", dayinfo.mSuit);
         dayobj.insert("Avoid", dayinfo.mAvoid);
@@ -253,11 +286,13 @@ QString CaHuangLiMonthInfo::toJson()
 
 void CaHuangLiMonthInfo::strJsonToInfo(const QString &strJson, bool &isVaild)
 {
+    // qCDebug(CommonLogger) << "Parsing CaHuangLiMonthInfo from JSON string.";
     isVaild = true;
     QJsonParseError json_error;
     QJsonDocument jsonDoc(QJsonDocument::fromJson(strJson.toLocal8Bit(), &json_error));
 
     if (json_error.error != QJsonParseError::NoError) {
+        // qCDebug(CommonLogger) << "JSON parse error:" << json_error.errorString();
         isVaild = false;
         return;
     }
@@ -266,14 +301,18 @@ void CaHuangLiMonthInfo::strJsonToInfo(const QString &strJson, bool &isVaild)
 
     //因为是预先定义好的JSON数据格式，所以这里可以这样读取
     if (rootObj.contains("Days")) {
+        // qCDebug(CommonLogger) << "Found and setting Days.";
         this->mDays = rootObj.value("Days").toInt();
     }
     if (rootObj.contains("FirstDayWeek")) {
+        // qCDebug(CommonLogger) << "Found and setting FirstDayWeek.";
         this->mFirstDayWeek = rootObj.value("FirstDayWeek").toInt();
     }
     if (rootObj.contains("Datas")) {
+        // qCDebug(CommonLogger) << "Found and processing Datas array.";
         QJsonArray subArray = rootObj.value("Datas").toArray();
         for (int i = 0; i < subArray.size(); i++) {
+            // qCDebug(CommonLogger) << "Processing array item at index" << i;
             QJsonObject subObj = subArray.at(i).toObject();
             CaHuangLiDayInfo huangliday;
             huangliday.jsonObjectToInfo(subObj);
@@ -284,12 +323,14 @@ void CaHuangLiMonthInfo::strJsonToInfo(const QString &strJson, bool &isVaild)
 
 void CaHuangLiMonthInfo::clear()
 {
+    // qCDebug(CommonLogger) << "Clearing CaHuangLiMonthInfo.";
     this->mDays = 0;
     this->mCaLunarDayInfo.clear();
 }
 
 QDebug operator<<(QDebug argument, const CaHuangLiMonthInfo &what)
 {
+    // qCDebug(CommonLogger) << "Streaming CaHuangLiMonthInfo to QDebug.";
     argument << what.mDays << what.mFirstDayWeek;
     argument << what.mCaLunarDayInfo;
 
@@ -298,6 +339,7 @@ QDebug operator<<(QDebug argument, const CaHuangLiMonthInfo &what)
 
 QDBusArgument &operator<<(QDBusArgument &argument, const CaHuangLiMonthInfo &what)
 {
+    // qCDebug(CommonLogger) << "Streaming CaHuangLiMonthInfo to QDBusArgument.";
     argument.beginStructure();
     argument << what.mDays << what.mFirstDayWeek;
     argument << what.mCaLunarDayInfo;
@@ -308,6 +350,7 @@ QDBusArgument &operator<<(QDBusArgument &argument, const CaHuangLiMonthInfo &wha
 
 const QDBusArgument &operator>>(const QDBusArgument &argument, CaHuangLiMonthInfo &what)
 {
+    // qCDebug(CommonLogger) << "Streaming CaHuangLiMonthInfo from QDBusArgument.";
     argument.beginStructure();
     argument >> what.mDays >> what.mFirstDayWeek;
     argument >> what.mCaLunarDayInfo;
diff --git a/calendar-common/src/lunarandfestival/lunarcalendar.cpp b/calendar-common/src/lunarandfestival/lunarcalendar.cpp
index 9ae67de18..38bc530aa 100644
--- a/calendar-common/src/lunarandfestival/lunarcalendar.cpp
+++ b/calendar-common/src/lunarandfestival/lunarcalendar.cpp
@@ -3,6 +3,7 @@
 // SPDX-License-Identifier: LGPL-3.0-or-later
 
 #include "lunarcalendar.h"
+#include "commondef.h"
 
 #include <QTime>
 #include <QDateTime>
@@ -12,11 +13,14 @@ QMap<int, LunarCalendar *> LunarCalendar::glYearCache;
 
 LunarCalendar *LunarCalendar::GetLunarCalendar(qint32 year)
 {
+    // qCDebug(CommonLogger) << "Getting lunar calendar for year:" << year;
     auto it = glYearCache.find(year);
     LunarCalendar *plcal = nullptr;
     if (it != glYearCache.end()) {
+        // qCDebug(CommonLogger) << "Found calendar in cache.";
         plcal = it.value();
     } else {
+        // qCDebug(CommonLogger) << "Calendar not in cache, creating new instance.";
         plcal = new LunarCalendar(year);
         glYearCache.insert(year, plcal);
     }
@@ -28,6 +32,7 @@ LunarCalendar *LunarCalendar::GetLunarCalendar(qint32 year)
  */
 void LunarCalendar::LogOffEmptyData()
 {
+    qCDebug(CommonLogger) << "Clearing all cached lunar calendars.";
     QMap<int, LunarCalendar *>::iterator it = glYearCache.begin();
     for (; it != glYearCache.end(); ++it) {
         delete it.value();
@@ -39,6 +44,7 @@ void LunarCalendar::LogOffEmptyData()
 //指定年份内公历日期转换为农历日
 lunarInfo LunarCalendar::SolarDayToLunarDay(qint32 month, qint32 day)
 {
+    // qCDebug(CommonLogger) << "Converting solar day to lunar day for:" << Year << month << day;
     lunarInfo dayinfo;
     QDateTime dt(QDate(Year, month, day), QTime(0, 0, 0, 0), Qt::TimeSpec::UTC);
     int yd = dt.date().dayOfYear();
@@ -74,6 +80,7 @@ lunarInfo LunarCalendar::SolarDayToLunarDay(qint32 month, qint32 day)
 
 LunarCalendar::LunarCalendar(qint32 year)
 {
+    // qCDebug(CommonLogger) << "Constructing LunarCalendar for year:" << year;
     Year = year;
     Months.reserve(13);
     calcProcData();
@@ -83,6 +90,7 @@ LunarCalendar::LunarCalendar(qint32 year)
 
 void LunarCalendar::calcProcData()
 {
+    // qCDebug(CommonLogger) << "Calculating process data for year:" << Year;
     SolarTermJDs = get25SolarTermJDs(Year - 1, DongZhi);
     for (int i = 0; i < 25; i++) {
         SolarTermTimes.append(GetDateTimeFromJulianDay(SolarTermJDs[i]));
@@ -101,6 +109,7 @@ void LunarCalendar::calcProcData()
 
 void LunarCalendar::fillMonths()
 {
+    // qCDebug(CommonLogger) << "Filling months for year:" << Year;
     //采用夏历建寅，冬至所在月份为农历11月(冬月)
     int yuejian = 11;
     for (int i = 0; i < 14; i++) {
@@ -125,6 +134,7 @@ void LunarCalendar::fillMonths()
 
 void LunarCalendar::calcLeapMonth()
 {
+    // qCDebug(CommonLogger) << "Calculating leap month for year:" << Year;
     // 根据节气计算是否有闰月，如果有闰月，根据农历月命名规则，调整月名称
     if (int(NewMoonJDs[13] + 0.5) <= int(SolarTermJDs[24] + 0.5)) {
         // 第13月的月末没有超过冬至，说明今年需要闰一个月
@@ -139,7 +149,7 @@ void LunarCalendar::calcLeapMonth()
         }
         if (i < 14) {
             // 找到闰月
-            //qCDebug(ServiceLogger)<<QString("找到闰月 %1").arg(i);
+            //qCDebug(CommonLogger)<<QString("找到闰月 %1").arg(i);
             Months[i].IsLeap = true;
             // 对后面的农历月调整月名
             while (i < 14) {
@@ -152,6 +162,7 @@ void LunarCalendar::calcLeapMonth()
 
 qint32 LunarCalendar::getSolarTermInfo(qint32 month, qint32 day) const
 {
+    // qCDebug(CommonLogger) << "Getting solar term info for:" << month << day;
     int index = 2 * month - 1;
     qint32 SolarTerm = -1;
     QDateTime dt1 = SolarTermTimes[index];
@@ -161,5 +172,6 @@ qint32 LunarCalendar::getSolarTermInfo(qint32 month, qint32 day) const
     } else if (dt2.date().day() == day) {
         SolarTerm = (index + 1 + DongZhi) % 24;
     }
+    // qCDebug(CommonLogger) << "Solar term found:" << SolarTerm;
     return SolarTerm;
 }
diff --git a/calendar-common/src/lunarandfestival/lunardateinfo.cpp b/calendar-common/src/lunarandfestival/lunardateinfo.cpp
index 04b75f766..a2ec6d921 100644
--- a/calendar-common/src/lunarandfestival/lunardateinfo.cpp
+++ b/calendar-common/src/lunarandfestival/lunardateinfo.cpp
@@ -16,15 +16,17 @@ LunarDateInfo::LunarDateInfo(KCalendarCore::RecurrenceRule *rruleStr, const qint
     : m_recurenceRule(rruleStr)
     , m_dateInterval(interval)
 {
+    // qCDebug(CommonLogger) << "LunarDateInfo constructor called.";
     m_rruleType = ParseRRule(m_recurenceRule->rrule());
 }
 
 QMap<int, QDate> LunarDateInfo::getRRuleStartDate(const QDate &beginDate, const QDate &endDate, const QDate &solarDate)
 {
+    // qCDebug(CommonLogger) << "Getting RRule start date for solar date:" << solarDate << "within range" << beginDate << "to" << endDate;
     QMap<int, QDate> solar;
     //不在范围内直接返回,开始时间小于结束时间或者需要计算的起始时间晚于结束时间
     if (endDate < beginDate || solarDate > endDate) {
-        qCWarning(ServiceLogger) << "Invalid date range: end date" << endDate.toString() 
+        qCWarning(CommonLogger) << "Invalid date range: end date" << endDate.toString() 
                                 << "is before begin date" << beginDate.toString() 
                                 << "or solar date" << solarDate.toString() << "is after end date";
         return solar;
@@ -35,7 +37,7 @@ QMap<int, QDate> LunarDateInfo::getRRuleStartDate(const QDate &beginDate, const
     //如果日程开始时间在查询起始时间之前
     if (solarDate > m_queryStartDate) {
         m_queryStartDate = solarDate;
-        qCDebug(ServiceLogger) << "Adjusted query start date to solar date:" << solarDate.toString();
+        qCDebug(CommonLogger) << "Adjusted query start date to solar date:" << solarDate.toString();
     }
     //如果是农历日程
     //TODO: 重复类型
@@ -53,13 +55,14 @@ QMap<int, QDate> LunarDateInfo::getRRuleStartDate(const QDate &beginDate, const
         break;
     }
 
+    // qCDebug(CommonLogger) << "Found" << solar.size() << "RRule start dates.";
     return solar;
 }
 
 //通过公历时间获取范围内该时间的农历天的具体公历日期
 QMap<int, QDate> LunarDateInfo::getAllNextMonthLunarDayBySolar(const QDate &solarDate)
 {
-    qCDebug(ServiceLogger) << "Getting next month lunar days for solar date:" << solarDate.toString();
+    qCDebug(CommonLogger) << "Getting next month lunar days for solar date:" << solarDate.toString();
     QMap<int, QDate> solar;
     //如果需要通过公历信息获取下一个对应农历信息对应的天
 
@@ -73,7 +76,7 @@ QMap<int, QDate> LunarDateInfo::getAllNextMonthLunarDayBySolar(const QDate &sola
 
         //如果超过范围则退出
         if (addSolarMap(solar, nextSolar, count, info.LunarMonthDays)) {
-            qCDebug(ServiceLogger) << "Month recurrence calculation completed. Found" << solar.size() << "dates";
+            qCDebug(CommonLogger) << "Month recurrence calculation completed. Found" << solar.size() << "dates";
             break;
         }
     }
@@ -82,7 +85,7 @@ QMap<int, QDate> LunarDateInfo::getAllNextMonthLunarDayBySolar(const QDate &sola
 
 QMap<int, QDate> LunarDateInfo::getAllNextYearLunarDayBySolar(const QDate &solarDate)
 {
-    qCDebug(ServiceLogger) << "Getting next year lunar days for solar date:" << solarDate.toString();
+    qCDebug(CommonLogger) << "Getting next year lunar days for solar date:" << solarDate.toString();
     QMap<int, QDate> solar;
 
     //TODO: 需要优化
@@ -167,19 +170,19 @@ QMap<int, QDate> LunarDateInfo::getAllNextYearLunarDayBySolar(const QDate &solar
             continue;
         }
     }
-    qCDebug(ServiceLogger) << "Year recurrence calculation completed. Found" << solar.size() << "dates";
+    qCDebug(CommonLogger) << "Year recurrence calculation completed. Found" << solar.size() << "dates";
     return solar;
 }
 
 lunarInfo LunarDateInfo::getNextMonthLunarDay(QDate &nextDate, const lunarInfo &info)
 {
-    qCDebug(ServiceLogger) << "Getting next month lunar day for date:" << nextDate.toString();
+    qCDebug(CommonLogger) << "Getting next month lunar day for date:" << nextDate.toString();
     LunarCalendar *lunc = LunarCalendar::GetLunarCalendar(nextDate.year());
     lunarInfo nextinfo = lunc->SolarDayToLunarDay(nextDate.month(), nextDate.day());
     //判断农历的天是否为重复的天，比如一月初一，加上一月份的天数应该为二月初一
     //如果不一样，则说明这个月没有这一天，比如正月三十，加上正月的月份天数，到了二月份是没有三十的，
     if (nextinfo.LunarDay != info.LunarDay) {
-        qCDebug(ServiceLogger) << "Adjusting date due to lunar day mismatch. Expected:" << info.LunarDay 
+        qCDebug(CommonLogger) << "Adjusting date due to lunar day mismatch. Expected:" << info.LunarDay 
                               << "Got:" << nextinfo.LunarDay;
         nextDate = nextDate.addDays(info.LunarDay - nextinfo.LunarDay);
         return getNextMonthLunarDay(nextDate, info);
@@ -196,25 +199,26 @@ LunarDateInfo::LunnarRRule LunarDateInfo::ParseRRule(const QString &rule)
 {
     //无规则的不走这里判断所以此处默认rule不为空
     //局部变量初始化
-    qCDebug(ServiceLogger) << "Parsing recurrence rule:" << rule;
+    qCDebug(CommonLogger) << "Parsing recurrence rule:" << rule;
     LunnarRRule options = RRule_None;
     QStringList rruleslist = rule.split(";", Qt::SkipEmptyParts);
     //rpeat重复规则 0 无  1 每天 2 每个工作日 3 每周 4每月 5每年
     //type结束重复类型 0 永不 1  多少次结束  2 结束日期
     if (rruleslist.contains("FREQ=MONTHLY")) {
         options = RRule_Month;
-        qCDebug(ServiceLogger) << "Detected monthly recurrence rule";
+        qCDebug(CommonLogger) << "Detected monthly recurrence rule";
     } else if (rruleslist.contains("FREQ=YEARLY")) {
         options = RRule_Year;
-        qCDebug(ServiceLogger) << "Detected yearly recurrence rule";
+        qCDebug(CommonLogger) << "Detected yearly recurrence rule";
     } else {
-        qCDebug(ServiceLogger) << "No specific recurrence rule detected";
+        qCDebug(CommonLogger) << "No specific recurrence rule detected";
     }
     return options;
 }
 
 bool LunarDateInfo::isWithinTimeFrame(const QDate &solarDate)
 {
+    // qCDebug(CommonLogger) << "Checking if" << solarDate << "is within the time frame.";
     QDate endDate = solarDate.addDays(m_dateInterval);
     //如果日程结束时间在查询起始时间之前，或者日程开始时间在查询截止时间之后，说明不在获取范围内
     return !(endDate < m_queryStartDate || solarDate > m_queryEndDate);
@@ -222,8 +226,10 @@ bool LunarDateInfo::isWithinTimeFrame(const QDate &solarDate)
 
 bool LunarDateInfo::addSolarMap(QMap<int, QDate> &solarMap, QDate &nextDate, int &count, const int addDays)
 {
+    qCDebug(CommonLogger) << "Attempting to add" << nextDate << "to solar map. Count:" << count;
     //如果获取到的时间在查询范围内
     if (isWithinTimeFrame(nextDate)) {
+        qCDebug(CommonLogger) << "Adding" << nextDate << "to solar map. Count:" << count;
         solarMap[count] = nextDate;
     }
     count++;
@@ -231,6 +237,7 @@ bool LunarDateInfo::addSolarMap(QMap<int, QDate> &solarMap, QDate &nextDate, int
     //    当重复次数达到最大限制直接返回
     //    duration > 0 表示结束与次数
     if ((m_recurenceRule->duration() > 0 && (m_recurenceRule->duration() - 1) < count) || count > RECURENCELIMIT) {
+        qCDebug(CommonLogger) << "Stopping recurrence due to limit reached.";
         return true;
     }
 
@@ -241,6 +248,7 @@ bool LunarDateInfo::addSolarMap(QMap<int, QDate> &solarMap, QDate &nextDate, int
     //判断next是否大于查询的截止时间,这里应该比较date，而不是datetime，如果是非全天的日程，这个设计具体时间的问题，会导致返回的job个数出现问题
     if ((m_recurenceRule->duration() == 0 && nextDate > m_recurenceRule->endDt().date())
             || nextDate > m_queryEndDate) {
+        qCDebug(CommonLogger) << "Stopping recurrence due to end date reached.";
         return true;
     }
     return false;
diff --git a/calendar-common/src/lunarandfestival/lunarmanager.cpp b/calendar-common/src/lunarandfestival/lunarmanager.cpp
index d92b9c1e4..a36077881 100644
--- a/calendar-common/src/lunarandfestival/lunarmanager.cpp
+++ b/calendar-common/src/lunarandfestival/lunarmanager.cpp
@@ -11,6 +11,7 @@
 
 stLunarDayInfo SolarToLunar(qint32 year, qint32 month, qint32 day)
 {
+    // qCDebug(CommonLogger) << "Converting solar to lunar for date:" << year << month << day;
     stLunarDayInfo info;
     LunarCalendar *pcalendar = LunarCalendar::GetLunarCalendar(year);
     lunarInfo lday = pcalendar->SolarDayToLunarDay(month, day);
@@ -33,12 +34,14 @@ stLunarDayInfo SolarToLunar(qint32 year, qint32 month, qint32 day)
  */
 LunarMonthInfo GetLunarMonthCalendar(qint32 year, qint32 month, bool fill)
 {
+    // qCDebug(CommonLogger) << "Getting lunar month calendar for:" << year << month << "with fill:" << fill;
     SolarMonthInfo solarMonth = GetSolarMonthCalendar(year, month, fill);
     return GetLunarMonthCalendar(solarMonth);
 }
 
 LunarMonthInfo GetLunarMonthCalendar(const SolarMonthInfo &solarMonth)
 {
+    // qCDebug(CommonLogger) << "Converting solar month calendar to lunar month calendar.";
     LunarMonthInfo lunarmonth;
     lunarmonth.FirstDayWeek = solarMonth.FirstDayWeek;
     lunarmonth.Days = solarMonth.Days;
@@ -56,6 +59,7 @@ LunarMonthInfo GetLunarMonthCalendar(const SolarMonthInfo &solarMonth)
  */
 SolarMonthInfo GetSolarMonthCalendar(qint32 year, qint32 month, bool fill)
 {
+    qCDebug(CommonLogger) << "Getting solar month calendar for:" << year << month << "with fill:" << fill;
     SolarMonthInfo solarMonth;
     int weekday = GetWeekday(year, month);
     int daycount = GetSolarMonthDays(year, month);
@@ -92,6 +96,7 @@ SolarMonthInfo GetSolarMonthCalendar(qint32 year, qint32 month, bool fill)
 
 QList<stDay> GetMonthDays(qint32 year, qint32 month, qint32 start, qint32 days)
 {
+    // qCDebug(CommonLogger) << "Getting month days for:" << year << month << "from" << start << "to" << days;
     QList<stDay> DayInfo;
     for (int day = start; day <= days; day++) {
         stDay stday = {year, month, day};
@@ -102,6 +107,7 @@ QList<stDay> GetMonthDays(qint32 year, qint32 month, qint32 start, qint32 days)
 
 QList<int> GetPreMonth(qint32 year, qint32 month)
 {
+    // qCDebug(CommonLogger) << "Getting previous month for:" << year << month;
     QList<int> datas;
     int preYear, preMonth;
     if (month == 1) {
@@ -118,6 +124,7 @@ QList<int> GetPreMonth(qint32 year, qint32 month)
 
 QList<int> GetNextMonth(qint32 year, qint32 month)
 {
+    // qCDebug(CommonLogger) << "Getting next month for:" << year << month;
     QList<int> datas;
     int nextYear, nextMonth;
     if (month == 12) {
@@ -139,12 +146,12 @@ QList<int> GetNextMonth(qint32 year, qint32 month)
  */
 QList<stDayFestival> GetFestivalsInRange(const QDateTime &start, const QDateTime &end)
 {
-    qCDebug(ServiceLogger) << "Getting festivals in range:" << start.toString() << "to" << end.toString();
+    qCDebug(CommonLogger) << "Getting festivals in range:" << start.toString() << "to" << end.toString();
     QList<stDayFestival> festivaldays;
     if (start <= end) {
         //days为需要查询的天数,而不是两个时间的差值
         int days = static_cast<int>(start.daysTo(end) + 1);
-        qCDebug(ServiceLogger) << "Calculating festivals for" << days << "days";
+        qCDebug(CommonLogger) << "Calculating festivals for" << days << "days";
         for (int i = 0; i < days; ++i) {
             stDayFestival stdayfestival;
             QDateTime tem = start.addDays(i);
@@ -161,9 +168,9 @@ QList<stDayFestival> GetFestivalsInRange(const QDateTime &start, const QDateTime
             festivaldays.append(stdayfestival);
         }
     } else {
-        qCWarning(ServiceLogger) << "Invalid date range: start date" << start.toString() << "is later than end date" << end.toString();
+        qCWarning(CommonLogger) << "Invalid date range: start date" << start.toString() << "is later than end date" << end.toString();
     }
-    qCDebug(ServiceLogger) << "Found" << festivaldays.size() << "festivals in the specified range";
+    qCDebug(CommonLogger) << "Found" << festivaldays.size() << "festivals in the specified range";
     return festivaldays;
 }
 /**
@@ -174,7 +181,7 @@ QList<stDayFestival> GetFestivalsInRange(const QDateTime &start, const QDateTime
  */
 QList<stDayFestival> FilterDayFestival(QList<stDayFestival> &festivaldays, const QString &querykey)
 {
-    qCDebug(ServiceLogger) << "Filtering festivals with query key:" << querykey;
+    qCDebug(CommonLogger) << "Filtering festivals with query key:" << querykey;
     QList<stDayFestival> m_festivaldays;
     pinyinsearch *search = pinyinsearch::getPinPinSearch();
 
@@ -196,11 +203,12 @@ QList<stDayFestival> FilterDayFestival(QList<stDayFestival> &festivaldays, const
         m_festivals.date = festivalsdate;
         m_festivaldays.append(m_festivals);
     }
-    qCDebug(ServiceLogger) << "Filtered festivals count:" << m_festivaldays.size();
+    qCDebug(CommonLogger) << "Filtered festivals count:" << m_festivaldays.size();
     return m_festivaldays;
 }
 
 void logOffEmptyData()
 {
+    // qCDebug(CommonLogger) << "Logging off empty data from LunarCalendar.";
     LunarCalendar::LogOffEmptyData();
 }
diff --git a/calendar-common/src/lunarandfestival/method_interface.cpp b/calendar-common/src/lunarandfestival/method_interface.cpp
index 4d3084730..c34a15618 100644
--- a/calendar-common/src/lunarandfestival/method_interface.cpp
+++ b/calendar-common/src/lunarandfestival/method_interface.cpp
@@ -3,6 +3,7 @@
 // SPDX-License-Identifier: LGPL-3.0-or-later
 
 #include "method_interface.h"
+#include "commondef.h"
 
 #include <QtMath>
 #include <QDebug>
@@ -15,6 +16,7 @@
  */
 QString GetLunarMonthName(int lunarmonthname, bool isleap)
 {
+    // qCDebug(CommonLogger) << "Getting lunar month name for month:" << lunarmonthname << "isLeap:" << isleap;
     QString monthname = lunarMonthNames[lunarmonthname - 1];
     if (isleap) {
         return "闰" + monthname + "月";
@@ -29,6 +31,7 @@ QString GetLunarMonthName(int lunarmonthname, bool isleap)
  */
 QString GetLunarDayName(int lundayname)
 {
+    // qCDebug(CommonLogger) << "Getting lunar day name for day:" << lundayname;
     return lunarDayNames[lundayname - 1];
 }
 
@@ -42,6 +45,7 @@ QString GetLunarDayName(int lundayname)
  */
 QString GetLunarDayFestival(int monthname, int lunarday, int lunarmonthdays, int solarterm)
 {
+    // qCDebug(CommonLogger) << "Getting lunar day festival for:" << monthname << lunarday;
     int key = monthname * 100 + lunarday;
     if (lunarFestival.contains(key)) {
         return lunarFestival[key];
@@ -63,6 +67,7 @@ QString GetLunarDayFestival(int monthname, int lunarday, int lunarmonthdays, int
  */
 QString GetSolarTermName(int order)
 {
+    // qCDebug(CommonLogger) << "Getting solar term name for order:" << order;
     if (0 <= order && order <= 23) {
         return SolarTermNames[order];
     }
@@ -75,6 +80,7 @@ QString GetSolarTermName(int order)
  */
 QString GetTianGanDiZhi(int num)
 {
+    // qCDebug(CommonLogger) << "Getting TianGanDiZhi for num:" << num;
     return TianGan[num % 10] + DiZhi[num % 12];
 }
 
@@ -86,6 +92,7 @@ QString GetTianGanDiZhi(int num)
  */
 QString GetGanZhiMonth(int year, int monthzhi)
 {
+    // qCDebug(CommonLogger) << "Getting GanZhi month for year:" << year << "monthzhi:" << monthzhi;
     return GetTianGanDiZhi((year - 1900) * 12 + monthzhi + 12);
 }
 
@@ -96,6 +103,7 @@ QString GetGanZhiMonth(int year, int monthzhi)
  */
 QString GetGanZhiYear(int lunaryear)
 {
+    // qCDebug(CommonLogger) << "Getting GanZhi year for lunar year:" << lunaryear;
     return GetTianGanDiZhi(lunaryear - 1864);
 }
 
@@ -108,6 +116,7 @@ QString GetGanZhiYear(int lunaryear)
  */
 QString GetGanZhiDay(int year, int month, int day)
 {
+    // qCDebug(CommonLogger) << "Getting GanZhi day for:" << year << month << day;
     QDateTime unixDateTime = QDateTime(QDate(year, month, day), QTime(0, 0, 0, 0), Qt::TimeSpec::UTC);
     qint64 unixTime = unixDateTime.toMSecsSinceEpoch() / 1000;
     int dayCyclical = int(unixTime / 86400) + 29219 + 18;
@@ -121,11 +130,13 @@ QString GetGanZhiDay(int year, int month, int day)
  */
 QString GetYearZodiac(int lunaryear)
 {
+    // qCDebug(CommonLogger) << "Getting year zodiac for lunar year:" << lunaryear;
     return Animals[(lunaryear - 4) % 12];
 }
 
 QVector<double> get25SolarTermJDs(int year, int start)
 {
+    // qCDebug(CommonLogger) << "Getting 25 solar term JDs starting from year:" << year << "start:" << start;
     // 从某一年的某个节气开始，连续计算25个节气，返回各节气的儒略日
     // year 年份
     // start 起始的节气
@@ -146,6 +157,7 @@ QVector<double> get25SolarTermJDs(int year, int start)
 
 double GetEarthEclipticLongitudeForSun(double jd)
 {
+    // qCDebug(CommonLogger) << "Calculating Earth's heliocentric ecliptic longitude for JD:" << jd;
     // 计算地球的日心黄经
     double l = GetSunEclipticLongitudeForEarth(jd);
     // 计算地球的日心黄纬
@@ -172,6 +184,7 @@ double GetEarthEclipticLongitudeForSun(double jd)
  */
 double GetSunEclipticLongitudeForEarth(double jd)
 {
+    // qCDebug(CommonLogger) << "Calculating Sun's ecliptic longitude for Earth for JD:" << jd;
     double t = GetJulianThousandYears(jd);
     double L0 = GetEarthL0(t);
     double L1 = GetEarthL1(t);
@@ -185,6 +198,7 @@ double GetSunEclipticLongitudeForEarth(double jd)
 
 double GetJulianThousandYears(double jd)
 {
+    // qCDebug(CommonLogger) << "Getting Julian thousand years for JD:" << jd;
     //1000年的日数
     const double  DaysOf1000Years = 365250.0;
     return (jd - J2000) / DaysOf1000Years;
@@ -198,6 +212,7 @@ double GetJulianThousandYears(double jd)
  */
 double GetSunEclipticLatitudeForEarth(double jd)
 {
+    // qCDebug(CommonLogger) << "Calculating Sun's ecliptic latitude for Earth for JD:" << jd;
     double t = GetJulianThousandYears(jd);
     double B0 = GetEarthB0(t);
     double B1 = GetEarthB1(t);
@@ -222,6 +237,7 @@ double GetSunEclipticLatitudeForEarth(double jd)
  */
 double Vsop2Fk5LongitudeCorrection(double l, double b, double jd)
 {
+    // qCDebug(CommonLogger) << "Applying VSOP87 to FK5 longitude correction.";
     double t = GetJulianCentury(jd);
     double lp = l - ToRadians(1.397) * t - ToRadians(0.00031) * t * t;
     return SecondsToRadians(-0.09033 + 0.03916 * (qCos(lp) + qSin(lp)) * qTan(b));
@@ -235,6 +251,7 @@ double Vsop2Fk5LongitudeCorrection(double l, double b, double jd)
  */
 double GetSunRadiusForEarth(double jd)
 {
+    // qCDebug(CommonLogger) << "Calculating Sun-Earth radius for JD:" << jd;
     double t = GetJulianThousandYears(jd);
     double R0 = GetEarthR0(t);
     double R1 = GetEarthR1(t);
@@ -248,6 +265,7 @@ double GetSunRadiusForEarth(double jd)
 
 double NewtonIteration(double angle, double x0, bool IsGetSolarTermJD)
 {
+    // qCDebug(CommonLogger) << "Performing Newton iteration. Angle:" << angle << "x0:" << x0 << "IsGetSolarTermJD:" << IsGetSolarTermJD;
     //此函数原是传入的匿名函数，这里用bool用作区分，后续可以优化
     const double Epsilon = 1e-7;
     const double Delta = 5e-6;
@@ -312,6 +330,7 @@ double DmsToSeconds(int d, int m, double s)
 // DmsToRadians 把度分秒表示的角度换算成弧度(rad)
 double DmsToRadians(int d, int m, int s)
 {
+    // qCDebug(CommonLogger) << "Converting DMS to radians:" << d << m << s;
     return ToRadians(DmsToDegrees(d, m, s));
 }
 
@@ -322,6 +341,7 @@ double DmsToRadians(int d, int m, int s)
 // 返回 节气的儒略日力学时间 TD
 double GetSolarTermJD(int year, int order)
 {
+    // qCDebug(CommonLogger) << "Getting solar term JD for year:" << year << "order:" << order;
     const double RADIANS_PER_TERM = M_PI / 12.0;
     double angle = double(order) * RADIANS_PER_TERM;
     int month = ((order + 1) / 2 + 2) % 12 + 1;
@@ -339,12 +359,14 @@ double GetSolarTermJD(int year, int order)
 // IsLeapYear 公历闰年判断
 bool IsLeapYear(int year)
 {
+    // qCDebug(CommonLogger) << "Checking if year is leap:" << year;
     return ((year & 3) == 0 && year % 100 != 0) || year % 400 == 0;
 }
 
 // GetSolarMonthDays 获取公历月份的天数
 int GetSolarMonthDays(int year, int month)
 {
+    // qCDebug(CommonLogger) << "Getting solar month days for:" << year << month;
     if (month == 2 && IsLeapYear(year)) {
         return 29;
     } else {
@@ -357,6 +379,7 @@ int GetSolarMonthDays(int year, int month)
 // 返回星期几的数字表示，1-6表示星期一到星期六，0表示星期日
 int GetWeekday(int y, int m, int d)
 {
+    // qCDebug(CommonLogger) << "Getting weekday for:" << y << m << d;
     if (m <= 2) {
         y -= 1;
         m += 12;
@@ -375,6 +398,7 @@ int GetWeekday(int y, int m, int d)
 // ∆T = TT - UT 此算法在-1999年到3000年有效
 double GetDeltaT(int year, int month)
 {
+    // qCDebug(CommonLogger) << "Getting Delta T for:" << year << month;
     double y = double(year) + (double(month) - 0.5) / 12;
 
     if (year < -500) {
@@ -469,6 +493,7 @@ double GetDeltaT(int year, int month)
 // GetDateFromJulianDay 从儒略日中获取公历的日期
 void GetDateFromJulianDay(double jd, int &yy, int &mm, int &dd)
 {
+    // qCDebug(CommonLogger) << "Getting date from Julian Day:" << jd;
     /*
      * This algorithm is taken from
      * "Numerical Recipes in c, 2nd Ed." (1992), pp. 14-15
@@ -519,6 +544,7 @@ void GetDateFromJulianDay(double jd, int &yy, int &mm, int &dd)
 // GetTimeFromJulianDay 从儒略日中获取时间 时分秒
 void GetTimeFromJulianDay(double jd, int &hour, int &minute, int &second)
 {
+    // qCDebug(CommonLogger) << "Getting time from Julian Day:" << jd;
     double frac = jd - qFloor(jd);
     int s = int(qFloor(frac * 24.0 * 60.0 * 60.0));
 
@@ -531,6 +557,7 @@ void GetTimeFromJulianDay(double jd, int &hour, int &minute, int &second)
 // 其中包含了 TT 到 UTC 的转换
 QDateTime GetDateTimeFromJulianDay(double jd)
 {
+    // qCDebug(CommonLogger) << "Getting QDateTime from Julian Day:" << jd;
     int year, month, day;
     GetDateFromJulianDay(jd, year, month, day);
     //  TT -> UTC
@@ -545,22 +572,26 @@ QDateTime GetDateTimeFromJulianDay(double jd)
 // JDUTC2BeijingTime 儒略日 UTC 时间转换到北京时间
 double JDUTC2BeijingTime(double utcJD)
 {
+    // qCDebug(CommonLogger) << "Converting JD UTC to Beijing Time:" << utcJD;
     return utcJD + 8.0 / 24.0;
 }
 
 // JDBeijingTime2UTC 儒略日 北京时间到 UTC 时间
 double JDBeijingTime2UTC(double bjtJD)
 {
+    // qCDebug(CommonLogger) << "Converting JD Beijing Time to UTC:" << bjtJD;
     return bjtJD - 8.0 / 24.0;
 }
 
 double getNewMoonJD(double jd0)
 {
+    // qCDebug(CommonLogger) << "Getting new moon JD from jd0:" << jd0;
     return NewtonIteration(0, jd0, false);
 }
 
 QVector<double> get15NewMoonJDs(double jd)
 {
+    // qCDebug(CommonLogger) << "Getting 15 new moon JDs from JD:" << jd;
     // 计算从某个时间之后的连续15个朔日
     // 参数: jd 开始时间的 儒略日
     // 返回 15个朔日时间 数组指针 儒略日北京时间
@@ -576,6 +607,7 @@ QVector<double> get15NewMoonJDs(double jd)
 
 qint64 deltaDays(QDateTime t1, QDateTime t2)
 {
+    // qCDebug(CommonLogger) << "Calculating delta days between:" << t1 << "and" << t2;
     // 计算两个时间相差的天数
     // t2 > t1 结果为正数
     return int(t1.date().daysTo(t2.date()));
@@ -584,6 +616,7 @@ qint64 deltaDays(QDateTime t1, QDateTime t2)
 
 QString festivalForFatherAndMother(int year, int month, int day)
 {
+    // qCDebug(CommonLogger) << "Checking for Father's/Mother's day for:" << year << month << day;
     int disparityMotherDay, disparityFatherDay, fatherDay, motherDay;
     int leapYear = 0;
     for (int i = 1900; i <= year; i++) {
@@ -618,6 +651,7 @@ QString festivalForFatherAndMother(int year, int month, int day)
  */
 void GetMoonEclipticParameter(MoonEclipticParameter &moonEclipticParameter, double T)
 {
+    // qCDebug(CommonLogger) << "Getting moon ecliptic parameters for T:" << T;
     double T2 = T * T;
     double T3 = T2 * T;
     double T4 = T3 * T;
@@ -642,6 +676,7 @@ void GetMoonEclipticParameter(MoonEclipticParameter &moonEclipticParameter, doub
  */
 double ToRadians(double degrees)
 {
+    // qCDebug(CommonLogger) << "Converting degrees to radians:" << degrees;
     return degrees * M_PI / 180;
 }
 /**
@@ -651,6 +686,7 @@ double ToRadians(double degrees)
  */
 double Mod2Pi(double r)
 {
+    // qCDebug(CommonLogger) << "Running Mod2Pi on:" << r;
     while (r < 0) {
         r += M_PI * 2;
     }
@@ -666,6 +702,7 @@ double Mod2Pi(double r)
  */
 double CalcMoonECLongitudePeriodic(MoonEclipticParameter &moonEclipticParameter)
 {
+    // qCDebug(CommonLogger) << "Calculating moon ecliptic longitude periodic sum.";
     double EI = 0.0;
     for (int i = 0; i < MoonLongitude.count(); i++) {
         double theta = MoonLongitude[i].D * moonEclipticParameter.D + MoonLongitude[i].M * moonEclipticParameter.M
@@ -682,6 +719,7 @@ double CalcMoonECLongitudePeriodic(MoonEclipticParameter &moonEclipticParameter)
  */
 double CalcMoonLongitudePerturbation(double T, MoonEclipticParameter &moonEclipticParameter)
 {
+    // qCDebug(CommonLogger) << "Calculating moon longitude perturbation for T:" << T;
     double A1 = Mod2Pi(ToRadians(119.75 + 131.849 * T));
     double A2 = Mod2Pi(ToRadians(53.09 + 479264.290 * T));
 
@@ -694,6 +732,7 @@ double CalcMoonLongitudePerturbation(double T, MoonEclipticParameter &moonEclipt
  */
 double GetMoonEclipticLongitudeEC(double julianDay)
 {
+    // qCDebug(CommonLogger) << "Getting moon ecliptic longitude EC for Julian Day:" << julianDay;
     MoonEclipticParameter m_radian;
     double T = GetJulianCentury(julianDay);
     GetMoonEclipticParameter(m_radian, T);
@@ -714,6 +753,7 @@ double GetMoonEclipticLongitudeEC(double julianDay)
  */
 double GetJulianCentury(double julianDay)
 {
+    // qCDebug(CommonLogger) << "Getting Julian century for Julian Day:" << julianDay;
     // 100年的日数
     const double DaysOfCentury = 36525.0;
     return (julianDay - J2000) / DaysOfCentury;
@@ -726,6 +766,7 @@ double GetJulianCentury(double julianDay)
  */
 void GetEarthNutationParameter(EarthNutationParameter &earthNutationParameter, double T)
 {
+    // qCDebug(CommonLogger) << "Getting Earth nutation parameters for T:" << T;
     double T2 = T * T;
     double T3 = T2 * T;
 
@@ -743,6 +784,7 @@ void GetEarthNutationParameter(EarthNutationParameter &earthNutationParameter, d
 
 double CalcEarthLongitudeNutation(double T)
 {
+    // qCDebug(CommonLogger) << "Calculating Earth longitude nutation for T:" << T;
     EarthNutationParameter m_radian;
     GetEarthNutationParameter(m_radian, T);
     double result = 0.0;
@@ -761,16 +803,19 @@ double CalcEarthLongitudeNutation(double T)
  */
 double SecondsToDegrees(double seconds)
 {
+    // qCDebug(CommonLogger) << "Converting seconds to degrees:" << seconds;
     return seconds / 3600;
 }
 
 double SecondsToRadians(double seconds)
 {
+    // qCDebug(CommonLogger) << "Converting seconds to radians:" << seconds;
     return ToRadians(SecondsToDegrees(seconds));
 }
 
 double CalcEarthObliquityNutation(double dt)
 {
+    // qCDebug(CommonLogger) << "Calculating Earth obliquity nutation for dt:" << dt;
     EarthNutationParameter m_radian;
     GetEarthNutationParameter(m_radian, dt);
     double result = 0.0;
@@ -785,12 +830,14 @@ double CalcEarthObliquityNutation(double dt)
 
 double ToJulianDateHMS(int year, int month, int day, int hour, int minute, double second)
 {
+    // qCDebug(CommonLogger) << "Converting HMS to Julian Date:" << year << month << day << hour << minute << second;
     int jdn = ToJulianDate(year, month, day);
     return double(jdn) + (double(hour) - 12) / 24.0 + double(minute) / 1440.0 + second / 86400.0;
 }
 
 int ToJulianDate(int year, int month, int day)
 {
+    // qCDebug(CommonLogger) << "Converting to Julian Date:" << year << month << day;
     int a = (14 - month) / 12;
     int y = year + 4800 - a;
     int m = month + 12 * a - 3;
@@ -799,17 +846,20 @@ int ToJulianDate(int year, int month, int day)
 
 double coefficient()
 {
+    // qCDebug(CommonLogger) << "Getting coefficient.";
     return SecondsToRadians(0.0001);
 }
 
 double lightAberration()
 {
+    // qCDebug(CommonLogger) << "Getting light aberration.";
     return SecondsToRadians(20.4898);
 }
 
 //获取阳历节日
 QString GetSolarDayFestival(int year, int month, int day)
 {
+    // qCDebug(CommonLogger) << "Getting solar day festival for:" << year << month << day;
     QString festivals;
     if ((month == 5) || (month == 6)) {
         QString name = festivalForFatherAndMother(year, month, day);
diff --git a/calendar-common/src/pinyin/pinyinsearch.cpp b/calendar-common/src/pinyin/pinyinsearch.cpp
index b0a705f74..21d1f5d8f 100644
--- a/calendar-common/src/pinyin/pinyinsearch.cpp
+++ b/calendar-common/src/pinyin/pinyinsearch.cpp
@@ -20,6 +20,7 @@ const QString kDictFile = ":/pinyin.dict";
  */
 pinyinsearch::pinyinsearch()
 {
+    qCDebug(CommonLogger) << "pinyinsearch constructor called, initializing valid pinyin map.";
     for (int i = 0; i < validPinyinList.size(); i++) {
         QString key = validPinyinList[i];
         validPinyinMap[key] = true;
@@ -31,7 +32,9 @@ pinyinsearch::pinyinsearch()
 
 pinyinsearch *pinyinsearch::getPinPinSearch()
 {
+    // qCDebug(CommonLogger) << "Getting pinyinsearch instance.";
     if (m_pinyinsearch == nullptr) {
+        qCDebug(CommonLogger) << "pinyinsearch instance is null, creating new one.";
         //new pinyinsearch
         m_pinyinsearch = new pinyinsearch();
         //获取拼音字典
@@ -47,6 +50,7 @@ pinyinsearch *pinyinsearch::getPinPinSearch()
  */
 bool pinyinsearch::CanQueryByPinyin(QString str)
 {
+    // qCDebug(CommonLogger) << "Checking if can query by pinyin:" << str;
 #if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
     QRegularExpression regexp("^[a-zA-Z]+$");
     return regexp.match(str).hasMatch();
@@ -63,6 +67,7 @@ bool pinyinsearch::CanQueryByPinyin(QString str)
  */
 QString pinyinsearch::CreatePinyin(const QString &zh)
 {
+    qCDebug(CommonLogger) << "Creating pinyin for Chinese string:" << zh;
     //返回中文对应的拼音，汉字个数对应QList长度，每个汉字拥有的拼音个数对应QStringList长度
     QList<QStringList> pyList = Pinyin(zh);
     QString pinyinStr;
@@ -73,19 +78,22 @@ QString pinyinsearch::CreatePinyin(const QString &zh)
         if (!pyStr.isEmpty())
             pinyinStr += "[" + pyStr + "]";
     }
+    qCDebug(CommonLogger) << "Created pinyin string:" << pinyinStr;
     return pinyinStr;
 }
 
 void pinyinsearch::initDict()
 {
+    qCDebug(CommonLogger) << "Initializing pinyin dictionary.";
     if (!pinyinDictVector.isEmpty()) {
+        qCDebug(CommonLogger) << "Dictionary already initialized, skipping.";
         return;
     }
 
     QFile file(kDictFile);
 
     if (!file.open(QIODevice::ReadOnly)) {
-        qCWarning(ServiceLogger) << "open dictFile error :" << file.error();
+        qCWarning(CommonLogger) << "open dictFile error :" << file.error();
         return;
     }
 
@@ -100,6 +108,7 @@ void pinyinsearch::initDict()
             pinyinDictVector.insert(items[0].toInt(nullptr, 16), items[1]);
         }
     }
+    qCDebug(CommonLogger) << "Pinyin dictionary initialized with" << pinyinDictVector.size() << "entries.";
 }
 
 /**
@@ -109,6 +118,7 @@ void pinyinsearch::initDict()
  */
 QString pinyinsearch::CreatePinyinQuery(QString pinyin) const
 {
+    // qCDebug(CommonLogger) << "Creating pinyin query for:" << pinyin;
     QString expr;
     //对传入的拼音进行划分，例如：“nihao”->"[%ni%][%hao%]"
     while (pinyin.size() > 0) {
@@ -142,6 +152,7 @@ QString pinyinsearch::CreatePinyinQuery(QString pinyin) const
  */
 QString pinyinsearch::CreatePinyinRegexp(QString pinyin) const
 {
+    // qCDebug(CommonLogger) << "Creating pinyin regexp for:" << pinyin;
     QString expr;
     while (pinyin.size() > 0) {
         int i = singlePinyinMaxLength;
@@ -170,6 +181,7 @@ QString pinyinsearch::CreatePinyinRegexp(QString pinyin) const
  */
 bool pinyinsearch::PinyinMatch(const QString &zh, const QString &py) const
 {
+    qCDebug(CommonLogger) << "Matching pinyin for Chinese:" << zh << "with pinyin:" << py;
     //获取汉字的拼音
     QString zhPinyin = CreatePinyin(zh);
     //获取拼音的正则表达式
@@ -189,6 +201,7 @@ bool pinyinsearch::PinyinMatch(const QString &zh, const QString &py) const
  */
 QList<QStringList> pinyinsearch::Pinyin(QString str)
 {
+    // qCDebug(CommonLogger) << "Getting pinyin for string:" << str;
     QList<QStringList> pys {};
     QStringList py;
     for (int i = 0; i < str.count(); i++) {
@@ -209,6 +222,7 @@ QList<QStringList> pinyinsearch::Pinyin(QString str)
  */
 QStringList pinyinsearch::SinglePinyin(QString index)
 {
+    // qCDebug(CommonLogger) << "Getting single pinyin for character:" << index;
     //通过汉字的编码找到对应的拼音
     QString value;
     //查找对应的拼音
@@ -229,6 +243,7 @@ QStringList pinyinsearch::SinglePinyin(QString index)
  */
 QStringList pinyinsearch::RemoveYin(QStringList pinyin)
 {
+    // qCDebug(CommonLogger) << "Removing tone from pinyin list.";
     QString str;
     QStringList strList;
     //遍历每个拼音
diff --git a/calendar-common/src/units.cpp b/calendar-common/src/units.cpp
index 8c1b4eaec..102ff43d7 100644
--- a/calendar-common/src/units.cpp
+++ b/calendar-common/src/units.cpp
@@ -3,6 +3,7 @@
 // SPDX-License-Identifier: LGPL-3.0-or-later
 
 #include "units.h"
+#include "commondef.h"
 #include <QDir>
 #include <QProcess>
 
@@ -13,12 +14,14 @@
 
 QString dtToString(const QDateTime &dt)
 {
+    // qCDebug(CommonLogger) << "Converting QDateTime to string:" << dt;
     QTime _offsetTime = QTime(0, 0).addSecs(dt.timeZone().offsetFromUtc(dt));
     return QString("%1+%2").arg(dt.toString("yyyy-MM-ddThh:mm:ss")).arg(_offsetTime.toString("hh:mm"));
 }
 
 QDateTime dtConvert(const QDateTime &datetime)
 {
+    // qCDebug(CommonLogger) << "Converting QDateTime:" << datetime;
     QDateTime dt = datetime;
     dt.setOffsetFromUtc(dt.offsetFromUtc());
     return dt;
@@ -26,6 +29,7 @@ QDateTime dtConvert(const QDateTime &datetime)
 
 QDateTime dtFromString(const QString &st)
 {
+    // qCDebug(CommonLogger) << "Converting string to QDateTime:" << st;
     QDateTime &&dtSt = QDateTime::fromString(st, Qt::ISODate);
     //转换为本地时区
     return QDateTime(dtSt.date(),dtSt.time());
@@ -33,29 +37,35 @@ QDateTime dtFromString(const QString &st)
 
 QString getDBPath()
 {
+    // qCDebug(CommonLogger) << "Getting DB path.";
     return getHomeConfigPath().append("/deepin/dde-calendar-service");
 }
 
 QDate dateFromString(const QString &date)
 {
+    // qCDebug(CommonLogger) << "Converting string to QDate:" << date;
     return QDate::fromString(date, Qt::ISODate);
 }
 
 QString dateToString(const QDate &date)
 {
+    // qCDebug(CommonLogger) << "Converting QDate to string:" << date;
     return date.toString("yyyy-MM-dd");
 }
 
 bool isChineseEnv()
 {
+    // qCDebug(CommonLogger) << "Checking for Chinese environment.";
     return QLocale::system().name().startsWith("zh_");
 }
 
 QString getHomeConfigPath()
 {
+    qCDebug(CommonLogger) << "Getting home config path.";
     //根据环境变量获取config目录
     QString configPath = QString(qgetenv("XDG_CONFIG_HOME"));
     if(configPath.trimmed().isEmpty()) {
+        qCDebug(CommonLogger) << "XDG_CONFIG_HOME is empty, using QStandardPaths.";
         configPath = QStandardPaths::writableLocation(QStandardPaths::ConfigLocation);
     }
     return configPath;
@@ -63,16 +73,19 @@ QString getHomeConfigPath()
 
 QDir getAppConfigDir()
 {
+    // qCDebug(CommonLogger) << "Getting app config directory.";
     return QStandardPaths::writableLocation(QStandardPaths::AppConfigLocation);
 }
 
 QDir getAppCacheDir()
 {
+    // qCDebug(CommonLogger) << "Getting app cache directory.";
     return QStandardPaths::writableLocation(QStandardPaths::CacheLocation);
 }
 
 QSharedPointer<QProcess> DownloadFile(QString url, QString filename)
 {
+    qCDebug(CommonLogger) << "Downloading file from" << url << "to" << filename;
     auto process = QSharedPointer<QProcess>::create();
     process->setEnvironment({"LANGUAGE=en"});
     process->start("wget", { "-c", "-N", "-O", filename, url });
@@ -81,6 +94,7 @@ QSharedPointer<QProcess> DownloadFile(QString url, QString filename)
 
 bool withinTimeFrame(const QDate &date)
 {
+    // qCDebug(CommonLogger) << "Checking if date" << date << "is within time frame.";
     return date.isValid() && (date.year() >= 1900 && date.year() <=2100);
 }
 
diff --git a/debian/rules b/debian/rules
index d1a2a8f0a..77d5ecbf3 100755
--- a/debian/rules
+++ b/debian/rules
@@ -10,6 +10,7 @@ export QT_SELECT := 6
 
 %:
 	dh $@
+
 override_dh_auto_configure:
 	dh_auto_configure -- \
 	-DCMAKE_BUILD_TYPE=Release \