vyn/mirai
1
Fork 0
mirror of https://codeberg.org/vyn/mirai.git synced 2025-07-04 10:43:19 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Compare commits

base: vyn:15bd0f58a7c2d3e877d587d54e831dce6a0b7039
Branches Tags
vyn:main
vyn:dev
..
compare: vyn:4bca7fac3ed49e8887c3c99a1c96a142018a77fe
Branches Tags
vyn:main
vyn:dev

No commits in common. "15bd0f58a7c2d3e877d587d54e831dce6a0b7039" and "4bca7fac3ed49e8887c3c99a1c96a142018a77fe" have entirely different histories.
15bd0f58a7 ... 4bca7fac3e

31 changed files with 1397 additions and 1033 deletions
Download patch file Download diff file Expand all files Collapse all files

4
.clang-format
View file

@ -7,7 +7,5 @@ SeparateDefinitionBlocks: Always
AllowShortBlocksOnASingleLine: Never AllowShortBlocksOnASingleLine: Never
AllowShortIfStatementsOnASingleLine: false AllowShortIfStatementsOnASingleLine: false
AllowShortFunctionsOnASingleLine: None AllowShortFunctionsOnASingleLine: None
AllowShortLambdasOnASingleLine: Empty
AlignAfterOpenBracket: BlockIndent AlignAfterOpenBracket: BlockIndent
AlignOperands: AlignAfterOperator
BreakBeforeBinaryOperators: NonAssignment
AllowAllArgumentsOnNextLine: true

2
external/mirai-core/CMakeLists.txt vendored
View file

@ -8,12 +8,14 @@ set(CMAKE_COMPILE_WARNING_AS_ERROR ON)
add_library(mirai-core add_library(mirai-core
src/Mirai.cpp src/Mirai.cpp
src/Task.cpp src/Task.cpp
src/Day.cpp
src/Event.cpp src/Event.cpp
src/DateTime.cpp src/DateTime.cpp
src/EventEmitter.cpp src/EventEmitter.cpp
src/Source.cpp src/Source.cpp
src/MarkdownDataProvider.cpp src/MarkdownDataProvider.cpp
src/MarkdownDataProvider.Parser.cpp src/MarkdownDataProvider.Parser.cpp
src/View.cpp
src/utils.cpp src/utils.cpp
) )

116
external/mirai-core/include/mirai-core/DataProvider.h vendored
View file

@ -14,83 +14,103 @@
namespace mirai namespace mirai
{ {
enum task_state { TODO, DONE }; struct DayData {
struct task_data {
int id;
std::string title;
task_state state;
std::optional<Date> due_date;
};
struct updatable_task_data {
std::optional<std::string> title = std::nullopt;
std::optional<task_state> state = std::nullopt;
std::optional<std::optional<Date>> due_date = std::nullopt;
};
struct event_data {
int id; int id;
Date date; Date date;
std::string title;
Time starts_at;
Time ends_at;
}; };
struct updatable_event_data { struct UpdatableDayData {
std::optional<Date> date; std::optional<Date> date;
std::optional<std::string> title;
std::optional<Time> starts_at;
std::optional<Time> ends_at;
}; };
class data_provider enum TaskState { TODO, DONE };
struct TaskData {
int id;
std::string title;
TaskState state;
std::optional<int> dayId;
std::optional<int> eventId;
};
struct UpdatableTaskData {
std::optional<std::string> title = std::nullopt;
std::optional<TaskState> state = std::nullopt;
std::optional<std::optional<int>> dayId = std::nullopt;
std::optional<std::optional<int>> eventId = std::nullopt;
};
struct EventData {
int id;
int dayId;
std::string title;
Time startsAt;
Time endsAt;
};
struct UpdatableEventData {
std::optional<int> dayId;
std::optional<std::string> title;
std::optional<Time> startsAt;
std::optional<Time> endsAt;
};
class DataProvider
{ {
public: public:
data_provider() {}; DataProvider() {};
data_provider(data_provider &) = delete; DataProvider(DataProvider &) = delete;
data_provider(data_provider &&) = delete; DataProvider(DataProvider &&) = delete;
virtual ~data_provider() = default; virtual ~DataProvider() = default;
virtual void save() = 0; virtual void save() = 0;
virtual void load() = 0; virtual void load() = 0;
virtual std::string name() const = 0; virtual std::string name() const = 0;
// Tasks // Tasks
virtual task_data insert_task(const task_data &task) = 0; virtual TaskData insertTask(const TaskData &task) = 0;
virtual void remove_task_by_id(int taskId) = 0; virtual void removeTaskById(int taskId) = 0;
virtual std::optional<task_data> get_task_by_id(int taskId) = 0; virtual std::optional<TaskData> getTaskById(int taskId) = 0;
virtual std::vector<task_data> get_tasks_by_date(Date date) = 0; virtual std::vector<TaskData> getTasksByEventId(int eventId) = 0;
virtual std::vector<task_data> get_tasks_without_date() = 0; virtual std::vector<TaskData> getTasksByDayId(int dayId) = 0;
virtual std::vector<task_data> get_tasks() = 0; virtual std::vector<TaskData> getTasksByDate(Date date) = 0;
virtual void update_task(int taskId, updatable_task_data updateData) = 0; virtual std::vector<TaskData> getTasksWithoutDate() = 0;
virtual std::vector<TaskData> getTasks() = 0;
virtual void updateTask(int taskId, UpdatableTaskData updateData) = 0;
// Events // Events
virtual event_data insertEvent(const event_data &task) = 0; virtual EventData insertEvent(const EventData &task) = 0;
virtual void remove_event_by_id(int eventId) = 0; virtual void removeEventById(int eventId) = 0;
virtual std::optional<event_data> get_event_by_id(int eventId) = 0; virtual std::optional<EventData> getEventById(int eventId) = 0;
virtual std::vector<event_data> get_events() = 0; virtual std::vector<EventData> getEvents() = 0;
virtual std::vector<event_data> get_events_by_date(Date date) = 0; virtual std::vector<EventData> getEventsByDate(Date date) = 0;
virtual void update_event(int eventId, updatable_event_data updateData) = 0; virtual void updateEvent(int eventId, UpdatableEventData updateData) = 0;
const int id = data_provider::generate_next_id(); // Days
virtual DayData insertDay(const DayData &day) = 0;
virtual void removeDayById(int dayId) = 0;
virtual std::vector<DayData> getDays() = 0;
virtual std::optional<DayData> getDayByDate(const Date &date) = 0;
virtual void updateDay(int dayId, UpdatableDayData updateData) = 0;
void set_dirty(bool dirty) const int id = DataProvider::generateNextId();
void setDirty(bool dirty)
{ {
_is_dirty = dirty; isDirty_ = dirty;
}; };
bool is_dirty() const bool isDirty() const
{ {
return _is_dirty; return isDirty_;
}; };
private: private:
bool _is_dirty = false; bool isDirty_ = false;
static int generate_next_id() static int generateNextId()
{ {
static int nextId = 0; static int nextId = 0;
return nextId++; return nextId++;

38
external/mirai-core/include/mirai-core/Day.h vendored Normal file
View file

@ -0,0 +1,38 @@
/*
* Mirai. Copyright (C) 2024 Vyn
* This file is licensed under version 3 of the GNU General Public License (GPL-3.0-only)
* The license can be found in the LICENSE file or at https://www.gnu.org/licenses/gpl-3.0.txt
*/
#pragma once
#include "DataProvider.h"
#include <vector>
namespace mirai
{
class Task;
class Event;
class Day
{
public:
Day(DataProvider *data, DayData day) : data_(data), dayData_(day) {};
Date date() const;
std::vector<Task> tasks();
std::vector<Event> events();
void mergeDay(const Day &otherDay);
int id() const;
int sourceId() const;
private:
DayData dayData_;
DataProvider *data_;
};
} // namespace mirai

24
external/mirai-core/include/mirai-core/Event.h vendored
View file

@ -7,6 +7,7 @@
#pragma once #pragma once
#include "DataProvider.h" #include "DataProvider.h"
#include "Day.h"
#include <string> #include <string>
#include <vector> #include <vector>
@ -19,26 +20,25 @@ class Event
{ {
public: public:
Event(data_provider *provider, event_data data) : _provider(provider), _data(data) {}; Event(DataProvider *data, EventData eventData) : data_(data), eventData_(eventData) {};
std::string title() const; std::string title() const;
Date date() const; Time startsAt() const;
Time starts_at() const; Time endsAt() const;
Time ends_at() const;
std::vector<Task> query_tasks() const; std::vector<Task> queryTasks() const;
void set_title(const std::string &newTitle); void setTitle(const std::string &newTitle);
void set_date(const Date &date); void setDay(const Day &day);
void set_start_time(const Time &time); void setStartTime(const Time &time);
void set_end_time(const Time &time); void setEndTime(const Time &time);
int id() const; int id() const;
int source_id() const; int sourceId() const;
private: private:
event_data _data; EventData eventData_;
data_provider *_provider; DataProvider *data_;
}; };
} // namespace mirai } // namespace mirai

56
external/mirai-core/include/mirai-core/MarkdownDataProvider.h vendored
View file

@ -19,21 +19,22 @@
namespace mirai namespace mirai
{ {
struct markdown_data { struct MarkdownData {
std::string name; std::string name;
std::vector<task_data> tasks; std::vector<TaskData> tasks;
std::vector<event_data> events; std::vector<DayData> days;
std::vector<EventData> events;
}; };
class markdown_data_provider final : public data_provider class MarkdownDataProvider : public DataProvider
{ {
public: public:
markdown_data_provider(const std::string &file_path) : _file_path(file_path), data_provider() MarkdownDataProvider(const std::string &filePath) : filePath_(filePath), DataProvider()
{ {
} }
std::string to_markdown(); std::string toMarkdown();
markdown_data parse_markdown(const std::string &content); MarkdownData parseMarkdown(const std::string &content);
std::string path() const; std::string path() const;
@ -43,26 +44,35 @@ class markdown_data_provider final : public data_provider
std::string name() const override; std::string name() const override;
// Tasks // Tasks
task_data insert_task(const task_data &task) override; TaskData insertTask(const TaskData &task) override;
void remove_task_by_id(int taskId) override; void removeTaskById(int taskId) override;
std::optional<task_data> get_task_by_id(int taskId) override; std::optional<TaskData> getTaskById(int taskId) override;
std::vector<task_data> get_tasks_by_date(Date date) override; std::vector<TaskData> getTasksByEventId(int eventId) override;
std::vector<task_data> get_tasks_without_date() override; std::vector<TaskData> getTasksByDayId(int dayId) override;
std::vector<task_data> get_tasks() override; std::vector<TaskData> getTasksByDate(Date date) override;
void update_task(int taskId, updatable_task_data updateData) override; std::vector<TaskData> getTasksWithoutDate() override;
std::vector<TaskData> getTasks() override;
void updateTask(int taskId, UpdatableTaskData updateData) override;
// Events // Events
event_data insertEvent(const event_data &task) override; EventData insertEvent(const EventData &task) override;
void remove_event_by_id(int eventId) override; void removeEventById(int eventId) override;
std::optional<event_data> get_event_by_id(int eventId) override; std::optional<EventData> getEventById(int eventId) override;
std::vector<event_data> get_events() override; std::vector<EventData> getEvents() override;
std::vector<event_data> get_events_by_date(Date date) override; std::vector<EventData> getEventsByDate(Date date) override;
void update_event(int eventId, updatable_event_data updateData) override; void updateEvent(int eventId, UpdatableEventData updateData) override;
// Days
DayData insertDay(const DayData &day) override;
void removeDayById(int dayId) override;
std::vector<DayData> getDays() override;
std::optional<DayData> getDayByDate(const Date &date) override;
void updateDay(int dayId, UpdatableDayData updateData) override;
private: private:
std::string _name; std::string name_;
std::string _file_path; std::string filePath_;
markdown_data _data; MarkdownData data;
}; };
} // namespace mirai } // namespace mirai

18
external/mirai-core/include/mirai-core/Mirai.h vendored
View file

@ -22,7 +22,7 @@ class Mirai
public: public:
Mirai(const std::string &configFilePath); Mirai(const std::string &configFilePath);
void addSource( void addSource(
const std::string &name, const std::string &type, std::unique_ptr<data_provider> &&source const std::string &name, const std::string &type, std::unique_ptr<DataProvider> &&source
); );
void void
editSource(int id, const std::string &name, const std::string &color, const std::string &path); editSource(int id, const std::string &name, const std::string &color, const std::string &path);
@ -30,25 +30,25 @@ class Mirai
void unloadAllSources(); void unloadAllSources();
void save(); void save();
std::vector<std::unique_ptr<source>> &getSources(); std::vector<std::unique_ptr<Source>> &getSources();
const std::vector<std::string> &getTags(); const std::vector<std::string> &getTags();
// Returns a non owning pointer to the requested resource or nullptr if not found. // Returns a non owning pointer to the requested resource or nullptr if not found.
source *getSourceById(int id); Source *getSourceById(int id);
source *getSourceByName(const std::string &name); Source *getSourceByName(const std::string &name);
void onSourceAdded(std::function<void(source *)> f); void onSourceAdded(std::function<void(Source *)> f);
void onSourceEdited(std::function<void(source *)> f); void onSourceEdited(std::function<void(Source *)> f);
void onSourceDeleted(std::function<void(int)> f); void onSourceDeleted(std::function<void(int)> f);
private: private:
void loadConfig(const std::string &path); void loadConfig(const std::string &path);
void saveConfig(); void saveConfig();
std::vector<std::unique_ptr<source>> sources_; std::vector<std::unique_ptr<Source>> sources_;
std::string configPath_; std::string configPath_;
EventEmitter<source *> sourceAdded; EventEmitter<Source *> sourceAdded;
EventEmitter<source *> sourceEdited; EventEmitter<Source *> sourceEdited;
EventEmitter<int> sourceDeleted; EventEmitter<int> sourceDeleted;
}; };
} // namespace mirai } // namespace mirai

81
external/mirai-core/include/mirai-core/Source.h vendored
View file

@ -8,6 +8,7 @@
#include "DataProvider.h" #include "DataProvider.h"
#include "DateTime.h" #include "DateTime.h"
#include "Day.h"
#include "Event.h" #include "Event.h"
#include "Task.h" #include "Task.h"
#include <string> #include <string>
@ -16,39 +17,40 @@
namespace mirai namespace mirai
{ {
struct create_task_params { struct createTaskParams {
std::string title; std::string title;
std::optional<Date> due_date; std::optional<Event> event;
std::optional<Date> date;
}; };
struct create_event_params { struct createEventParams {
std::string title; std::string title;
Date date; Date date;
Time starts_at; Time startsAt;
Time ends_at; Time endsAt;
}; };
struct source_constructor { struct SourceConstructor {
std::string name; std::string name;
std::string color; std::string color;
data_provider *source_data_provider; DataProvider *sourceDataProvider;
}; };
class source class Source
{ {
public: public:
source(source_constructor params) Source(SourceConstructor params)
: data(params.source_data_provider), _name(params.name), _color(params.color), : data(params.sourceDataProvider), name_(params.name), color_(params.color),
_type("FileSystemMarkdown") type_("FileSystemMarkdown")
{ {
} }
source(source &) = delete; Source(Source &) = delete;
source(source &&) = delete; Source(Source &&) = delete;
source operator=(source &) = delete; Source operator=(Source &) = delete;
source operator=(source &&) = delete; Source operator=(Source &&) = delete;
~source() = default; ~Source() = default;
void init(); void init();
void save(); void save();
@ -57,41 +59,44 @@ class source
std::string name() const; std::string name() const;
std::string type() const; std::string type() const;
std::string color() const; std::string color() const;
class data_provider *data_provider(); DataProvider *dataProvider();
void set_name(const std::string &name); void setName(const std::string &name);
void set_color(const std::string &color); void setColor(const std::string &color);
void create_task(const create_task_params &task); void createTask(const createTaskParams &task);
void remove_task(const Task &task); void removeTask(const Task &task);
std::optional<Task> get_task_by_id(int taskId); std::optional<Task> getTaskById(int taskId);
std::vector<Task> get_tasks_by_date(Date date); std::vector<Task> getTasksByDate(Date date);
std::vector<Task> get_unscheduled_tasks(); std::vector<Task> getUnscheduledTasks();
std::vector<Task> get_tasks(); std::vector<Task> getTasks();
void create_event(const create_event_params &eventToCreate); void createEvent(const createEventParams &eventToCreate);
void remove_event(const Event &event); void removeEvent(const Event &event);
std::vector<Event> get_events(); std::vector<Event> getEvents();
std::optional<Event> get_event_by_id(int eventId); std::optional<Event> getEventById(int eventId);
std::vector<Event> get_events_by_date(Date date); std::vector<Event> getEventsByDate(Date date);
const int id = source::generate_next_id(); std::vector<Day> getDays();
std::optional<Day> getDayByDate(Date date);
bool is_dirty() const const int id = Source::generateNextId();
bool isDirty() const
{ {
return data->is_dirty(); return data->isDirty();
}; };
private: private:
static int generate_next_id() static int generateNextId()
{ {
static int nextId = 0; static int nextId = 0;
return nextId++; return nextId++;
} }
std::string _name; std::string name_;
std::string _type; std::string type_;
std::string _color; std::string color_;
class data_provider *data; DataProvider *data;
}; };
} // namespace mirai } // namespace mirai

24
external/mirai-core/include/mirai-core/Task.h vendored
View file

@ -7,9 +7,7 @@
#pragma once #pragma once
#include "DataProvider.h" #include "DataProvider.h"
#include "DateTime.h"
#include "Event.h" #include "Event.h"
#include <optional>
#include <string> #include <string>
namespace mirai namespace mirai
@ -21,25 +19,27 @@ class Task
{ {
public: public:
Task(data_provider *data, task_data task) : data_(data), task_(task) {}; Task(DataProvider *data, TaskData task) : data_(data), task_(task) {};
std::string title() const; std::string title() const;
mirai::task_state state() const; mirai::TaskState state() const;
bool checked() const; bool checked() const;
bool has_due_date() const; bool hasEvent() const;
std::optional<Date> due_date() const; bool hasDate() const;
void set_title(const std::string &newTitle); void setTitle(const std::string &newTitle);
void set_date(const Date &date); void setDay(const Day &day);
void set_checked(bool checked); void setDate(const Date &date);
void setEvent(const Event &event);
void setChecked(bool checked);
void unschedule(); void unschedule();
int id() const; int id() const;
int source_id() const; int sourceId() const;
private: private:
task_data task_; TaskData task_;
data_provider *data_; DataProvider *data_;
}; };
} // namespace mirai } // namespace mirai

58
external/mirai-core/include/mirai-core/View.h vendored Normal file
View file

@ -0,0 +1,58 @@
/*
* Mirai. Copyright (C) 2024 Vyn
* This file is licensed under version 3 of the GNU General Public License (GPL-3.0-only)
* The license can be found in the LICENSE file or at https://www.gnu.org/licenses/gpl-3.0.txt
*/
#pragma once
#include "Mirai.h"
#include "Task.h"
#include <algorithm>
#include <iterator>
#include <map>
#include <memory>
#include <string>
#include <vector>
namespace mirai
{
struct DateView {
std::vector<Task> tasks;
std::vector<Event> events;
};
class View
{
public:
View(Mirai *mirai);
void hideCompletedTasks(bool hide);
bool shouldHideCompletedTasks() const;
std::vector<Date> getDates();
std::vector<Task> getTasksForDate(const Date &date);
std::vector<Event> getEventsForDate(const Date &date);
std::vector<Task> getUnscheduledTasks();
void update();
void removeSources();
void addSource(const Source &source);
void setSources(const std::vector<Source> &sources);
void setAllSources();
bool isSourceSelected(const Source &source) const;
size_t activeSourceCount() const;
private:
Mirai *mirai_;
std::vector<int> sourcesIds_;
std::vector<Task> unscheduledTasks_;
std::map<Date, DateView> dates;
bool shouldHideCompletedTasks_ = true;
};
} // namespace mirai

5
external/mirai-core/include/mirai-core/utils.h vendored
View file

@ -6,14 +6,11 @@
#pragma once #pragma once
#include "DataProvider.h"
#include "DateTime.h"
#include <cctype> #include <cctype>
#include <cpp-utils/string.h> #include <cpp-utils/string.h>
#include <cpp-utils/vector.h> #include <cpp-utils/vector.h>
#include <functional> #include <functional>
#include <optional> #include <optional>
#include <vector>
namespace mirai namespace mirai
{ {
@ -48,6 +45,6 @@ template <typename T, typename F> std::vector<T> findAll(std::vector<T> containe
return result; return result;
} }
int generate_unique_id(); int generateUniqueId();
} // namespace mirai } // namespace mirai

60
external/mirai-core/src/Day.cpp vendored Normal file
View file

@ -0,0 +1,60 @@
/*
* Mirai. Copyright (C) 2024 Vyn
* This file is licensed under version 3 of the GNU General Public License (GPL-3.0-only)
* The license can be found in the LICENSE file or at https://www.gnu.org/licenses/gpl-3.0.txt
*/
#include "Day.h"
#include "Task.h"
#include <algorithm>
#include <stdexcept>
namespace mirai
{
int Day::id() const
{
return dayData_.id;
}
int Day::sourceId() const
{
return data_->id;
}
Date Day::date() const
{
return dayData_.date;
}
std::vector<Task> Day::tasks()
{
auto tasksData = data_->getTasksByDayId(id());
std::vector<Task> tasks;
std::transform(
tasksData.begin(), tasksData.end(), std::back_inserter(tasks),
[&](const TaskData &taskData) {
return Task{data_, taskData};
}
);
return tasks;
}
std::vector<Event> Day::events()
{
auto eventsData = data_->getEventsByDate(dayData_.date);
std::vector<Event> events;
std::transform(
eventsData.begin(), eventsData.end(), std::back_inserter(events),
[&](const EventData &eventData) {
return Event{data_, eventData};
}
);
return events;
}
void Day::mergeDay(const Day &otherDay)
{
throw std::runtime_error("Not implemented yet");
}
} // namespace mirai

44
external/mirai-core/src/Event.cpp vendored
View file

@ -13,51 +13,59 @@ namespace mirai
int Event::id() const int Event::id() const
{ {
return _data.id; return eventData_.id;
} }
int Event::source_id() const int Event::sourceId() const
{ {
return _provider->id; return data_->id;
} }
std::string Event::title() const std::string Event::title() const
{ {
return _data.title; return eventData_.title;
} }
Date Event::date() const Time Event::startsAt() const
{ {
return _data.date; return eventData_.startsAt;
} }
Time Event::starts_at() const Time Event::endsAt() const
{ {
return _data.starts_at; return eventData_.endsAt;
} }
Time Event::ends_at() const std::vector<Task> Event::queryTasks() const
{ {
return _data.ends_at; auto tasksData = data_->getTasksByEventId(eventData_.id);
std::vector<Task> tasks;
std::transform(
tasksData.begin(), tasksData.end(), std::back_inserter(tasks),
[&](const TaskData &taskData) {
return Task{data_, taskData};
}
);
return tasks;
} }
void Event::set_title(const std::string &newTitle) void Event::setTitle(const std::string &newTitle)
{ {
_provider->update_event(id(), {.title = newTitle}); data_->updateEvent(id(), {.title = newTitle});
} }
void Event::set_date(const Date &date) void Event::setDay(const Day &day)
{ {
_provider->update_event(id(), {.date = date}); data_->updateEvent(id(), {.dayId = day.id()});
} }
void Event::set_start_time(const Time &time) void Event::setStartTime(const Time &time)
{ {
_provider->update_event(id(), {.starts_at = time}); data_->updateEvent(id(), {.startsAt = time});
} }
void Event::set_end_time(const Time &time) void Event::setEndTime(const Time &time)
{ {
_provider->update_event(id(), {.ends_at = time}); data_->updateEvent(id(), {.endsAt = time});
} }
} // namespace mirai } // namespace mirai

167
external/mirai-core/src/MarkdownDataProvider.Parser.cpp vendored
View file

@ -7,7 +7,6 @@
#include "MarkdownDataProvider.h" #include "MarkdownDataProvider.h"
#include "cpp-utils/debug.h" #include "cpp-utils/debug.h"
#include "utils.h" #include "utils.h"
#include <optional>
#include <print> #include <print>
#include <regex> #include <regex>
@ -38,17 +37,16 @@ std::string fieldWithSpace(const std::string &field)
return (field + " "); return (field + " ");
} }
task_data stringToTask(const std::string &str, const std::string &date) TaskData stringToTask(const std::string &str, const std::string &date)
{ {
std::smatch matches; std::smatch matches;
std::regex regex( std::regex regex("- \\[(\\s|X)\\] (([0-9]{2}:[0-9]{2})-([0-9]{2}:[0-9]{2}) > )?(.*?)( -- (.*))?"
"- \\[(\\s|X)\\] (([0-9]{2}:[0-9]{2})-([0-9]{2}:[0-9]{2}) > )?(.*?)( -- (.*))?"
); );
std::regex_match(str, matches, regex); std::regex_match(str, matches, regex);
std::string text = stringUtils::trim(matches[5]); std::string text = stringUtils::trim(matches[5]);
task_data taskItem{ TaskData taskItem{
.title = text, .title = text,
.state = str.substr(0, 5) == "- [X]" ? DONE : TODO, .state = str.substr(0, 5) == "- [X]" ? DONE : TODO,
}; };
@ -71,7 +69,7 @@ Time stringToTime(const std::string &str)
return time; return time;
} }
event_data stringToEvent(const std::string &str, const std::string &dateString) EventData stringToEvent(const std::string &str, const std::string &dateString)
{ {
std::smatch matches; std::smatch matches;
std::regex regex("> (([0-9]{2}h[0-9]{2})-([0-9]{2}h[0-9]{2}) )(.*?)( -- (.*))?"); std::regex regex("> (([0-9]{2}h[0-9]{2})-([0-9]{2}h[0-9]{2}) )(.*?)( -- (.*))?");
@ -85,86 +83,68 @@ event_data stringToEvent(const std::string &str, const std::string &dateString)
throw std::runtime_error("Malformated date"); throw std::runtime_error("Malformated date");
} }
event_data eventData{ EventData eventData{
.date = date.value(),
.title = text, .title = text,
.starts_at = stringToTime(matches[2]), .startsAt = stringToTime(matches[2]),
.ends_at = stringToTime(matches[3]), .endsAt = stringToTime(matches[3]),
}; };
return eventData; return eventData;
} }
std::string taskToString(const task_data &task) std::string taskToString(const TaskData &task)
{ {
std::string str = task.title; std::string str = task.title;
str = (task.state == DONE ? "- [X] " : "- [ ] ") + str; str = (task.state == DONE ? "- [X] " : "- [ ] ") + str;
return str; return str;
} }
std::string markdown_data_provider::to_markdown() std::string MarkdownDataProvider::toMarkdown()
{ {
const std::vector<DayData> days = getDays();
std::string result = "# " + name() + "\n\n"; std::string result = "# " + name() + "\n\n";
std::string currentDate = ""; std::string currentDate = "";
int next_task_index = 0; for (const auto &day : days) {
int next_event_index = 0; auto &date = day.date;
auto tasks = getTasksByDayId(day.id);
while (next_event_index < _data.events.size() || next_task_index < _data.tasks.size()) { auto events = getEventsByDate(date);
std::optional<Date> current_date = std::nullopt; if (tasks.size() == 0 && events.size() == 0) {
// First we find the lowest date between the events and the tasks continue;
if (_data.events.size() > 0 && next_event_index < _data.events.size()) {
current_date = _data.events.at(next_event_index).date;
} }
if (_data.tasks.size() > 0 && next_task_index < _data.tasks.size()) { result +=
auto &task = _data.tasks.at(next_task_index); "## " + std::format("{:02d}-{:02d}-{:02d}", date.year, date.month, date.day) + "\n\n";
if (task.due_date.has_value() && task.due_date < current_date.value()) { for (auto event : events) {
current_date = _data.tasks.at(next_task_index).due_date; auto &start = event.startsAt;
} auto &end = event.endsAt;
} result += "> " +
std::format(
if (current_date.has_value()) {
result += "## "
+ std::format(
"{:02d}-{:02d}-{:02d}", current_date.value().year,
current_date.value().month, current_date.value().day
)
+ "\n\n";
} else {
result += "## Unscheduled\n\n";
}
while (next_event_index < _data.events.size()) {
auto &current_event = _data.events.at(next_event_index);
if (current_event.date != current_date) {
break;
}
auto &start = current_event.starts_at;
auto &end = current_event.ends_at;
result += "> "
+ std::format(
"{:02d}h{:02d}-{:02d}h{:02d} {}", start.hour, start.minute, end.hour, "{:02d}h{:02d}-{:02d}h{:02d} {}", start.hour, start.minute, end.hour,
end.minute, current_event.title end.minute, event.title
) ) +
+ "\n"; "\n";
next_event_index++; for (const auto &task : getTasksByEventId(event.id)) {
current_event = _data.events.at(next_event_index); result += taskToString(task) + '\n';
}
while (next_task_index < _data.tasks.size()) {
auto &current_task = _data.tasks.at(next_task_index);
if (current_task.due_date != current_date) {
break;
} }
taskToString(current_task); result += '\n';
next_event_index++; }
current_task = _data.tasks.at(next_task_index); for (const auto &task : tasks) {
result += taskToString(task) + '\n';
} }
result += '\n'; result += '\n';
} }
auto unscheduledTasks = getTasksWithoutDate();
if (unscheduledTasks.size() > 0) {
result += "## Unscheduled\n\n";
for (const auto &task : unscheduledTasks) {
result += taskToString(task) + '\n';
}
result += '\n';
}
return result; return result;
}; };
markdown_data markdown_data_provider::parse_markdown(const std::string &content) MarkdownData MarkdownDataProvider::parseMarkdown(const std::string &content)
{ {
cpputils::debug::Timer readMdFormatDuration; cpputils::debug::Timer readMdFormatDuration;
@ -176,10 +156,13 @@ markdown_data markdown_data_provider::parse_markdown(const std::string &content)
std::println("Couldn't find the task list name"); std::println("Couldn't find the task list name");
} }
_data.name = line.substr(2); data.name = line.substr(2);
std::string currentDateString = ""; std::string currentDateString = "";
std::optional<Date> current_date = std::nullopt; std::vector<mirai::DayData> daysData;
std::vector<mirai::TaskData> unscheduledTasks;
std::optional<Date> currentDate = std::nullopt;
std::optional<EventData> currentEvent = std::nullopt;
cpputils::debug::Timer stringToTaskDuration; cpputils::debug::Timer stringToTaskDuration;
stringToTaskDuration.reset(); stringToTaskDuration.reset();
@ -188,40 +171,64 @@ markdown_data markdown_data_provider::parse_markdown(const std::string &content)
if (std::string_view{line.data(), 3} == "## ") { if (std::string_view{line.data(), 3} == "## ") {
currentDateString = line.substr(3); currentDateString = line.substr(3);
if (currentDateString == "Unscheduled") { if (currentDateString == "Unscheduled") {
current_date = std::nullopt; currentDate = std::nullopt;
continue; continue;
} }
current_date = mirai::stringToDate(currentDateString); currentDate = mirai::stringToDate(currentDateString);
if (!current_date.has_value()) { if (!currentDate.has_value()) {
throw std::runtime_error("Malformated date (1)"); throw std::runtime_error("Malformated date (1)");
} }
insertDay({.id = generateUniqueId(), .date = currentDate.value()});
} else if (line.starts_with("> ")) { } else if (line.starts_with("> ")) {
auto event = stringToEvent(line, currentDateString); auto event = stringToEvent(line, currentDateString);
if (current_date.has_value()) { if (currentDate.has_value()) {
insertEvent( auto day = getDayByDate(currentDate.value());
{.id = generate_unique_id(), currentEvent = insertEvent(
.date = current_date.value(), {.id = generateUniqueId(),
.dayId = day->id,
.title = event.title, .title = event.title,
.starts_at = event.starts_at, .startsAt = event.startsAt,
.ends_at = event.ends_at} .endsAt = event.endsAt}
); );
} }
} else if (line.starts_with("- [ ]") || line.starts_with("- [X]")) { } else if (line.starts_with("- [ ]") || line.starts_with("- [X]")) {
stringToTaskDuration.start(); stringToTaskDuration.start();
task_data taskItemData = stringToTask(line, currentDateString); TaskData taskItemData = stringToTask(line, currentDateString);
stringToTaskDuration.stop(); stringToTaskDuration.stop();
insert_task( if (currentEvent.has_value()) {
{.id = generate_unique_id(), insertTask({
.title = taskItemData.title, .id = generateUniqueId(),
.state = taskItemData.state, .title = taskItemData.title,
.due_date = current_date} .state = taskItemData.state,
); .dayId = std::nullopt,
.eventId = currentEvent.value().id,
});
} else if (currentDate.has_value()) {
auto day = getDayByDate(currentDate.value());
insertTask({
.id = generateUniqueId(),
.title = taskItemData.title,
.state = taskItemData.state,
.dayId = day->id,
.eventId = std::nullopt,
});
} else {
insertTask({
.id = generateUniqueId(),
.title = taskItemData.title,
.state = taskItemData.state,
.dayId = std::nullopt,
.eventId = std::nullopt,
});
}
} else if (cpputils::string::trim(line) == "") {
currentEvent = std::nullopt;
} }
} }
gelinesDuration.printTimeElapsed("getlinesDuration"); gelinesDuration.printTimeElapsed("getlinesDuration");
stringToTaskDuration.printTimeElapsed("stringToTaskDuration"); stringToTaskDuration.printTimeElapsed("stringToTaskDuration");
readMdFormatDuration.printTimeElapsed("Reading MD File duration"); readMdFormatDuration.printTimeElapsed("Reading MD File duration");
return _data; return data;
} }
} // namespace mirai } // namespace mirai

192
external/mirai-core/src/MarkdownDataProvider.cpp vendored
View file

@ -18,33 +18,33 @@
namespace mirai namespace mirai
{ {
std::string markdown_data_provider::path() const std::string MarkdownDataProvider::path() const
{ {
return _file_path; return filePath_;
} }
std::string markdown_data_provider::name() const std::string MarkdownDataProvider::name() const
{ {
return _data.name; return data.name;
} }
void markdown_data_provider::save() void MarkdownDataProvider::save()
{ {
std::ofstream file(_file_path); std::ofstream file(filePath_);
if (!file.is_open()) { if (!file.is_open()) {
throw std::runtime_error("can't create " + _file_path); throw std::runtime_error("can't create " + filePath_);
} }
const std::string content = to_markdown(); const std::string content = toMarkdown();
file << content; file << content;
file.close(); file.close();
set_dirty(false); setDirty(false);
}; };
void markdown_data_provider::load() void MarkdownDataProvider::load()
{ {
std::ifstream file(_file_path); std::ifstream file(filePath_);
if (!file.is_open()) { if (!file.is_open()) {
return; return;
} }
@ -55,19 +55,19 @@ void markdown_data_provider::load()
content += line + "\n"; content += line + "\n";
} }
file.close(); file.close();
_data = parse_markdown(content); data = parseMarkdown(content);
}; };
task_data markdown_data_provider::insert_task(const task_data &taskData) TaskData MarkdownDataProvider::insertTask(const TaskData &taskData)
{ {
_data.tasks.push_back(taskData); data.tasks.push_back(taskData);
set_dirty(true); setDirty(true);
return taskData; return taskData;
} }
void markdown_data_provider::update_task(int taskId, updatable_task_data updateData) void MarkdownDataProvider::updateTask(int taskId, UpdatableTaskData updateData)
{ {
auto taskData = ptrFindFirst(_data.tasks, [&](const task_data &task) { auto taskData = ptrFindFirst(data.tasks, [&](const TaskData &task) {
return task.id == taskId; return task.id == taskId;
}); });
assert(taskData != nullptr); // Shouldn't be possible assert(taskData != nullptr); // Shouldn't be possible
@ -77,110 +77,180 @@ void markdown_data_provider::update_task(int taskId, updatable_task_data updateD
if (updateData.state.has_value()) { if (updateData.state.has_value()) {
taskData->state = updateData.state.value(); taskData->state = updateData.state.value();
} }
if (updateData.due_date.has_value()) { if (updateData.dayId.has_value()) {
taskData->due_date = updateData.due_date.value(); taskData->dayId = updateData.dayId.value();
} }
set_dirty(true); if (updateData.eventId.has_value()) {
taskData->eventId = updateData.eventId.value();
}
setDirty(true);
} }
std::optional<task_data> markdown_data_provider::get_task_by_id(int taskId) std::optional<TaskData> MarkdownDataProvider::getTaskById(int taskId)
{ {
return findFirst(_data.tasks, [&](const task_data &task) { return findFirst(data.tasks, [&](const TaskData &task) {
return task.id == taskId; return task.id == taskId;
}); });
} }
std::vector<task_data> markdown_data_provider::get_tasks_without_date() std::vector<TaskData> MarkdownDataProvider::getTasksByEventId(int eventId)
{ {
return findAll(_data.tasks, [](const task_data &t) { return findAll(data.tasks, [&](const TaskData &task) {
return t.due_date == std::nullopt; return task.eventId == eventId;
}); });
} }
std::vector<task_data> markdown_data_provider::get_tasks_by_date(Date date) std::vector<TaskData> MarkdownDataProvider::getTasksByDayId(int dayId)
{ {
return findAll(_data.tasks, [&](const task_data &t) { return findAll(data.tasks, [&](const TaskData &task) {
return t.due_date == date; return task.dayId == dayId;
}); });
} }
std::vector<task_data> markdown_data_provider::get_tasks() std::vector<TaskData> MarkdownDataProvider::getTasksWithoutDate()
{ {
return _data.tasks; return findAll(data.tasks, [](const TaskData &t) {
return t.dayId == std::nullopt && t.eventId == std::nullopt;
});
} }
void markdown_data_provider::remove_task_by_id(int taskId) std::vector<TaskData> MarkdownDataProvider::getTasksByDate(Date date)
{ {
_data.tasks.erase( auto day = getDayByDate(date);
if (!day.has_value()) {
return {};
}
return findAll(data.tasks, [&](const TaskData &t) {
return t.dayId == day.value().id;
});
}
std::vector<TaskData> MarkdownDataProvider::getTasks()
{
return data.tasks;
}
void MarkdownDataProvider::removeTaskById(int taskId)
{
data.tasks.erase(
std::remove_if( std::remove_if(
_data.tasks.begin(), _data.tasks.end(), data.tasks.begin(), data.tasks.end(),
[&](const task_data &task) { [&](const TaskData &task) {
return task.id == taskId; return task.id == taskId;
} }
), ),
_data.tasks.end() data.tasks.end()
); );
set_dirty(true); setDirty(true);
} }
event_data markdown_data_provider::insertEvent(const event_data &eventData) DayData MarkdownDataProvider::insertDay(const DayData &dayData)
{ {
_data.events.push_back(eventData); data.days.push_back(dayData);
set_dirty(true); setDirty(true);
return dayData;
}
void MarkdownDataProvider::updateDay(int dayId, UpdatableDayData updateData)
{
auto dayData = ptrFindFirst(data.days, [&](const DayData &day) {
return day.id == dayId;
});
assert(dayData != nullptr); // Shouldn't be possible
if (updateData.date.has_value()) {
dayData->date = updateData.date.value();
}
setDirty(true);
}
void MarkdownDataProvider::removeDayById(int dayId)
{
data.days.erase(
std::remove_if(
data.days.begin(), data.days.end(),
[&](const DayData &day) {
return day.id == dayId;
}
),
data.days.end()
);
setDirty(true);
}
std::vector<DayData> MarkdownDataProvider::getDays()
{
return data.days;
}
std::optional<DayData> MarkdownDataProvider::getDayByDate(const Date &date)
{
return findFirst(data.days, [&](const DayData &day) {
return day.date == date;
});
}
EventData MarkdownDataProvider::insertEvent(const EventData &eventData)
{
data.events.push_back(eventData);
setDirty(true);
return eventData; return eventData;
} }
void markdown_data_provider::update_event(int eventId, updatable_event_data updateData) void MarkdownDataProvider::updateEvent(int eventId, UpdatableEventData updateData)
{ {
auto eventData = ptrFindFirst(_data.events, [&](const event_data &event) { auto eventData = ptrFindFirst(data.events, [&](const EventData &event) {
return event.id == eventId; return event.id == eventId;
}); });
assert(eventData != nullptr); // Shouldn't be possible assert(eventData != nullptr); // Shouldn't be possible
if (updateData.title.has_value()) { if (updateData.title.has_value()) {
eventData->title = updateData.title.value(); eventData->title = updateData.title.value();
} }
if (updateData.date.has_value()) { if (updateData.dayId.has_value()) {
eventData->date = updateData.date.value(); eventData->dayId = updateData.dayId.value();
} }
if (updateData.starts_at.has_value()) { if (updateData.startsAt.has_value()) {
eventData->starts_at = updateData.starts_at.value(); eventData->startsAt = updateData.startsAt.value();
} }
if (updateData.ends_at.has_value()) { if (updateData.endsAt.has_value()) {
eventData->ends_at = updateData.ends_at.value(); eventData->endsAt = updateData.endsAt.value();
} }
set_dirty(true); setDirty(true);
} }
void markdown_data_provider::remove_event_by_id(int eventId) void MarkdownDataProvider::removeEventById(int eventId)
{ {
_data.events.erase( data.events.erase(
std::remove_if( std::remove_if(
_data.events.begin(), _data.events.end(), data.events.begin(), data.events.end(),
[&](const event_data &event) { [&](const EventData &event) {
return event.id == eventId; return event.id == eventId;
} }
), ),
_data.events.end() data.events.end()
); );
set_dirty(true); setDirty(true);
} }
std::optional<event_data> markdown_data_provider::get_event_by_id(int eventId) std::optional<EventData> MarkdownDataProvider::getEventById(int eventId)
{ {
return findFirst(_data.events, [&](const event_data &event) { return findFirst(data.events, [&](const EventData &event) {
return event.id == eventId; return event.id == eventId;
}); });
} }
std::vector<event_data> markdown_data_provider::get_events_by_date(Date date) std::vector<EventData> MarkdownDataProvider::getEventsByDate(Date date)
{ {
return findAll(_data.events, [&](const event_data &event) { auto day = getDayByDate(date);
return event.date == date; if (!day.has_value()) {
return {};
}
return findAll(data.events, [&](const EventData &event) {
return event.dayId == day.value().id;
}); });
} }
std::vector<event_data> markdown_data_provider::get_events() std::vector<EventData> MarkdownDataProvider::getEvents()
{ {
return _data.events; return data.events;
} }
} // namespace mirai } // namespace mirai

57
external/mirai-core/src/Mirai.cpp vendored
View file

@ -43,12 +43,12 @@ void Mirai::loadConfig(const std::string &path)
const auto name = filePath.asObject().getString("name"); const auto name = filePath.asObject().getString("name");
const auto color = filePath.asObject().getString("color"); const auto color = filePath.asObject().getString("color");
const auto path = filePath.asObject().getString("path"); const auto path = filePath.asObject().getString("path");
std::unique_ptr<data_provider> file = std::make_unique<markdown_data_provider>(path); std::unique_ptr<DataProvider> file = std::make_unique<MarkdownDataProvider>(path);
data_provider *sourceDataProvider = file.release(); DataProvider *sourceDataProvider = file.release();
sourceDataProvider->load(); sourceDataProvider->load();
sources_.push_back( sources_.push_back(
std::make_unique<source>(source_constructor{ std::make_unique<Source>(SourceConstructor{
.name = name, .color = color, .source_data_provider = sourceDataProvider .name = name, .color = color, .sourceDataProvider = sourceDataProvider
}) })
); );
} }
@ -69,7 +69,7 @@ void Mirai::saveConfig()
rei::json::JsonObject jsonSource; rei::json::JsonObject jsonSource;
jsonSource.set("name", source->name()); jsonSource.set("name", source->name());
jsonSource.set("color", source->color()); jsonSource.set("color", source->color());
auto dataProvider = dynamic_cast<markdown_data_provider *>(source->data_provider()); auto dataProvider = dynamic_cast<MarkdownDataProvider *>(source->dataProvider());
jsonSource.set("path", dataProvider->path()); jsonSource.set("path", dataProvider->path());
jsonSource.set("type", "FileSystemMarkdown"); jsonSource.set("type", "FileSystemMarkdown");
configJson.getArray("files").push(jsonSource); configJson.getArray("files").push(jsonSource);
@ -84,14 +84,14 @@ Mirai::Mirai(const std::string &configFilePath) : configPath_(configFilePath)
} }
void Mirai::addSource( void Mirai::addSource(
const std::string &name, const std::string &type, std::unique_ptr<data_provider> &&new_source const std::string &name, const std::string &type, std::unique_ptr<DataProvider> &&source
) )
{ {
data_provider *sourceDataProvider = new_source.release(); DataProvider *sourceDataProvider = source.release();
sourceDataProvider->load(); sourceDataProvider->load();
sources_.push_back( sources_.push_back(
std::make_unique<source>( std::make_unique<Source>(
source_constructor{.name = name, .source_data_provider = sourceDataProvider} SourceConstructor{.name = name, .sourceDataProvider = sourceDataProvider}
) )
); );
saveConfig(); saveConfig();
@ -103,20 +103,23 @@ void Mirai::editSource(
) )
{ {
auto source = getSourceById(id); auto source = getSourceById(id);
source->set_name(name); source->setName(name);
source->set_color(color); source->setColor(color);
data_provider *sourceDataProvider = source->data_provider(); DataProvider *sourceDataProvider = source->dataProvider();
saveConfig(); saveConfig();
sourceEdited.emit(nullptr); sourceEdited.emit(nullptr);
} }
void Mirai::deleteSource(int id) void Mirai::deleteSource(int id)
{ {
auto source = getSourceById(id);
sources_.erase( sources_.erase(
std::remove_if( std::remove_if(
sources_.begin(), sources_.end(), sources_.begin(), sources_.end(),
[&](const std::unique_ptr<source> &source) { return source->id == id; } [&](const std::unique_ptr<Source> &source) {
return source->id == id;
}
), ),
sources_.end() sources_.end()
); );
@ -133,47 +136,47 @@ void Mirai::unloadAllSources()
void Mirai::save() void Mirai::save()
{ {
for (auto &source : sources_) { for (auto &source : sources_) {
if (source->is_dirty()) { if (source->isDirty()) {
source->save(); source->save();
} }
} }
} }
std::vector<std::unique_ptr<source>> &Mirai::getSources() std::vector<std::unique_ptr<Source>> &Mirai::getSources()
{ {
return sources_; return sources_;
} }
source *Mirai::getSourceById(int id) Source *Mirai::getSourceById(int id)
{ {
auto source_found = std::ranges::find_if(sources_, [&](const std::unique_ptr<source> &source) { auto source = std::ranges::find_if(sources_, [&](const std::unique_ptr<Source> &source) {
return source->id == id; return source->id == id;
}); });
// assert(source_found != sources_.end()); // This should not happen assert(source != sources_.end()); // This should not happen
if (source_found == sources_.end()) { if (source == sources_.end()) {
return nullptr; return nullptr;
} }
return source_found->get(); return source->get();
} }
source *Mirai::getSourceByName(const std::string &name) Source *Mirai::getSourceByName(const std::string &name)
{ {
auto source_found = std::ranges::find_if(sources_, [&](const std::unique_ptr<source> &source) { auto source = std::ranges::find_if(sources_, [&](const std::unique_ptr<Source> &source) {
return source->name() == name; return source->name() == name;
}); });
assert(source_found != sources_.end()); // This should not happen assert(source != sources_.end()); // This should not happen
if (source_found == sources_.end()) { if (source == sources_.end()) {
return nullptr; return nullptr;
} }
return source_found->get(); return source->get();
} }
void Mirai::onSourceAdded(std::function<void(source *)> f) void Mirai::onSourceAdded(std::function<void(Source *)> f)
{ {
sourceAdded.registerCallback(f); sourceAdded.registerCallback(f);
} }
void Mirai::onSourceEdited(std::function<void(source *)> f) void Mirai::onSourceEdited(std::function<void(Source *)> f)
{ {
sourceEdited.registerCallback(f); sourceEdited.registerCallback(f);
} }

132
external/mirai-core/src/Source.cpp vendored
View file

@ -16,65 +16,99 @@
namespace mirai namespace mirai
{ {
void source::save() void Source::save()
{ {
data->save(); data->save();
} }
void source::create_task(const create_task_params &task) void Source::createTask(const createTaskParams &task)
{ {
data->insert_task({ std::optional<int> dayId = std::nullopt;
.id = generate_unique_id(), std::optional<int> eventId = std::nullopt;
if (!task.event.has_value() && task.date.has_value()) {
auto day = data->getDayByDate(task.date.value());
if (!day.has_value() && task.date.has_value()) {
day = data->insertDay({.id = generateUniqueId(), .date = task.date.value()});
}
dayId = day->id;
}
if (task.event.has_value() && task.event->id()) {
eventId = task.event.value().id();
}
data->insertTask({
.id = generateUniqueId(),
.title = task.title, .title = task.title,
.state = TODO, .state = TODO,
.due_date = task.due_date, .dayId = dayId,
.eventId = eventId,
}); });
}; };
void source::create_event(const create_event_params &new_event) std::vector<Day> Source::getDays()
{ {
data->insertEvent({ auto daysData = data->getDays();
.id = generate_unique_id(), std::vector<Day> days;
.date = new_event.date,
.title = new_event.title,
.starts_at = new_event.starts_at,
.ends_at = new_event.ends_at,
});
};
std::vector<Event> source::get_events()
{
auto event_data = data->get_events();
std::vector<Event> events;
std::transform( std::transform(
event_data.begin(), event_data.end(), std::back_inserter(events), daysData.begin(), daysData.end(), std::back_inserter(days), [&](const DayData &dayData) {
[&](const struct event_data &event_data) { return Event{data, event_data}; } return Day{data, dayData};
}
); );
return events; return days;
} }
std::optional<Event> source::get_event_by_id(int evendId) std::optional<Day> Source::getDayByDate(Date date)
{ {
auto event = data->get_event_by_id(evendId); auto day = data->getDayByDate(date);
if (!day.has_value()) {
return std::nullopt;
}
return Day{data, day.value()};
}
void Source::createEvent(const createEventParams &eventToCreate)
{
std::optional<int> dayId = std::nullopt;
auto day = data->getDayByDate(eventToCreate.date);
if (!day.has_value()) {
day = data->insertDay({.id = generateUniqueId(), .date = eventToCreate.date});
dayId = day->id;
}
data->insertEvent({
.id = generateUniqueId(),
.dayId = day.value().id,
.title = eventToCreate.title,
.startsAt = eventToCreate.startsAt,
.endsAt = eventToCreate.endsAt,
});
};
std::optional<Event> Source::getEventById(int evendId)
{
auto event = data->getEventById(evendId);
if (!event.has_value()) { if (!event.has_value()) {
return std::nullopt; return std::nullopt;
} }
return Event{data, event.value()}; return Event{data, event.value()};
} }
void source::remove_event(const Event &event) void Source::removeEvent(const Event &event)
{ {
data->remove_event_by_id(event.id()); data->removeEventById(event.id());
} }
void source::remove_task(const Task &task) void Source::removeTask(const Task &task)
{ {
data->remove_task_by_id(task.id()); data->removeTaskById(task.id());
} }
std::optional<Task> source::get_task_by_id(int taskId) std::optional<Task> Source::getTaskById(int taskId)
{ {
auto taskData = data->get_task_by_id(taskId); auto taskData = data->getTaskById(taskId);
if (!taskData.has_value()) { if (!taskData.has_value()) {
return std::nullopt; return std::nullopt;
} }
@ -82,55 +116,59 @@ std::optional<Task> source::get_task_by_id(int taskId)
return task; return task;
} }
std::vector<Task> source::get_tasks() std::vector<Task> Source::getTasks()
{ {
auto tasksData = data->get_tasks(); auto tasksData = data->getTasks();
std::vector<Task> tasks; std::vector<Task> tasks;
std::transform( std::transform(
tasksData.begin(), tasksData.end(), std::back_inserter(tasks), tasksData.begin(), tasksData.end(), std::back_inserter(tasks),
[&](const task_data &taskData) { return Task{data, taskData}; } [&](const TaskData &taskData) {
return Task{data, taskData};
}
); );
return tasks; return tasks;
} }
std::vector<Task> source::get_unscheduled_tasks() std::vector<Task> Source::getUnscheduledTasks()
{ {
auto tasksData = data->get_tasks_without_date(); auto tasksData = data->getTasksWithoutDate();
std::vector<Task> tasks; std::vector<Task> tasks;
std::transform( std::transform(
tasksData.begin(), tasksData.end(), std::back_inserter(tasks), tasksData.begin(), tasksData.end(), std::back_inserter(tasks),
[&](const task_data &taskData) { return Task{data, taskData}; } [&](const TaskData &taskData) {
return Task{data, taskData};
}
); );
return tasks; return tasks;
} }
std::string source::name() const std::string Source::name() const
{ {
return _name; return name_;
} }
std::string source::color() const std::string Source::color() const
{ {
return _color; return color_;
} }
void source::set_name(const std::string &name) void Source::setName(const std::string &name)
{ {
_name = name; name_ = name;
} }
void source::set_color(const std::string &color) void Source::setColor(const std::string &color)
{ {
_color = color; color_ = color;
} }
std::string source::type() const std::string Source::type() const
{ {
// There is only 1 type for now // There is only 1 type for now
return _type; return type_;
} }
data_provider *source::data_provider() DataProvider *Source::dataProvider()
{ {
return data; return data;
} }

46
external/mirai-core/src/Task.cpp vendored
View file

@ -6,6 +6,7 @@
#include "Task.h" #include "Task.h"
#include "DataProvider.h" #include "DataProvider.h"
#include "Day.h"
#include "utils.h" #include "utils.h"
#include <optional> #include <optional>
#include <string> #include <string>
@ -18,7 +19,7 @@ int Task::id() const
return task_.id; return task_.id;
} }
int Task::source_id() const int Task::sourceId() const
{ {
return data_->id; return data_->id;
} }
@ -28,7 +29,7 @@ std::string Task::title() const
return task_.title; return task_.title;
} }
mirai::task_state Task::state() const mirai::TaskState Task::state() const
{ {
return task_.state; return task_.state;
} }
@ -38,39 +39,52 @@ bool Task::checked() const
return task_.state == mirai::DONE; return task_.state == mirai::DONE;
} }
bool Task::has_due_date() const bool Task::hasEvent() const
{ {
return task_.due_date.has_value(); return task_.eventId.has_value();
} }
std::optional<Date> Task::due_date() const bool Task::hasDate() const
{ {
if (!task_.due_date.has_value()) { return task_.dayId.has_value();
return std::nullopt;
}
return task_.due_date.value();
} }
void Task::set_title(const std::string &newTitle) void Task::setTitle(const std::string &newTitle)
{ {
data_->update_task(id(), {.title = newTitle}); data_->updateTask(id(), {.title = newTitle});
} }
void Task::set_date(const Date &date) void Task::setDay(const Day &day)
{ {
auto emptyEventId = std::optional<std::optional<int>>(std::optional<int>(std::nullopt)); auto emptyEventId = std::optional<std::optional<int>>(std::optional<int>(std::nullopt));
data_->update_task(id(), {.due_date = date}); data_->updateTask(id(), {.dayId = day.id(), .eventId = emptyEventId});
}
void Task::setDate(const Date &date)
{
auto day = data_->getDayByDate(date);
if (!day.has_value()) {
day = data_->insertDay({.id = generateUniqueId(), .date = date});
}
auto emptyEventId = std::optional<std::optional<int>>(std::optional<int>(std::nullopt));
data_->updateTask(id(), {.dayId = day.value().id, .eventId = emptyEventId});
} }
void Task::unschedule() void Task::unschedule()
{ {
auto emptyId = std::optional<std::optional<int>>(std::optional<int>(std::nullopt)); auto emptyId = std::optional<std::optional<int>>(std::optional<int>(std::nullopt));
data_->update_task(id(), {.due_date = std::nullopt}); data_->updateTask(id(), {.dayId = emptyId, .eventId = emptyId});
} }
void Task::set_checked(bool checked) void Task::setEvent(const Event &event)
{ {
data_->update_task(id(), {.state = checked ? DONE : TODO}); auto emptyDayId = std::optional<std::optional<int>>(std::optional<int>(std::nullopt));
data_->updateTask(id(), {.dayId = emptyDayId, .eventId = event.id()});
}
void Task::setChecked(bool checked)
{
data_->updateTask(id(), {.state = checked ? DONE : TODO});
} }
} // namespace mirai } // namespace mirai

165
external/mirai-core/src/View.cpp vendored Normal file
View file

@ -0,0 +1,165 @@
/*
* Mirai. Copyright (C) 2024 Vyn
* This file is licensed under version 3 of the GNU General Public License (GPL-3.0-only)
* The license can be found in the LICENSE file or at https://www.gnu.org/licenses/gpl-3.0.txt
*/
#include "View.h"
#include "utils.h"
#include <algorithm>
#include <iostream>
#include <iterator>
#include <ranges>
namespace mirai
{
View::View(Mirai *mirai) : mirai_(mirai)
{
}
void View::hideCompletedTasks(bool hide)
{
shouldHideCompletedTasks_ = hide;
}
bool View::shouldHideCompletedTasks() const
{
return shouldHideCompletedTasks_;
}
std::vector<Date> View::getDates()
{
std::vector<Date> datesVector;
for (auto &date : dates) {
datesVector.push_back(date.first);
}
return datesVector;
}
std::vector<Task> View::getTasksForDate(const Date &date)
{
return dates.at(date).tasks;
}
std::vector<Event> View::getEventsForDate(const Date &date)
{
if (!dates.contains(date)) {
return {};
}
return dates.at(date).events;
}
std::vector<Task> View::getUnscheduledTasks()
{
return unscheduledTasks_;
}
void View::update()
{
dates.clear();
unscheduledTasks_.clear();
auto todayDate = Date(std::chrono::system_clock::now());
for (int sourceId : sourcesIds_) {
Source *source = mirai_->getSourceById(sourceId);
for (auto day : source->getDays()) {
// day's tasks
auto sourceTasks = day.tasks() | std::ranges::views::filter([&](const Task &task) {
if (day.date() >= todayDate) {
return true;
}
if (shouldHideCompletedTasks()) {
return task.checked() == false;
}
return true;
});
if (day.date() >= todayDate || std::ranges::distance(sourceTasks) > 0) {
if (!dates.contains(day.date())) {
dates.insert_or_assign(day.date(), DateView{});
}
auto &tasks = dates.at(day.date()).tasks;
tasks.insert(tasks.end(), sourceTasks.begin(), sourceTasks.end());
}
// day's events
auto sourceEvents =
day.events() | std::ranges::views::filter([&](const Event &event) {
return (!shouldHideCompletedTasks() || day.date() >= todayDate) ||
findFirst(event.queryTasks(), [&](const Task &task) {
return task.checked() == false;
}).has_value();
});
if (day.date() >= todayDate || std::ranges::distance(sourceEvents) > 0) {
if (!dates.contains(day.date())) {
dates.insert_or_assign(day.date(), DateView{});
}
auto &events = dates.at(day.date()).events;
events.insert(events.end(), sourceEvents.begin(), sourceEvents.end());
}
}
// unscheduled tasks
auto tasks = source->getUnscheduledTasks();
unscheduledTasks_.insert(unscheduledTasks_.end(), tasks.begin(), tasks.end());
}
for (auto &date : dates) {
auto &events = date.second.events;
std::sort(events.begin(), events.end(), [](const Event &a, const Event &b) {
return a.startsAt() < b.startsAt();
});
}
}
void View::removeSources()
{
sourcesIds_.clear();
}
void View::addSource(const Source &source)
{
sourcesIds_.push_back(source.id);
}
void View::setSources(const std::vector<Source> &sources)
{
sourcesIds_.clear();
std::transform(
sources.begin(), sources.end(), std::back_inserter(sourcesIds_),
[](const Source &source) {
return source.id;
}
);
}
void View::setAllSources()
{
const auto &sources = mirai_->getSources();
sourcesIds_.clear();
std::transform(
sources.begin(), sources.end(), std::back_inserter(sourcesIds_),
[](const std::unique_ptr<Source> &source) {
return source->id;
}
);
}
bool View::isSourceSelected(const Source &source) const
{
for (auto &sourceId : sourcesIds_) {
if (sourceId == source.id) {
return true;
}
}
return false;
}
size_t View::activeSourceCount() const
{
return sourcesIds_.size();
}
} // namespace mirai

2
external/mirai-core/src/utils.cpp vendored
View file

@ -39,7 +39,7 @@ bool isDate(const std::string &dateStr)
return true; return true;
} }
int generate_unique_id() int generateUniqueId()
{ {
static int nextId = 0; static int nextId = 0;
return nextId++; return nextId++;

16
src/components/Calendar.slint
View file

@ -1,10 +1,10 @@
import { ScrollView, Date, Time } from "std-widgets.slint"; import { ScrollView, Date, Time } from "std-widgets.slint";
import { VCheckBox, VButton, VActionButton, Svg, VTag, VPopupIconMenu, VText, Palette } from "@selenite"; import { VCheckBox, VButton, VActionButton, Svg, VTag, VPopupIconMenu, VText, Palette } from "@selenite";
import { Utils } from "../shared/Utils.slint"; import { Utils } from "../shared/Utils.slint";
import { AppModels, CalendarViewDate, CalendarDateDisplayFormat } from "../shared/Models.slint"; import { AppModels, CalendarDay, CalendarDateDisplayFormat } from "../shared/Models.slint";
export component Calendar inherits Rectangle { export component Calendar inherits Rectangle {
in property<[CalendarViewDate]> days; in property<[CalendarDay]> days;
in property <CalendarDateDisplayFormat> format; in property <CalendarDateDisplayFormat> format;
in property <Date> current-date; in property <Date> current-date;
in property <Time> current-time; in property <Time> current-time;
@ -17,6 +17,8 @@ export component Calendar inherits Rectangle {
callback delete-event-request(source-id: int, event-id: int); callback delete-event-request(source-id: int, event-id: int);
HorizontalLayout { HorizontalLayout {
Rectangle { Rectangle {
//background: red; //background: red;
@ -92,20 +94,20 @@ export component Calendar inherits Rectangle {
Rectangle { Rectangle {
width: 100%; width: 100%;
height: 100%; height: 100%;
background: AppModels.get-source-color-from-id-as-color(event.source-id); background: AppModels.get-source-color-from-id-as-color(event.sourceId);
opacity: 0.05; opacity: 0.05;
} }
background: Palette.card-background; background: Palette.card-background;
border-radius: 4px; border-radius: 4px;
x: 8px; x: 8px;
width: parent.width - 16px; width: parent.width - 16px;
y: day-start-y + hour-spacing * event.starts_at.hour; y: day-start-y + hour-spacing * event.startsAt.hour;
height: hour-spacing * (event.ends_at.hour - event.starts_at.hour) - 2px; height: hour-spacing * (event.endsAt.hour - event.startsAt.hour) - 2px;
clip: true; clip: true;
HorizontalLayout { HorizontalLayout {
Rectangle { Rectangle {
width: 4px; width: 4px;
background: AppModels.get-source-color-from-id-as-color(event.source-id); background: AppModels.get-source-color-from-id-as-color(event.sourceId);
} }
VerticalLayout { VerticalLayout {
padding: 16px; padding: 16px;
@ -136,7 +138,7 @@ export component Calendar inherits Rectangle {
icon-size: 1.5rem; icon-size: 1.5rem;
border-radius: 0; border-radius: 0;
clicked => { clicked => {
delete-event-request(event.source-id, event.id); delete-event-request(event.sourceId, event.id);
} }
} }
} }

2
src/components/CreateTaskOrEvent.slint
View file

@ -39,7 +39,7 @@ export component CreateTaskOrEvent inherits Rectangle {
newTaskTitleInput := VTextInput { newTaskTitleInput := VTextInput {
placeholder: "Enter new task"; placeholder: "Enter new task";
started-writting() => { started-writting() => {
sourceInput.current-index = 0; sourceInput.current-index = AppModels.default-source-index;
} }
accepted => { accepted() } accepted => { accepted() }
} }

128
src/components/EventGroup.slint Normal file
View file

@ -0,0 +1,128 @@
import { Event } from "../shared/Models.slint";
import { ScrollView } from "std-widgets.slint";
import { VCheckBox, VTextInput, VButton, VActionButton, Svg, VTag, VPopupIconMenu, VText, Palette } from "@selenite";
import { TaskLine } from "./TaskLine.slint";
import { Utils } from "../shared/Utils.slint";
export struct EventGroupAddTask {
title: string
}
export component EventGroup {
in property<Event> event;
private property <bool> show-add-task: false;
private property <bool> edit-name: false;
callback add-task(EventGroupAddTask);
callback edit-task(int, EventGroupAddTask);
callback delete-task(int);
callback delete();
callback edit(EventGroupAddTask);
callback toggle-check-task(int);
eventPopup := VPopupIconMenu {
VActionButton {
icon-svg: Svg.plus;
icon-colorize: Colors.greenyellow;
icon-size: 1.5rem;
border-radius: 0;
clicked => {
root.show-add-task = true;
}
}
VActionButton {
icon-svg: Svg.pen;
icon-colorize: Colors.grey;
icon-size: 1.5rem;
border-radius: 0;
clicked => { edit-name = true; }
}
VActionButton {
icon-svg: Svg.trash;
icon-colorize: Colors.pink;
icon-size: 1.5rem;
border-radius: 0;
clicked => { root.delete() }
}
}
ta := TouchArea {
pointer-event(e) => {
if (e.button == PointerEventButton.right && e.kind == PointerEventKind.up) {
eventPopup.show(ta.mouse-x, ta.mouse-y);
}
}
}
HorizontalLayout {
VerticalLayout {
spacing: 4px;
VText {
text: Utils.time-to-string(event.startsAt);
horizontal-alignment: center;
color: Palette.accent;
}
HorizontalLayout {
alignment: center;
Rectangle {
width: 2px;
background: Palette.accent;
}
}
VText {
text: Utils.time-to-string(event.endsAt);
color: Palette.accent;
font-size: 0.9rem;
horizontal-alignment: center;
}
}
VerticalLayout {
horizontal-stretch: 1;
padding: 16px;
padding-top: 32px;
padding-bottom: 32px;
padding-right: 0px;
if !edit-name : VText {
text: event.title;
font-size: 1.1rem;
}
if edit-name : title := VTextInput {
text: event.title;
accepted => {
root.edit({
title: title.text
});
root.edit-name = false;
}
}
for task[taskIndex] in event.tasks: VerticalLayout {
padding-top: taskIndex == 0 ? 16px : 0px;
padding-bottom: 8px;
TaskLine {
title: task.title;
checked: task.checked;
delete => {
root.delete-task(task.id)
}
toggle-check => {
root.toggle-check-task(task.id)
}
edited(data) => {
root.edit-task(task.id, {
title: data.title
});
}
}
}
if show-add-task : taskInput := VTextInput {
accepted => {
root.add-task({
title: taskInput.text
});
root.show-add-task = false;
}
}
}
}
}

1
src/shared/Actions.slint
View file

@ -1,4 +1,5 @@
import { Date, Time } from "std-widgets.slint"; import { Date, Time } from "std-widgets.slint";
import { CalendarDay } from "./Models.slint";
export struct NewTaskData { export struct NewTaskData {
sourceId: int, sourceId: int,

94
src/shared/Models.slint
View file

@ -1,76 +1,68 @@
import { Date, Time } from "std-widgets.slint"; import { Date, Time } from "std-widgets.slint";
export struct TasksViewTask { export struct Source {
id: int,
source-id: int,
title: string,
checked: bool
}
export struct TasksViewSource {
id: int, id: int,
name: string, name: string,
color: color, selected: bool,
tasks: [TasksViewTask] path: string
} }
export struct TasksViewDate { export struct TaskData {
due-date: Date, sourceId: int,
no-date: bool, eventId: int,
is-late: bool, id: int,
sources: [TasksViewSource] title: string,
date: Date,
checked: bool,
} }
export struct TasksView { export struct Event {
dates: [TasksViewDate], sourceId: int,
sources: [string]
}
export struct CalendarViewEvent {
source-id: int,
id: int, id: int,
title: string, title: string,
starts-at: Time, startsAt: Time,
ends-at: Time endsAt: Time,
tasks: [TaskData],
} }
export struct CalendarViewDate { export struct Day {
events: [CalendarViewEvent], sourceId: int,
id: int,
date: Date,
events: [Event],
tasks: [TaskData],
isLate: bool,
isToday: bool,
relativeDaysDiff: int
}
export struct CalendarDayEvent {
sourceId: int,
id: int,
title: string,
startsAt: Time,
endsAt: Time
}
export struct CalendarDay {
events: [CalendarDayEvent],
date: Date, date: Date,
header: string, header: string,
} }
export struct CalendarView {
dates: [CalendarViewDate]
}
export struct SidebarViewSources {
id: int,
name: string,
color: color,
active: bool
}
export enum SidebarViewActiveTab {
tasks,
calendar
}
export struct SidebarView {
sources: [SidebarViewSources],
active-view: SidebarViewActiveTab,
all-active: bool
}
export enum CalendarDateDisplayFormat { export enum CalendarDateDisplayFormat {
Relative, Relative,
Normal Normal
} }
export global AppModels { export global AppModels {
in-out property<SidebarView> sidebar-view; in-out property<[Source]> sources-selected;
in-out property<TasksView> tasks-view; in-out property<int> default-source-index;
in-out property<CalendarView> calendar-view; in-out property<[string]> sources;
in-out property<bool> no-source-selected;
in-out property<[Day]> days;
in-out property<[CalendarDay]> calendar;
in-out property<[TaskData]> unscheduled-tasks;
callback get-source-id-from-name(string) -> int; callback get-source-id-from-name(string) -> int;
pure callback get-source-name-from-id(int) -> string; pure callback get-source-name-from-id(int) -> string;

24
src/view.h
View file

@ -1,24 +0,0 @@
#include "DataProvider.h"
#include "DateTime.h"
#include <vector>
struct source_group {
int source_id;
std::vector<mirai::event_data> events;
std::vector<mirai::task_data> tasks;
};
struct day_group {
mirai::Date date;
source_group sources;
};
std::vector<day_group>
group_by_day(std::vector<mirai::event_data> events, std::vector<mirai::task_data> tasks)
{
std::vector<day_group> days;
// todo
return days;
}

675
src/windows/AppWindow/AppWindow.cpp
View file

@ -8,40 +8,37 @@
#include "../../SeleniteSetup.h" #include "../../SeleniteSetup.h"
#include "../../shared/Utils.h" #include "../../shared/Utils.h"
#include "mirai-core/DateTime.h" #include "mirai-core/DateTime.h"
#include "mirai-core/Event.h" #include "mirai-core/Day.h"
#include "mirai-core/MarkdownDataProvider.h" #include "mirai-core/MarkdownDataProvider.h"
#include "mirai-core/Mirai.h" #include "mirai-core/Mirai.h"
#include "mirai-core/Source.h"
#include "selenite/palette.h" #include "selenite/palette.h"
#include "slint_color.h" #include "slint_color.h"
#include "slint_models.h"
#include "slint_string.h" #include "slint_string.h"
#include "ui.h" #include "ui.h"
#include <algorithm>
#include <bits/chrono.h> #include <bits/chrono.h>
#include <cassert> #include <cassert>
#include <chrono> #include <chrono>
#include <cstdlib> #include <cstdlib>
#include <iostream> #include <iostream>
#include <iterator>
#include <memory> #include <memory>
#include <optional> #include <optional>
#include <print> #include <print>
#include <ranges>
#include <string> #include <string>
#include <string_view> #include <string_view>
#include <vector> #include <vector>
AppWindow::AppWindow(mirai::Mirai *miraiInstance) : miraiInstance_(miraiInstance) AppWindow::AppWindow(mirai::Mirai *miraiInstance)
: miraiInstance_(miraiInstance), view_(miraiInstance)
{ {
_sidebar_view = ui::SidebarView(); sources_ = std::make_shared<slint::VectorModel<ui::Source>>();
_calendar_view = ui::CalendarView(); days_ = std::make_shared<slint::VectorModel<ui::Day>>();
_tasks_view = ui::TasksView(); calendar_ = std::make_shared<slint::VectorModel<ui::CalendarDay>>();
/*auto sourcesNames = std::make_shared<slint::MapModel<ui::Source, slint::SharedString>>(*/ unscheduledTasks_ = std::make_shared<slint::VectorModel<ui::TaskData>>();
/*sources_, [&](const ui::Source &a) {*/ auto sourcesNames = std::make_shared<slint::MapModel<ui::Source, slint::SharedString>>(
/*return a.name;*/ sources_, [&](const ui::Source &a) {
/*}*/ return a.name;
/*);*/ }
);
const auto palettePath = std::string(getenv("HOME")) + "/.config/evalyte/theme.json"; const auto palettePath = std::string(getenv("HOME")) + "/.config/evalyte/theme.json";
const auto palette = selenite::parseJson(palettePath); const auto palette = selenite::parseJson(palettePath);
@ -52,14 +49,13 @@ AppWindow::AppWindow(mirai::Mirai *miraiInstance) : miraiInstance_(miraiInstance
bindSlintUtils(mainWindow_->global<ui::Utils>()); bindSlintUtils(mainWindow_->global<ui::Utils>());
models().set_sidebar_view(_sidebar_view); models().set_sources(sourcesNames);
models().set_calendar_view(_calendar_view); models().set_sources_selected(sources_);
models().set_tasks_view(_tasks_view); models().set_days(days_);
models().set_calendar(calendar_);
show_all_sources(); view_.setAllSources();
update_views(); view_.update();
/*view_.setAllSources();*/
/*view_.update();*/
reloadSources(); reloadSources();
reloadTasks(); reloadTasks();
@ -118,49 +114,53 @@ void AppWindow::setupCallbacks()
models().on_get_source_path_from_id([&](int sourceId) { models().on_get_source_path_from_id([&](int sourceId) {
auto source = miraiInstance_->getSourceById(sourceId); auto source = miraiInstance_->getSourceById(sourceId);
assert(source); assert(source);
mirai::markdown_data_provider *sourceProvider = mirai::MarkdownDataProvider *sourceProvider =
dynamic_cast<mirai::markdown_data_provider *>(source->data_provider()); dynamic_cast<mirai::MarkdownDataProvider *>(source->dataProvider());
return slint::SharedString(sourceProvider->path()); return slint::SharedString(sourceProvider->path());
}); });
miraiInstance_->onSourceAdded([&](mirai::source *source) { refreshModels(); }); miraiInstance_->onSourceAdded([&](mirai::Source *source) {
miraiInstance_->onSourceEdited([&](mirai::source *source) { refreshModels(); }); refreshModels();
miraiInstance_->onSourceDeleted([&](int id) { refreshModels(); }); });
miraiInstance_->onSourceEdited([&](mirai::Source *source) {
refreshModels();
});
miraiInstance_->onSourceDeleted([&](int id) {
refreshModels();
});
actions().on_task_clicked([&](int sourceId, int taskId) { actions().on_task_clicked([&](int sourceId, int taskId) {
auto source = miraiInstance_->getSourceById(sourceId); auto source = miraiInstance_->getSourceById(sourceId);
assert(source); assert(source);
auto task = source->get_task_by_id(taskId); auto task = source->getTaskById(taskId);
assert(task); assert(task);
task->set_checked(!task->checked()); if (!task->checked() && !task->hasDate() && !task->hasEvent()) {
task->setDate(mirai::Date(mirai::Date(std::chrono::system_clock::now())));
}
task->setChecked(!task->checked());
miraiInstance_->save(); miraiInstance_->save();
update_views(); view_.update();
// view_.update();
reloadTasks(); reloadTasks();
}); });
actions().on_source_clicked([&](int index) { actions().on_source_clicked([&](int index) {
// index with value -1 is equal to no selection, aka "All" // index with value -1 is equal to no selection, aka "All"
if (index == -1) { if (index == -1) {
show_all_sources(); view_.setAllSources();
// view_.setAllSources();
} else { } else {
hide_all_sources(); view_.removeSources();
// view_.removeSources(); const mirai::Source *source = miraiInstance_->getSourceById(index);
const mirai::source *source = miraiInstance_->getSourceById(index); view_.addSource(*source);
show_source(*source);
// view_.addSource(*source);
} }
// models().set_default_source_index(index == -1 ? 0 : index); models().set_default_source_index(index == -1 ? 0 : index);
update_views(); view_.update();
// view_.update();
reloadSources(); reloadSources();
reloadTasks(); reloadTasks();
}); });
actions().on_add_source([&](slint::SharedString name, slint::SharedString path) { actions().on_add_source([&](slint::SharedString name, slint::SharedString path) {
std::unique_ptr<mirai::data_provider> file = std::unique_ptr<mirai::DataProvider> file =
std::make_unique<mirai::markdown_data_provider>(std::string(path)); std::make_unique<mirai::MarkdownDataProvider>(std::string(path));
miraiInstance_->addSource(std::string(name), "FileSystemMarkdown", std::move(file)); miraiInstance_->addSource(std::string(name), "FileSystemMarkdown", std::move(file));
}); });
@ -174,39 +174,39 @@ void AppWindow::setupCallbacks()
actions().on_delete_task_clicked([&](int sourceId, int taskId) { actions().on_delete_task_clicked([&](int sourceId, int taskId) {
auto source = miraiInstance_->getSourceById(sourceId); auto source = miraiInstance_->getSourceById(sourceId);
assert(source); assert(source);
auto task = source->get_task_by_id(taskId); auto task = source->getTaskById(taskId);
assert(task); assert(task);
source->remove_task(*task); source->removeTask(*task);
miraiInstance_->save(); miraiInstance_->save();
// view_.update(); view_.update();
update_views();
reloadTasks(); reloadTasks();
}); });
actions().on_toggle_show_completed_tasks([&] { actions().on_toggle_show_completed_tasks([&] {
// view_.hideCompletedTasks(!view_.shouldHideCompletedTasks()); view_.hideCompletedTasks(!view_.shouldHideCompletedTasks());
if (should_hide_completed_tasks()) { view_.update();
show_completed_tasks();
} else {
hide_completed_tasks();
}
// view_.update();
update_views();
reloadTasks(); reloadTasks();
}); });
actions().on_save_task([&](ui::SaveTaskData newTaskData) { actions().on_save_task([&](ui::SaveTaskData newTaskData) {
auto source = miraiInstance_->getSourceById(newTaskData.sourceId); auto source = miraiInstance_->getSourceById(newTaskData.sourceId);
assert(source); assert(source);
auto task = source->get_task_by_id(newTaskData.id); auto task = source->getTaskById(newTaskData.id);
assert(task.has_value()); assert(task.has_value());
const mirai::Date &date = SlintDateToMiraiDate(newTaskData.date); const mirai::Date &date = SlintDateToMiraiDate(newTaskData.date);
// const auto dayOpt = source->get_day_by_date(date); const auto dayOpt = source->getDayByDate(date);
task->set_title(std::string(newTaskData.title)); task->setTitle(std::string(newTaskData.title));
if (!task.value().hasEvent() && date.year != 0) {
task->setDate(date);
}
if (!task.value().hasEvent() && date.year == 0) {
task->unschedule();
}
miraiInstance_->save(); miraiInstance_->save();
// view_.update(); view_.update();
update_views();
reloadTasks(); reloadTasks();
}); });
@ -219,47 +219,45 @@ void AppWindow::setupCallbacks()
std::optional<mirai::Event> event = std::nullopt; std::optional<mirai::Event> event = std::nullopt;
if (newTaskData.eventId >= 0) { if (newTaskData.eventId >= 0) {
event = source->get_event_by_id(newTaskData.eventId); event = source->getEventById(newTaskData.eventId);
} }
source->create_task({ source->createTask({
.title = std::string(newTaskData.title), .title = std::string(newTaskData.title),
.due_date = date, .event = event,
.date = date,
}); });
miraiInstance_->save(); miraiInstance_->save();
// view_.update(); view_.update();
update_views();
reloadTasks(); reloadTasks();
}); });
actions().on_delete_event([&](int sourceId, int eventId) { actions().on_delete_event([&](int sourceId, int eventId) {
auto source = miraiInstance_->getSourceById(sourceId); auto source = miraiInstance_->getSourceById(sourceId);
assert(source); assert(source);
auto event = source->get_event_by_id(eventId); auto event = source->getEventById(eventId);
assert(event.has_value()); assert(event.has_value());
source->remove_event(event.value()); source->removeEvent(event.value());
miraiInstance_->save(); miraiInstance_->save();
// view_.update(); view_.update();
update_views();
reloadTasks(); reloadTasks();
}); });
actions().on_create_event([&](ui::CreateEventParams newEventParams) { actions().on_create_event([&](ui::CreateEventParams newEventParams) {
const ui::Date &date = newEventParams.date; const ui::Date &date = newEventParams.date;
const std::string dateStr = SlintDateToStdString(date); const std::string dateStr = SlintDateToStdString(date);
// const auto sourceId = models().get_default_source_index(); const auto sourceId = models().get_default_source_index();
// auto source = miraiInstance_->getSourceById(sourceId == -1 ? 0 : sourceId); auto source = miraiInstance_->getSourceById(sourceId == -1 ? 0 : sourceId);
/* source->create_event({*/ source->createEvent({
/*.title = std::string(newEventParams.title),*/ .title = std::string(newEventParams.title),
/*.date = SlintDateToMiraiDate(newEventParams.date),*/ .date = SlintDateToMiraiDate(newEventParams.date),
/*.starts_at = SlintTimeToMiraiTime(newEventParams.startsAt),*/ .startsAt = SlintTimeToMiraiTime(newEventParams.startsAt),
/*.ends_at = SlintTimeToMiraiTime(newEventParams.endsAt),*/ .endsAt = SlintTimeToMiraiTime(newEventParams.endsAt),
/*});*/ });
miraiInstance_->save(); miraiInstance_->save();
// view_.update(); view_.update();
update_views();
reloadTasks(); reloadTasks();
}); });
} }
@ -276,410 +274,157 @@ stdToSlintStringVector(const std::vector<std::string> &stdVector)
void AppWindow::reloadTasks() void AppWindow::reloadTasks()
{ {
/* days_->clear();*/ days_->clear();
/*if (miraiInstance_->getSources().size() == 0) {*/ if (miraiInstance_->getSources().size() == 0) {
/*return;*/ return;
/*}*/
/*auto todayDate = mirai::Date(std::chrono::system_clock::now());*/
/*auto dates = view_.getDates();*/
/*auto slintDays = std::make_shared<slint::VectorModel<ui::Day>>();*/
/*for (int dayIndex = 0; dayIndex < dates.size(); ++dayIndex) {*/
/*auto &currentDate = dates.at(dayIndex);*/
/*auto slintEvents = std::make_shared<slint::VectorModel<ui::Event>>();*/
/*auto slintDayTasks = std::make_shared<slint::VectorModel<ui::TaskData>>();*/
/*auto relativeDaysDiff = std::chrono::duration_cast<std::chrono::days>(*/
/*std::chrono::sys_days(currentDate.toStdChrono()) -*/
/*std::chrono::sys_days(todayDate.toStdChrono())*/
/*)*/
/*.count();*/
/*slintDays->push_back(*/
/*ui::Day{*/
/*.date = MiraiDateToSlintDate(currentDate),*/
/*.events = slintEvents,*/
/*.tasks = slintDayTasks,*/
/*.isLate = currentDate < todayDate,*/
/*.isToday = currentDate == todayDate,*/
/*.relativeDaysDiff = static_cast<int>(relativeDaysDiff)*/
/*}*/
/*);*/
/*Day's tasks*/
/*const std::vector<mirai::Task> tasksForDate = view_.getTasksForDate(currentDate);*/
/*for (int taskIndex = 0; taskIndex < tasksForDate.size(); ++taskIndex) {*/
/*auto &task = tasksForDate.at(taskIndex);*/
/*slintDayTasks->push_back({*/
/*.sourceId = task.sourceId(),*/
/*.eventId = -1,*/
/*.id = task.id(),*/
/*.title = slint::SharedString(task.title()),*/
/*.checked = task.checked(),*/
/*});*/
/*}*/
/*Day's events*/
/*const std::vector<mirai::Event> eventsForDate = view_.getEventsForDate(currentDate);*/
/*for (int eventIndex = 0; eventIndex < eventsForDate.size(); ++eventIndex) {*/
/*auto &currentEvent = eventsForDate.at(eventIndex);*/
/*auto slintTasks = std::make_shared<slint::VectorModel<ui::TaskData>>();*/
/*slintEvents->push_back(*/
/*ui::Event{*/
/*.sourceId = currentEvent.source_id(),*/
/*.id = currentEvent.id(),*/
/*.title = slint::SharedString(currentEvent.title()),*/
/*.startsAt = MiraiTimeToSlintTime(currentEvent.startsAt()),*/
/*.endsAt = MiraiTimeToSlintTime(currentEvent.endsAt()),*/
/*.tasks = slintTasks,*/
/*}*/
/*);*/
/*auto eventTasks = currentEvent.queryTasks();*/
/*for (int taskIndex = 0; taskIndex < eventTasks.size(); ++taskIndex) {*/
/*auto &task = eventTasks.at(taskIndex);*/
/*slintTasks->push_back({*/
/*.sourceId = task.sourceId(),*/
/*.eventId = currentEvent.id(),*/
/*.id = task.id(),*/
/*.title = slint::SharedString(task.title()),*/
/*.checked = task.checked(),*/
/*});*/
/*}*/
/*}*/
/*}*/
/*days_ = slintDays;*/
/*models().set_days(days_);*/
/*auto unscheduledTasksView = view_.getUnscheduledTasks();*/
/*unscheduledTasks_->clear();*/
/*for (int taskIndex = 0; taskIndex < unscheduledTasksView.size(); ++taskIndex) {*/
/*auto &task = unscheduledTasksView.at(taskIndex);*/
/*const auto &source = miraiInstance_->getSourceById(task.sourceId());*/
/*std::println("request name for source id {} : {}", task.sourceId(), source->name());*/
/*unscheduledTasks_->push_back({*/
/*.sourceId = task.sourceId(),*/
/*.eventId = -1,*/
/*.id = task.id(),*/
/*.title = slint::SharedString(task.title()),*/
/*.checked = task.checked(),*/
/*});*/
/*}*/
/*models().set_unscheduled_tasks(unscheduledTasks_);*/
/*calendar_->clear();*/
/*for (int dayIndex = 0; dayIndex < 7; ++dayIndex) {*/
/*std::chrono::year_month_day nextDate =*/
/*std::chrono::floor<std::chrono::days>(std::chrono::system_clock::now()) +*/
/*std::chrono::days{dayIndex};*/
/*auto currentDate = mirai::Date{nextDate};*/
/*auto events = view_.getEventsForDate(currentDate);*/
/*auto slintEvents = std::make_shared<slint::VectorModel<ui::CalendarDayEvent>>();*/
/*auto relativeDaysDiff = std::chrono::duration_cast<std::chrono::days>(*/
/*std::chrono::sys_days(currentDate.toStdChrono()) -*/
/*std::chrono::sys_days(todayDate.toStdChrono())*/
/*)*/
/*.count();*/
/*if (relativeDaysDiff < 0 || relativeDaysDiff >= 7) {*/
/*continue;*/
/*}*/
/*const std::vector<mirai::Event> eventsForDate = view_.getEventsForDate(currentDate);*/
/*for (int eventIndex = 0; eventIndex < eventsForDate.size(); ++eventIndex) {*/
/*auto &currentEvent = eventsForDate.at(eventIndex);*/
/*slintEvents->push_back(*/
/*ui::CalendarDayEvent{*/
/*.sourceId = currentEvent.source_id(),*/
/*.id = currentEvent.id(),*/
/*.title = slint::SharedString(currentEvent.title()),*/
/*.startsAt = MiraiTimeToSlintTime(currentEvent.startsAt()),*/
/*.endsAt = MiraiTimeToSlintTime(currentEvent.endsAt()),*/
/*}*/
/*);*/
/*}*/
/*auto calendarDay = ui::CalendarDay{*/
/*.events = slintEvents,*/
/*.date = MiraiDateToSlintDate(currentDate),*/
/*.header = slint::SharedString(*/
/*capitalize(formatDateRelative(MiraiDateToSlintDate(currentDate)))*/
/*)*/
/*};*/
/*calendar_->push_back(calendarDay);*/
/*}*/
}
void AppWindow::reloadSources()
{
/*sources_->clear();*/
/*bool noSourceSelected = miraiInstance_->getSources().size() == view_.activeSourceCount();*/
/*for (const auto &source : miraiInstance_->getSources()) {*/
/*bool isSourceSelected = view_.isSourceSelected(*source);*/
/*mirai::markdown_data_provider *sourceProvider =*/
/*dynamic_cast<mirai::markdown_data_provider *>(source->data_provider());*/
/*sources_->push_back(*/
/*{.id = source->id,*/
/*.name = slint::SharedString(source->name()),*/
/*.selected = isSourceSelected && !noSourceSelected,*/
/*.path = slint::SharedString(sourceProvider->path())}*/
/*);*/
/*}*/
/*models().set_no_source_selected(noSourceSelected);*/
}
void AppWindow::refreshModels()
{
show_all_sources();
update_views();
}
void AppWindow::update_views()
{
update_sidebar_view();
update_calendar_view();
update_tasks_view();
}
void AppWindow::update_sidebar_view()
{
const auto &sources = miraiInstance_->getSources();
auto new_sources = std::make_shared<slint::VectorModel<ui::SidebarViewSources>>();
std::println("sources");
for (auto &source : sources) {
std::println("source: {}", source->name());
mirai::markdown_data_provider *sourceProvider =
dynamic_cast<mirai::markdown_data_provider *>(source->data_provider());
new_sources->push_back(
{.id = source->id, .name = slint::SharedString(source->name()), .active = false}
);
} }
auto todayDate = mirai::Date(std::chrono::system_clock::now());
_sidebar_view.sources = new_sources; auto dates = view_.getDates();
_sidebar_view.all_active = true; // TESTING auto slintDays = std::make_shared<slint::VectorModel<ui::Day>>();
_sidebar_view.active_view = ui::SidebarViewActiveTab::Calendar; for (int dayIndex = 0; dayIndex < dates.size(); ++dayIndex) {
models().set_sidebar_view(_sidebar_view); auto &currentDate = dates.at(dayIndex);
} auto slintEvents = std::make_shared<slint::VectorModel<ui::Event>>();
auto slintDayTasks = std::make_shared<slint::VectorModel<ui::TaskData>>();
std::vector<mirai::Event> auto relativeDaysDiff = std::chrono::duration_cast<std::chrono::days>(
get_all_events_from_sources(std::vector<std::unique_ptr<mirai::source>> &sources) std::chrono::sys_days(currentDate.toStdChrono()) -
{ std::chrono::sys_days(todayDate.toStdChrono())
std::vector<mirai::Event> all_events;
for (auto &source : sources) {
const auto &events = source->get_events();
all_events.insert(all_events.end(), events.begin(), events.end());
}
return all_events;
}
std::vector<mirai::Event>
get_events_for_date(const std::vector<mirai::Event> &events, const mirai::Date &date)
{
auto filtered_events = events | std::ranges::views::filter([&](const mirai::Event &event) {
return event.date() == date;
});
return std::ranges::to<std::vector>(filtered_events);
}
void AppWindow::update_calendar_view()
{
auto today = mirai::Date(std::chrono::system_clock::now());
auto new_slint_dates = std::make_shared<slint::VectorModel<ui::CalendarViewDate>>();
auto &sources = miraiInstance_->getSources();
auto all_events = get_all_events_from_sources(sources);
for (int day_index = 0; day_index < 7; ++day_index) {
std::chrono::year_month_day next_date =
std::chrono::floor<std::chrono::days>(std::chrono::system_clock::now())
+ std::chrono::days{day_index};
auto current_date = mirai::Date{next_date};
auto new_slint_events = std::make_shared<slint::VectorModel<ui::CalendarViewEvent>>();
auto relative_days_diff = std::chrono::duration_cast<std::chrono::days>(
std::chrono::sys_days(current_date.toStdChrono())
- std::chrono::sys_days(today.toStdChrono())
) )
.count(); .count();
if (relative_days_diff < 0 || relative_days_diff >= 7) { slintDays->push_back(
ui::Day{
.date = MiraiDateToSlintDate(currentDate),
.events = slintEvents,
.tasks = slintDayTasks,
.isLate = currentDate < todayDate,
.isToday = currentDate == todayDate,
.relativeDaysDiff = static_cast<int>(relativeDaysDiff)
}
);
// Day's tasks
const std::vector<mirai::Task> tasksForDate = view_.getTasksForDate(currentDate);
for (int taskIndex = 0; taskIndex < tasksForDate.size(); ++taskIndex) {
auto &task = tasksForDate.at(taskIndex);
slintDayTasks->push_back({
.sourceId = task.sourceId(),
.eventId = -1,
.id = task.id(),
.title = slint::SharedString(task.title()),
.checked = task.checked(),
});
}
// Day's events
const std::vector<mirai::Event> eventsForDate = view_.getEventsForDate(currentDate);
for (int eventIndex = 0; eventIndex < eventsForDate.size(); ++eventIndex) {
auto &currentEvent = eventsForDate.at(eventIndex);
auto slintTasks = std::make_shared<slint::VectorModel<ui::TaskData>>();
slintEvents->push_back(
ui::Event{
.sourceId = currentEvent.sourceId(),
.id = currentEvent.id(),
.title = slint::SharedString(currentEvent.title()),
.startsAt = MiraiTimeToSlintTime(currentEvent.startsAt()),
.endsAt = MiraiTimeToSlintTime(currentEvent.endsAt()),
.tasks = slintTasks,
}
);
auto eventTasks = currentEvent.queryTasks();
for (int taskIndex = 0; taskIndex < eventTasks.size(); ++taskIndex) {
auto &task = eventTasks.at(taskIndex);
slintTasks->push_back({
.sourceId = task.sourceId(),
.eventId = currentEvent.id(),
.id = task.id(),
.title = slint::SharedString(task.title()),
.checked = task.checked(),
});
}
}
}
days_ = slintDays;
models().set_days(days_);
auto unscheduledTasksView = view_.getUnscheduledTasks();
unscheduledTasks_->clear();
for (int taskIndex = 0; taskIndex < unscheduledTasksView.size(); ++taskIndex) {
auto &task = unscheduledTasksView.at(taskIndex);
const auto &source = miraiInstance_->getSourceById(task.sourceId());
std::println("request name for source id {} : {}", task.sourceId(), source->name());
unscheduledTasks_->push_back({
.sourceId = task.sourceId(),
.eventId = -1,
.id = task.id(),
.title = slint::SharedString(task.title()),
.checked = task.checked(),
});
}
models().set_unscheduled_tasks(unscheduledTasks_);
calendar_->clear();
for (int dayIndex = 0; dayIndex < 7; ++dayIndex) {
std::chrono::year_month_day nextDate =
std::chrono::floor<std::chrono::days>(std::chrono::system_clock::now()) +
std::chrono::days{dayIndex};
auto currentDate = mirai::Date{nextDate};
auto events = view_.getEventsForDate(currentDate);
auto slintEvents = std::make_shared<slint::VectorModel<ui::CalendarDayEvent>>();
auto relativeDaysDiff = std::chrono::duration_cast<std::chrono::days>(
std::chrono::sys_days(currentDate.toStdChrono()) -
std::chrono::sys_days(todayDate.toStdChrono())
)
.count();
if (relativeDaysDiff < 0 || relativeDaysDiff >= 7) {
continue; continue;
} }
auto events_for_date = get_events_for_date(all_events, current_date); const std::vector<mirai::Event> eventsForDate = view_.getEventsForDate(currentDate);
for (int event_index = 0; event_index < events_for_date.size(); ++event_index) { for (int eventIndex = 0; eventIndex < eventsForDate.size(); ++eventIndex) {
auto &current_event = events_for_date.at(event_index); auto &currentEvent = eventsForDate.at(eventIndex);
new_slint_events->push_back( slintEvents->push_back(
ui::CalendarViewEvent{ ui::CalendarDayEvent{
.source_id = current_event.source_id(), .sourceId = currentEvent.sourceId(),
.id = current_event.id(), .id = currentEvent.id(),
.title = slint::SharedString(current_event.title()), .title = slint::SharedString(currentEvent.title()),
.starts_at = MiraiTimeToSlintTime(current_event.starts_at()), .startsAt = MiraiTimeToSlintTime(currentEvent.startsAt()),
.ends_at = MiraiTimeToSlintTime(current_event.ends_at()), .endsAt = MiraiTimeToSlintTime(currentEvent.endsAt()),
} }
); );
} }
auto new_slint_date = ui::CalendarViewDate{ auto calendarDay = ui::CalendarDay{
.events = new_slint_events, .events = slintEvents,
.date = MiraiDateToSlintDate(current_date), .date = MiraiDateToSlintDate(currentDate),
.header = slint::SharedString( .header = slint::SharedString(
capitalize(formatDateRelative(MiraiDateToSlintDate(current_date))) capitalize(formatDateRelative(MiraiDateToSlintDate(currentDate)))
) )
}; };
new_slint_dates->push_back(new_slint_date); calendar_->push_back(calendarDay);
}
_calendar_view.dates = new_slint_dates;
models().set_calendar_view(_calendar_view);
}
std::vector<mirai::Task>
get_all_tasks_from_sources(std::vector<std::unique_ptr<mirai::source>> &sources)
{
std::vector<mirai::Task> all_tasks;
for (auto &source : sources) {
const auto &tasks = source->get_tasks();
all_tasks.insert(all_tasks.end(), tasks.begin(), tasks.end());
}
std::sort(all_tasks.begin(), all_tasks.end(), [](const mirai::Task &t1, const mirai::Task &t2) {
if (!t1.has_due_date() && !t2.has_due_date()) {
return false;
}
if (t1.has_due_date() && !t2.has_due_date()) {
return true;
}
if (!t1.has_due_date() && t2.has_due_date()) {
return false;
}
return t1.due_date() < t2.due_date();
});
return all_tasks;
}
struct tasks_source_group {
int id;
std::vector<mirai::Task> tasks;
};
struct tasks_date_group {
std::optional<mirai::Date> date;
std::vector<tasks_source_group> sources;
};
std::vector<tasks_date_group> group_tasks_by_date(const std::vector<mirai::Task> &tasks)
{
if (tasks.size() == 0) {
return {};
}
std::vector<tasks_date_group> dates_group;
int next_task_index = 0;
mirai::Task current_task = tasks.at(next_task_index);
while (next_task_index < tasks.size()) {
tasks_date_group date_group{.date = current_task.due_date()};
while (next_task_index < tasks.size() && current_task.due_date() == date_group.date) {
tasks_source_group source_group{.id = current_task.source_id()};
while (next_task_index < tasks.size() && current_task.due_date() == date_group.date
&& current_task.source_id() == source_group.id) {
source_group.tasks.push_back(current_task);
next_task_index++;
if (next_task_index >= tasks.size()) {
break;
}
current_task = tasks.at(next_task_index);
}
date_group.sources.push_back(source_group);
}
dates_group.push_back(date_group);
}
return dates_group;
};
void AppWindow::update_tasks_view()
{
auto today = mirai::Date(std::chrono::system_clock::now());
auto new_slint_dates = std::make_shared<slint::VectorModel<ui::TasksViewDate>>();
auto &sources = miraiInstance_->getSources();
auto all_tasks_dates = group_tasks_by_date(get_all_tasks_from_sources(sources));
for (int date_index = 0; date_index < all_tasks_dates.size(); ++date_index) {
auto &current_date_group = all_tasks_dates.at(date_index);
auto &current_date = current_date_group.date;
std::optional<int> relative_days_diff = std::nullopt;
if (current_date.has_value()) {
relative_days_diff = std::chrono::duration_cast<std::chrono::days>(
std::chrono::sys_days(current_date.value().toStdChrono())
- std::chrono::sys_days(today.toStdChrono())
)
.count();
}
auto new_slint_sources = std::make_shared<slint::VectorModel<ui::TasksViewSource>>();
for (auto &source : current_date_group.sources) {
auto new_slint_source = ui::TasksViewSource();
auto new_slint_tasks = std::make_shared<slint::VectorModel<ui::TasksViewTask>>();
for (auto &task : source.tasks) {
if (task.has_due_date() && task.due_date() < today) {
continue;
}
new_slint_tasks->push_back(
{.id = task.id(),
.source_id = source.id,
.title = slint::SharedString(task.title()),
.checked = task.checked()}
);
}
new_slint_source.tasks = new_slint_tasks;
new_slint_source.id = source.id;
new_slint_source.name =
slint::SharedString(miraiInstance_->getSourceById(source.id)->name());
const auto color =
selenite::hexStringToColor(miraiInstance_->getSourceById(source.id)->color());
new_slint_source.color = slint::Color::from_rgb_uint8(color.r, color.g, color.b);
if (new_slint_source.tasks->row_count() > 0) {
new_slint_sources->push_back(new_slint_source);
}
}
auto new_slint_date = ui::TasksViewDate{
.sources = new_slint_sources,
};
if (current_date.has_value()) {
new_slint_date.due_date = MiraiDateToSlintDate(current_date.value());
new_slint_date.is_late = current_date.value() < today;
} else {
new_slint_date.no_date = true;
}
if (new_slint_date.sources->row_count() > 0) {
new_slint_dates->push_back(new_slint_date);
}
_tasks_view.dates = new_slint_dates;
models().set_tasks_view(_tasks_view);
} }
} }
void AppWindow::show_source(const mirai::source &source) void AppWindow::reloadSources()
{ {
sources_->clear();
bool noSourceSelected = miraiInstance_->getSources().size() == view_.activeSourceCount();
for (const auto &source : miraiInstance_->getSources()) {
bool isSourceSelected = view_.isSourceSelected(*source);
mirai::MarkdownDataProvider *sourceProvider =
dynamic_cast<mirai::MarkdownDataProvider *>(source->dataProvider());
sources_->push_back(
{.id = source->id,
.name = slint::SharedString(source->name()),
.selected = isSourceSelected && !noSourceSelected,
.path = slint::SharedString(sourceProvider->path())}
);
}
models().set_no_source_selected(noSourceSelected);
} }
void AppWindow::show_all_sources() void AppWindow::refreshModels()
{ {
} view_.setAllSources();
view_.update();
void AppWindow::hide_all_sources() reloadSources();
{ reloadTasks();
}
void AppWindow::show_completed_tasks()
{
}
void AppWindow::hide_completed_tasks()
{
}
bool AppWindow::should_hide_completed_tasks() const
{
return true;
} }
void AppWindow::run() void AppWindow::run()

27
src/windows/AppWindow/AppWindow.h
View file

@ -7,10 +7,9 @@
#pragma once #pragma once
#include "mirai-core/Mirai.h" #include "mirai-core/Mirai.h"
#include "mirai-core/Source.h" #include "mirai-core/View.h"
#include "slint.h" #include "slint.h"
#include "ui.h" #include "ui.h"
#include <vector>
class AppWindow class AppWindow
{ {
@ -24,32 +23,18 @@ class AppWindow
void reloadTasks(); void reloadTasks();
void refreshModels(); void refreshModels();
void update_views();
void update_sidebar_view();
void update_calendar_view();
void update_tasks_view();
void show_all_sources();
void show_source(const mirai::source &source);
void hide_all_sources();
void show_completed_tasks();
void hide_completed_tasks();
bool should_hide_completed_tasks() const;
private: private:
void setupCallbacks(); void setupCallbacks();
const ui::AppModels &models(); const ui::AppModels &models();
const ui::AppActions &actions(); const ui::AppActions &actions();
ui::SidebarView _sidebar_view; std::shared_ptr<slint::VectorModel<ui::Source>> sources_;
ui::TasksView _tasks_view; std::shared_ptr<slint::VectorModel<ui::Day>> days_;
ui::CalendarView _calendar_view; std::shared_ptr<slint::VectorModel<ui::CalendarDay>> calendar_;
std::shared_ptr<slint::VectorModel<ui::TaskData>> unscheduledTasks_;
slint::ComponentHandle<ui::AppWindow> mainWindow_ = ui::AppWindow::create(); slint::ComponentHandle<ui::AppWindow> mainWindow_ = ui::AppWindow::create();
mirai::Mirai *miraiInstance_; mirai::Mirai *miraiInstance_;
mirai::View view_;
std::vector<int> _source_filters;
bool _should_hide_completed_tasks;
}; };

5
src/windows/AppWindow/views/CalendarView.slint
View file

@ -1,7 +1,8 @@
import { AppModels } from "../../../shared/Models.slint"; import { AppModels, TaskData } from "../../../shared/Models.slint";
import { AppActions, NewTaskData, SaveTaskData } from "../../../shared/Actions.slint"; import { AppActions, NewTaskData, SaveTaskData } from "../../../shared/Actions.slint";
import { Button, VerticalBox, CheckBox, ScrollView, ComboBox } from "std-widgets.slint"; import { Button, VerticalBox, CheckBox, ScrollView, ComboBox } from "std-widgets.slint";
import { TaskLine } from "../../../components/TaskLine.slint"; import { TaskLine } from "../../../components/TaskLine.slint";
import { EventGroup } from "../../../components/EventGroup.slint";
import { Calendar } from "../../../components/Calendar.slint"; import { Calendar } from "../../../components/Calendar.slint";
import { VDatePicker, VTimePicker, VCheckBox, VButton, VTag, VText, VTextInput, Svg, Palette } from "@selenite"; import { VDatePicker, VTimePicker, VCheckBox, VButton, VTag, VText, VTextInput, Svg, Palette } from "@selenite";
import { CreateTaskOrEvent } from "../../../components/CreateTaskOrEvent.slint"; import { CreateTaskOrEvent } from "../../../components/CreateTaskOrEvent.slint";
@ -40,7 +41,7 @@ export component CalendarView inherits Rectangle {
delete-event-request(source-id, event-id) => { delete-event-request(source-id, event-id) => {
AppActions.delete-event(source-id, event-id) AppActions.delete-event(source-id, event-id)
} }
days: AppModels.calendar-view.dates; days: AppModels.calendar;
current-date: Utils.current-date; current-date: Utils.current-date;
current-time: Utils.current-time; current-time: Utils.current-time;
} }

16
src/windows/AppWindow/views/SideBar.slint
View file

@ -1,4 +1,4 @@
import { AppModels } from "../../../shared/Models.slint"; import { AppModels, TaskData } from "../../../shared/Models.slint";
import { AppActions } from "../../../shared/Actions.slint"; import { AppActions } from "../../../shared/Actions.slint";
import { VButton, ToggleButton, VActionButton, VText, Svg, Palette } from "@selenite"; import { VButton, ToggleButton, VActionButton, VText, Svg, Palette } from "@selenite";
import { EditSourceModal } from "../../../modals/EditSourceModal.slint"; import { EditSourceModal } from "../../../modals/EditSourceModal.slint";
@ -10,7 +10,7 @@ export component SideBar inherits Rectangle {
editSourcePopup.edit(source-id) editSourcePopup.edit(source-id)
} }
addSourcePopup := AddSourceModal{} addSourcePopup := AddSourceModal{}
editSourcePopup := EditSourceModal {} editSourcePopup := EditSourceModal {}
VerticalLayout { VerticalLayout {
@ -46,17 +46,17 @@ export component SideBar inherits Rectangle {
ToggleButton { ToggleButton {
text: "All"; text: "All";
text-alignment: left; text-alignment: left;
active: AppModels.sidebar-view.all-active; active: AppModels.no-source-selected;
clicked => { AppActions.source-clicked(-1) } clicked => { AppActions.source-clicked(-1) }
} }
for source[index] in AppModels.sidebar-view.sources: ToggleButton { for item[index] in AppModels.sources-selected: ToggleButton {
text: source.name; text: item.name;
text-alignment: left; text-alignment: left;
active: source.active; active: item.selected;
clicked => { AppActions.source-clicked(source.id) } clicked => { AppActions.source-clicked(item.id) }
right-clicked => { editSourcePopup.edit(source.id) } right-clicked => { editSourcePopup.edit(item.id) }
} }
} }
VerticalLayout { VerticalLayout {

151
src/windows/AppWindow/views/TasksView.slint
View file

@ -1,7 +1,8 @@
import { AppModels } from "../../../shared/Models.slint"; import { AppModels, TaskData } from "../../../shared/Models.slint";
import { AppActions, NewTaskData, SaveTaskData } from "../../../shared/Actions.slint"; import { AppActions, NewTaskData, SaveTaskData } from "../../../shared/Actions.slint";
import { Button, VerticalBox, CheckBox, ScrollView, ComboBox } from "std-widgets.slint"; import { Button, VerticalBox, CheckBox, ScrollView, ComboBox } from "std-widgets.slint";
import { TaskLine } from "../../../components/TaskLine.slint"; import { TaskLine } from "../../../components/TaskLine.slint";
import { EventGroup } from "../../../components/EventGroup.slint";
import { Calendar } from "../../../components/Calendar.slint"; import { Calendar } from "../../../components/Calendar.slint";
import { VPopupIconMenu, VDatePicker, VTimePicker, VCheckBox, VButton, VTag, VText, VTextInput, Svg, Palette } from "@selenite"; import { VPopupIconMenu, VDatePicker, VTimePicker, VCheckBox, VButton, VTag, VText, VTextInput, Svg, Palette } from "@selenite";
import { CreateTaskOrEvent } from "../../../components/CreateTaskOrEvent.slint"; import { CreateTaskOrEvent } from "../../../components/CreateTaskOrEvent.slint";
@ -36,7 +37,7 @@ export component MainView inherits Rectangle {
} }
CreateTaskOrEvent { CreateTaskOrEvent {
sources: AppModels.tasks-view.sources; sources: AppModels.sources;
create-task(data) => { create-task(data) => {
AppActions.create-task({ AppActions.create-task({
sourceId: data.sourceId, sourceId: data.sourceId,
@ -53,66 +54,106 @@ export component MainView inherits Rectangle {
horizontal-stretch: 1; horizontal-stretch: 1;
VerticalLayout { VerticalLayout {
alignment: start; alignment: start;
if AppModels.tasks-view.dates.length == 0 : VText { if AppModels.days.length == 0 && AppModels.unscheduled-tasks.length == 0 : VText {
text: "There is no task to show"; text: "There is no task to show";
horizontal-alignment: center; horizontal-alignment: center;
vertical-alignment: center; vertical-alignment: center;
} }
for day[dayIndex] in AppModels.tasks-view.dates: VerticalLayout { for day[dayIndex] in AppModels.days: VerticalLayout {
spacing: day.sources.length > 0 ? 16px : 0px; spacing: day.tasks.length > 0 ? 16px : 0px;
padding-bottom: 32px; padding-bottom: 32px;
HorizontalLayout { if day.tasks.length > 0 : Rectangle {
alignment: start; border-radius: 8px;
VText { VerticalLayout {
text: day.no-date ? "Unscheduled" : Utils.format-date(day.due-date); HorizontalLayout {
color: day.is-late ? Palette.orange : Palette.foreground; alignment: start;
font-size: 1.2rem; VText {
text: Utils.format-date(day.date);
color: day.isLate ? Palette.orange : Palette.foreground;
font-size: 1.2rem;
}
VerticalLayout {
alignment: center;
VText {
text: day.relativeDaysDiff == 0 ? " - today" :
day.relativeDaysDiff == 1 ? " - tomorrow" :
day.relativeDaysDiff == -1 ? " - yesterday" :
day.relativeDaysDiff > 0 ? " - in \{day.relativeDaysDiff} days" :
" - \{-day.relativeDaysDiff} days ago";
color: Palette.foreground-hint;
font-size: 1rem;
}
}
}
for task[taskIndex] in day.tasks: VerticalLayout {
padding-top: taskIndex == 0 ? 16px : 0px;
padding-bottom: 8px;
TaskLine {
title: task.title;
source-name: AppModels.get-source-name-from-id(task.sourceId);
source-color: AppModels.get-source-color-from-id-as-color(task.sourceId);
scheduled: task.date.year != 0;
date: day.date;
checked: task.checked;
allow-edit-date: true;
delete => {
AppActions.delete-task-clicked(task.sourceId, task.id)
}
toggle-check => {
AppActions.task-clicked(task.sourceId, task.id);
}
edited(data) => {
AppActions.save-task({
id: task.id,
sourceId: task.sourceId,
title: data.title,
scheduled: data.scheduled,
date: data.date
})
}
}
}
} }
//VerticalLayout {
//alignment: center;
//VText {
//text: day.relativeDaysDiff == 0 ? " - today" :
//day.relativeDaysDiff == 1 ? " - tomorrow" :
//day.relativeDaysDiff == -1 ? " - yesterday" :
//day.relativeDaysDiff > 0 ? " - in \{day.relativeDaysDiff} days" :
//" - \{-day.relativeDaysDiff} days ago";
//color: Palette.foreground-hint;
//font-size: 1rem;
//}
//}
} }
}
for source[source-index] in day.sources: VerticalLayout { if AppModels.unscheduled-tasks.length > 0 : VerticalLayout {
VText { Rectangle {
text: source.name; //background: Palette.card-background;
} border-radius: 8px;
if source.tasks.length > 0 : Rectangle { VerticalLayout {
VerticalLayout { HorizontalLayout {
for task[taskIndex] in source.tasks: VerticalLayout { alignment: start;
padding-top: taskIndex == 0 ? 16px : 0px; VText {
padding-bottom: 8px; text: "Unscheduled";
TaskLine { color: Palette.foreground;
title: task.title; font-size: 1.2rem;
source-name: AppModels.get-source-name-from-id(task.source-id); }
source-color: AppModels.get-source-color-from-id-as-color(task.source-id); }
checked: task.checked; for task[taskIndex] in AppModels.unscheduled-tasks: VerticalLayout {
allow-edit-date: true; padding-top: taskIndex == 0 ? 16px : 0px;
delete => { padding-bottom: 8px;
AppActions.delete-task-clicked(task.source-id, task.id) TaskLine {
} title: task.title;
toggle-check => { source-name: AppModels.get-source-name-from-id(task.sourceId);
AppActions.task-clicked(task.source-id, task.id); source-color: AppModels.get-source-color-from-id-as-color(task.sourceId);
} checked: task.checked;
edited(data) => { allow-edit-date: true;
AppActions.save-task({ delete => {
id: task.id, AppActions.delete-task-clicked(task.sourceId, task.id)
sourceId: task.source-id, }
title: data.title, toggle-check => {
scheduled: data.scheduled, AppActions.task-clicked(task.sourceId, task.id);
date: data.date }
}) edited(data) => {
} AppActions.save-task({
id: task.id,
sourceId: task.sourceId,
title: data.title,
scheduled: data.scheduled,
date: data.date
})
} }
} }
} }