').html(response.replace(rscript, "")).find(selector)
1560 | : response)
1561 | callback && callback.apply(self, arguments)
1562 | }
1563 | $.ajax(options)
1564 | return this
1565 | }
1566 |
1567 | var escape = encodeURIComponent
1568 |
1569 | function serialize(params, obj, traditional, scope){
1570 | var type, array = $.isArray(obj), hash = $.isPlainObject(obj)
1571 | $.each(obj, function(key, value) {
1572 | type = $.type(value)
1573 | if (scope) key = traditional ? scope :
1574 | scope + '[' + (hash || type == 'object' || type == 'array' ? key : '') + ']'
1575 | // handle data in serializeArray() format
1576 | if (!scope && array) params.add(value.name, value.value)
1577 | // recurse into nested objects
1578 | else if (type == "array" || (!traditional && type == "object"))
1579 | serialize(params, value, traditional, key)
1580 | else params.add(key, value)
1581 | })
1582 | }
1583 |
1584 | $.param = function(obj, traditional){
1585 | var params = []
1586 | params.add = function(key, value) {
1587 | if ($.isFunction(value)) value = value()
1588 | if (value == null) value = ""
1589 | this.push(escape(key) + '=' + escape(value))
1590 | }
1591 | serialize(params, obj, traditional)
1592 | return params.join('&').replace(/%20/g, '+')
1593 | }
1594 | })(Zepto)
1595 |
1596 | ;(function($){
1597 | $.fn.serializeArray = function() {
1598 | var name, type, result = [],
1599 | add = function(value) {
1600 | if (value.forEach) return value.forEach(add)
1601 | result.push({ name: name, value: value })
1602 | }
1603 | if (this[0]) $.each(this[0].elements, function(_, field){
1604 | type = field.type, name = field.name
1605 | if (name && field.nodeName.toLowerCase() != 'fieldset' &&
1606 | !field.disabled && type != 'submit' && type != 'reset' && type != 'button' && type != 'file' &&
1607 | ((type != 'radio' && type != 'checkbox') || field.checked))
1608 | add($(field).val())
1609 | })
1610 | return result
1611 | }
1612 |
1613 | $.fn.serialize = function(){
1614 | var result = []
1615 | this.serializeArray().forEach(function(elm){
1616 | result.push(encodeURIComponent(elm.name) + '=' + encodeURIComponent(elm.value))
1617 | })
1618 | return result.join('&')
1619 | }
1620 |
1621 | $.fn.submit = function(callback) {
1622 | if (0 in arguments) this.bind('submit', callback)
1623 | else if (this.length) {
1624 | var event = $.Event('submit')
1625 | this.eq(0).trigger(event)
1626 | if (!event.isDefaultPrevented()) this.get(0).submit()
1627 | }
1628 | return this
1629 | }
1630 |
1631 | })(Zepto)
1632 |
1633 | ;(function(){
1634 | // getComputedStyle shouldn't freak out when called
1635 | // without a valid element as argument
1636 | try {
1637 | getComputedStyle(undefined)
1638 | } catch(e) {
1639 | var nativeGetComputedStyle = getComputedStyle
1640 | window.getComputedStyle = function(element, pseudoElement){
1641 | try {
1642 | return nativeGetComputedStyle(element, pseudoElement)
1643 | } catch(e) {
1644 | return null
1645 | }
1646 | }
1647 | }
1648 | })()
1649 | return Zepto
1650 | }))
1651 |
--------------------------------------------------------------------------------
/src/wtplan-web/login_view.js:
--------------------------------------------------------------------------------
1 | // Copyright 2017 Kjell Winblad (kjellwinblad@gmail.com, http://winsh.me)
2 | // License: MIT License, see the LICENSE file
3 |
4 | var WTPLAN = WTPLAN || {};
5 |
6 | (function() {
7 |
8 | //Constructor
9 | WTPLAN.LoginView = function(authenticateCallback) {
10 | WTPLAN.Component.call(this);
11 | this.authenticateCallback = authenticateCallback;
12 | }
13 | //Extending Component
14 | WTPLAN.LoginView.prototype = Object.create(WTPLAN.Component.prototype);
15 | WTPLAN.LoginView.prototype.constructor = WTPLAN.LoginView;
16 |
17 | //Methods
18 | WTPLAN.LoginView.prototype.render = function() {
19 | return WTPLAN.template(
20 | '\
\
21 |
Password:
\
22 |
\
23 |
\
24 |
',
25 | {});
26 |
27 | };
28 |
29 | WTPLAN.LoginView.prototype.componentDidMount = function(component) {
30 | var outerThis = this;
31 | $("#loginButton").click(function() {
32 | var password = $("#passwordField").val();
33 | outerThis.authenticateCallback(password);
34 | });
35 | };
36 |
37 | })()
38 |
--------------------------------------------------------------------------------
/src/wtplan-web/main.go:
--------------------------------------------------------------------------------
1 | // Copyright 2017 Kjell Winblad (kjellwinblad@gmail.com, http://winsh.me)
2 | // License: MIT License, see the LICENSE file
3 |
4 | package main
5 |
6 | //go:generate go run include_text/includetext.go
7 |
8 | import (
9 | "crypto/rand"
10 | "encoding/json"
11 | "flag"
12 | "fmt"
13 | "net/http"
14 | "os/exec"
15 | "os"
16 | "strings"
17 | )
18 |
19 | var authenticationTokens []string = nil
20 | var passwordGiven bool = true
21 |
22 | type addCalendarItemMessage struct {
23 | Date string `json:"date"`
24 | Duration string `json:"duration"`
25 | Description string `json:"description"`
26 | LoginToken string `json:"loginToken"`
27 | }
28 |
29 | type editCalendarItemMessage struct {
30 | Date string `json:"date"`
31 | Duration string `json:"duration"`
32 | Description string `json:"description"`
33 | ID string `json:"id"`
34 | LoginToken string `json:"loginToken"`
35 | }
36 |
37 | type removeCalendarItemMessage struct {
38 | IDs []string `json:"ids"`
39 | LoginToken string `json:"loginToken"`
40 | }
41 |
42 | type getCalendarItemsMessage struct {
43 | LoginToken string `json:"loginToken"`
44 | }
45 |
46 | type getLoginTokenMessage struct {
47 | Password string `json:"password"`
48 | }
49 |
50 | type loginTokenResponseMessage struct {
51 | LoginToken string `json:"loginToken"`
52 | }
53 |
54 | type logoutMessage struct {
55 | LoginToken string `json:"loginToken"`
56 | }
57 |
58 | func staticFileHandlerProducer(content string) func(w http.ResponseWriter, r *http.Request) {
59 | return func(w http.ResponseWriter, r *http.Request) {
60 | w.Write([]byte(content))
61 | }
62 | }
63 |
64 | func runWTPlanCommand(w http.ResponseWriter, loginToken string, command ...string) {
65 | if authenticate(loginToken, w) {
66 | cmd := exec.Command("wtplan", command...)
67 | b, err := cmd.CombinedOutput()
68 | if err != nil {
69 | http.Error(w, string(b), 500)
70 | return
71 | }
72 | w.Write(b)
73 | }
74 | }
75 |
76 | func authenticate(loginToken string, w http.ResponseWriter) bool {
77 | if ! passwordGiven {
78 | return true
79 | }
80 | for i := range(authenticationTokens) {
81 | if authenticationTokens[i] == loginToken {
82 | return true;
83 | }
84 | }
85 | http.Error(w, "NOT_AUTHENTICATED", 500)
86 | return false
87 | }
88 |
89 | func loginTokenRequest(password string) func (w http.ResponseWriter, r *http.Request){
90 | return func (w http.ResponseWriter, r *http.Request) {
91 | decoder := json.NewDecoder(r.Body)
92 | var msg getLoginTokenMessage
93 | err := decoder.Decode(&msg)
94 | defer r.Body.Close()
95 | if err != nil {
96 | http.Error(w, fmt.Sprintf("Could not parse request message %s", err.Error()), 500)
97 | return
98 | }
99 | if msg.Password == password {
100 | // Create and send back auth token
101 | token := createNewAuthenticationToken()
102 | var response loginTokenResponseMessage
103 | response.LoginToken = token
104 | b, _ := json.MarshalIndent(response, "", " ")
105 | w.Write(b)
106 | } else {
107 | http.Error(w, "NOT_AUTHENTICATED", 500)
108 | }
109 | }
110 | }
111 |
112 | func logoutRequest(w http.ResponseWriter, r *http.Request) {
113 | decoder := json.NewDecoder(r.Body)
114 | var msg logoutMessage
115 | err := decoder.Decode(&msg)
116 | defer r.Body.Close()
117 | if err != nil {
118 | http.Error(w, fmt.Sprintf("Could not parse request message %s", err.Error()), 500)
119 | return
120 | }
121 | var itemsToSave []string
122 | for _, token := range(authenticationTokens) {
123 | if token != msg.LoginToken {
124 | itemsToSave = append(itemsToSave, token)
125 | }
126 | }
127 | authenticationTokens = itemsToSave
128 | }
129 |
130 | func calendarItemsRequest(w http.ResponseWriter, r *http.Request) {
131 | decoder := json.NewDecoder(r.Body)
132 | var msg getCalendarItemsMessage
133 | err := decoder.Decode(&msg)
134 | defer r.Body.Close()
135 | if err != nil {
136 | http.Error(w, fmt.Sprintf("Could not parse request message %s", err.Error()), 500)
137 | return
138 | }
139 | runWTPlanCommand(w, msg.LoginToken, "show", "ALLJSON")
140 | }
141 |
142 | func addCalendarItemRequest(w http.ResponseWriter, r *http.Request) {
143 | decoder := json.NewDecoder(r.Body)
144 | var msg addCalendarItemMessage
145 | err := decoder.Decode(&msg)
146 | defer r.Body.Close()
147 | if err != nil {
148 | http.Error(w, fmt.Sprintf("Could not parse request message %s", err.Error()), 500)
149 | return
150 | }
151 | runWTPlanCommand(w, msg.LoginToken, "add", msg.Date, msg.Duration, msg.Description)
152 | }
153 |
154 | func removeCalendarItemRequest(w http.ResponseWriter, r *http.Request) {
155 | decoder := json.NewDecoder(r.Body)
156 | var msg removeCalendarItemMessage
157 | err := decoder.Decode(&msg)
158 | defer r.Body.Close()
159 | if err != nil {
160 | http.Error(w, "Could not parse request message", 500)
161 | return
162 | }
163 | runWTPlanCommand(w, msg.LoginToken, append([]string{"remove"}, msg.IDs...)...)
164 | }
165 |
166 | func editCalendarItemRequest(w http.ResponseWriter, r *http.Request) {
167 | decoder := json.NewDecoder(r.Body)
168 | var msg editCalendarItemMessage
169 | err := decoder.Decode(&msg)
170 | defer r.Body.Close()
171 | if err != nil {
172 | http.Error(w, fmt.Sprintf("Could not parse request message %s", err.Error()), 500)
173 | return
174 | }
175 | if authenticate(msg.LoginToken, w) {
176 | runWTPlanCommand(w, msg.LoginToken, "remove", msg.ID)
177 | runWTPlanCommand(w, msg.LoginToken, "add", msg.Date, msg.Duration, msg.Description)
178 | }
179 | }
180 |
181 | func createNewAuthenticationToken() string {
182 | letters := []rune("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ")
183 | c := 512
184 | b := make([]byte, c)
185 | token := make([]rune, c)
186 | _, err := rand.Read(b)
187 | if err != nil {
188 | fmt.Println("error:", err)
189 | os.Exit(1)
190 | }
191 | for i, _ := range(b) {
192 | token[i] = letters[(uint32(b[i]) % uint32(len(letters)))]
193 | }
194 | if len(authenticationTokens) == 10 {
195 | newAuthenticationTokens := make([]string, 9, 10)
196 | copy(newAuthenticationTokens, authenticationTokens[1:10])
197 | authenticationTokens = newAuthenticationTokens
198 | }
199 | tokenStr := string(token)
200 | authenticationTokens = append(authenticationTokens, tokenStr)
201 | return tokenStr
202 | }
203 |
204 | func main() {
205 | addressPtr := flag.String("address", "127.0.0.1:8005", "The serve address (default \"127.0.0.1:8005\")")
206 | passwordPtr := flag.String("password", "", "The password")
207 | flag.Parse()
208 | if *passwordPtr == "" {
209 | passwordGiven = false
210 | }
211 | http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
212 | indexPage := indexDhtml
213 | if *passwordPtr == "" {
214 | token := createNewAuthenticationToken()
215 | indexPage = strings.Replace(indexPage, "NOT_AUTHENTICATED", token, 1)
216 | }
217 | w.Write([]byte(indexPage))
218 | })
219 | http.HandleFunc("/lib/zepto.js", staticFileHandlerProducer(libDzeptoDjs))
220 | http.HandleFunc("/component.js", staticFileHandlerProducer(componentDjs))
221 | http.HandleFunc("/edit_item_view.js", staticFileHandlerProducer(editDitemDviewDjs))
222 | http.HandleFunc("/main_page.js", staticFileHandlerProducer(mainDpageDjs))
223 | http.HandleFunc("/flow_view.js", staticFileHandlerProducer(flowDviewDjs))
224 | http.HandleFunc("/day_list.js", staticFileHandlerProducer(dayDlistDjs))
225 | http.HandleFunc("/day_list_day.js", staticFileHandlerProducer(dayDlistDdayDjs))
226 | http.HandleFunc("/day_list_item.js", staticFileHandlerProducer(dayDlistDitemDjs))
227 | http.HandleFunc("/calendar_item.js", staticFileHandlerProducer(calendarDitemDjs))
228 | http.HandleFunc("/remote_commands.js", staticFileHandlerProducer(remoteDcommandsDjs))
229 | http.HandleFunc("/utility_functions.js", staticFileHandlerProducer(utilityDfunctionsDjs))
230 | http.HandleFunc("/login_view.js", staticFileHandlerProducer(loginDviewDjs))
231 | http.HandleFunc("/login_token_request", loginTokenRequest(*passwordPtr))
232 | http.HandleFunc("/calendar_items", calendarItemsRequest)
233 | http.HandleFunc("/add_calendar_item", addCalendarItemRequest)
234 | http.HandleFunc("/edit_calendar_item", editCalendarItemRequest)
235 | http.HandleFunc("/remove_calendar_item", removeCalendarItemRequest)
236 | http.HandleFunc("/logout", logoutRequest)
237 | fmt.Println("Starting wtplan web at http://"+*addressPtr)
238 | http.ListenAndServe(*addressPtr, nil)
239 | }
240 |
--------------------------------------------------------------------------------
/src/wtplan-web/main_page.js:
--------------------------------------------------------------------------------
1 | // Copyright 2017 Kjell Winblad (kjellwinblad@gmail.com, http://winsh.me)
2 | // License: MIT License, see the LICENSE file
3 |
4 | var WTPLAN = WTPLAN || {};
5 |
6 | (function() {
7 |
8 |
9 | //The MainPage component
10 |
11 | //Constructor
12 | WTPLAN.MainPage = function(showLogoutButton) {
13 | WTPLAN.Component.call(this);
14 | this.state = {
15 | outgoingRequest: true,
16 | page: "MAIN_PAGE",
17 | message: "",
18 | isErrorMessage: false,
19 | calendarItems: [],
20 | showLogoutButton: showLogoutButton
21 | }
22 | this._flowView = new WTPLAN.FlowView(
23 | this.openAddDialog.bind(this),
24 | this.openEditDialog.bind(this),
25 | this.removeItemAction.bind(this)
26 | );
27 | var outerThis = this;
28 | WTPLAN.remoteFetchCalendarItems(function(items) {
29 | outerThis.state.calendarItems = items;
30 | outerThis.state.outgoingRequest = false;
31 | outerThis.setState(outerThis.state);
32 | }, this.handleNotAuth(function(errorText) {
33 | outerThis.state.message = errorText;
34 | outerThis.state.isErrorMessage = true;
35 | outerThis.state.outgoingRequest = false;
36 | outerThis.setState(outerThis.state);
37 | }));
38 | }
39 | //Extending Component
40 | WTPLAN.MainPage.prototype = Object.create(WTPLAN.Component.prototype);
41 | WTPLAN.MainPage.prototype.constructor = WTPLAN.MainPage;
42 |
43 | //Render methods
44 | WTPLAN.MainPage.prototype.render = function() {
45 | if (this.state.outgoingRequest) {
46 | return "
Loading...
";
47 | } else if (this.state.page === "MAIN_PAGE") {
48 | return WTPLAN.template(
49 | '
\
50 |
\
51 | <%logoutButton%>\
52 |
\
53 | <%message%>\
54 |
\
55 |
',{
56 | message: (this.state.message ? (this.state.message + "
") : ""),
57 | logoutButton: (this.state.showLogoutButton ? '
': "")
58 | });
59 | } else if (this.state.page === "EDIT_CALENDAR_ITEM_PAGE") {
60 | return '
';
61 | } else if (this.state.page === "LOGIN_PAGE") {
62 | return '
';
63 | }
64 |
65 |
66 | };
67 |
68 | WTPLAN.MainPage.prototype.componentDidMount = function(component) {
69 | if (!this.state.outgoingRequest) {
70 | if (this.state.page === "MAIN_PAGE") {
71 | this._flowView.state.calendarItems = this.state.calendarItems;
72 | this._flowView.renderAt($("#calendarViewMountPoint"));
73 | $('#mainAddButton').click(function() {
74 | this.openAddDialog(WTPLAN.dateToRfc3339String(WTPLAN.getLocalStartOfDay(
75 | WTPLAN.getLocalDayString())));
76 | }.bind(this));
77 | if(this.state.showLogoutButton){
78 | $('#logoutButton').click(function() {
79 | this.showLoadingPage();
80 | WTPLAN.logoutRequest(
81 | function(){
82 | window.location.reload();
83 | },
84 | function(errorStr){
85 | this.showMainPage();
86 | alert(errorStr);
87 | }.bind(this));
88 | }.bind(this));
89 | }
90 | } else if (this.state.page === "EDIT_CALENDAR_ITEM_PAGE") {
91 | this._editItemView.renderAt($("#editCalendarItemPageDiv"));
92 | } else if (this.state.page === "LOGIN_PAGE") {
93 | this._loginPage.renderAt($("#loginPageDiv"));
94 | }
95 | }
96 | };
97 |
98 | //Utility methods
99 |
100 | WTPLAN.MainPage.prototype.showLoginPage = function(retryFunction) {
101 | var oldPage = this.state.page;
102 | this.state.page = "LOGIN_PAGE";
103 | this._loginPage = new WTPLAN.LoginView(
104 | function(password){
105 | this.showLoadingPage();
106 | WTPLAN.loginTokenRequest(
107 | password,
108 | function(){
109 | this.state.outgoingRequest = false;
110 | this.state.page = oldPage;
111 | this.setState(this.state);
112 | this.showLoadingPage();
113 | retryFunction();
114 | }.bind(this),
115 | function(errorStr){
116 | this.state.outgoingRequest = false;
117 | alert(errorStr);
118 | this.state.page = oldPage;
119 | this.showLoginPage(retryFunction);
120 | }.bind(this))
121 | }.bind(this)
122 | );
123 | this.setState(this.state);
124 | }
125 |
126 | WTPLAN.MainPage.prototype.handleNotAuth = function(secondErrorHandler) {
127 | var outerThis = this;
128 | return function(errorString, retryFunction){
129 | if(errorString.startsWith("NOT_AUTHENTICATED")) {
130 | outerThis.state.outgoingRequest = false;
131 | outerThis.showLoginPage(retryFunction);
132 | } else {
133 | secondErrorHandler(errorString);
134 | }
135 | }
136 | }
137 |
138 | WTPLAN.MainPage.prototype.showCalendarItemPage = function(calendarItem,
139 | successCallback) {
140 | var outerThis = this;
141 | this._editItemView = new WTPLAN.EditItemView(calendarItem,
142 | function(item) {
143 | outerThis.showMainPage();
144 | successCallback(item);
145 | },
146 | function() {
147 | outerThis.showMainPage();
148 | });
149 | this.state.page = "EDIT_CALENDAR_ITEM_PAGE";
150 | this.setState(this.state);
151 | };
152 |
153 | WTPLAN.MainPage.prototype.showMainPage = function() {
154 | this.state.outgoingRequest = false;
155 | this.state.page = "MAIN_PAGE";
156 | this.setState(this.state);
157 | };
158 |
159 | WTPLAN.MainPage.prototype.showLoadingPage = function() {
160 | this.state.outgoingRequest = true;
161 | this.setState(this.state);
162 | }
163 |
164 | //Helper functions
165 | WTPLAN.MainPage.prototype.openAddDialog = function(dateString) {
166 | var calendarItemTemplate = {
167 | date: dateString,
168 | duration: "NA",
169 | description: ""
170 | };
171 | var outerThis = this;
172 | outerThis.showCalendarItemPage(
173 | new WTPLAN.CalendarItem(calendarItemTemplate),
174 | function(item) {
175 | WTPLAN.addCalendarItem(outerThis.state.calendarItems, item);
176 | outerThis.showLoadingPage();
177 | WTPLAN.remoteAddCalendarItem(
178 | item,
179 | function() {
180 | outerThis.showMainPage();
181 | },
182 | this.handleNotAuth(function(error) {
183 | alert(error)
184 | outerThis.showMainPage();
185 | }));
186 | }.bind(this));
187 | };
188 |
189 | WTPLAN.MainPage.prototype.openEditDialog = function(calendarItem) {
190 | var outerThis = this;
191 | outerThis.showCalendarItemPage(
192 | calendarItem,
193 | function(item) {
194 | WTPLAN.updateCalendarItem(outerThis.state.calendarItems,
195 | calendarItem, item);
196 | outerThis.showLoadingPage();
197 | WTPLAN.remoteEditCalendarItem(
198 | item, calendarItem.id,
199 | function() {
200 | outerThis.showMainPage();
201 | },
202 | this.handleNotAuth(function(error) {
203 | alert(error)
204 | outerThis.showMainPage();
205 | }));
206 | }.bind(this));
207 | };
208 |
209 | WTPLAN.MainPage.prototype.removeItemAction = function(id) {
210 | var outerThis = this;
211 | WTPLAN.removeCalendarItem(outerThis.state.calendarItems, id);
212 | outerThis.showLoadingPage();
213 | WTPLAN.remoteRemoveCalendarItem(
214 | id,
215 | function() {
216 | outerThis.showMainPage();
217 | },
218 | this.handleNotAuth(function(error) {
219 | alert(error)
220 | outerThis.showMainPage();
221 | }));
222 | };
223 |
224 | })();
225 |
--------------------------------------------------------------------------------
/src/wtplan-web/remote_commands.js:
--------------------------------------------------------------------------------
1 | // Copyright 2017 Kjell Winblad (kjellwinblad@gmail.com, http://winsh.me)
2 | // License: MIT License, see the LICENSE file
3 |
4 | var WTPLAN = WTPLAN || {};
5 |
6 | (function() {
7 |
8 | //Remote commands
9 |
10 | WTPLAN.remoteFetchCalendarItems = function(successCallback, errorCallback) {
11 | WTPLAN.serverRequest("/calendar_items", {}, function(itemsStr) {
12 | var items = JSON.parse(itemsStr);
13 | items = items.map(function(item, index) {
14 | return new WTPLAN.CalendarItem(item, index + 1);
15 | });
16 | successCallback(items)
17 | }, errorCallback);
18 | };
19 |
20 |
21 | WTPLAN.remoteAddCalendarItem = function(calendarItem, successCallback,
22 | errorCallback) {
23 | WTPLAN.serverRequest("/add_calendar_item", calendarItem.toPlainObject(), successCallback, errorCallback);
24 | };
25 |
26 | WTPLAN.remoteEditCalendarItem = function(calendarItem, id, successCallback,
27 | errorCallback) {
28 | var message = calendarItem.toPlainObject();
29 | message.id = "" + id;
30 | WTPLAN.serverRequest("/edit_calendar_item", message, successCallback, errorCallback);
31 | };
32 |
33 | WTPLAN.remoteRemoveCalendarItem = function(id, successCallback,
34 | errorCallback) {
35 | var message = {
36 | ids: ["" + id]
37 | };
38 | WTPLAN.serverRequest("/remove_calendar_item", message, successCallback, errorCallback);
39 | };
40 |
41 | WTPLAN.loginTokenRequest = function(password, successCallback, errorCallback) {
42 | var message = {
43 | password: password
44 | };
45 | function success(dataStr){
46 | var data = JSON.parse(dataStr);
47 | WTPLAN.loginToken = data.loginToken;
48 | successCallback();
49 | }
50 | WTPLAN.serverRequest("/login_token_request", message, success, errorCallback, true);
51 | };
52 |
53 | WTPLAN.logoutRequest = function(successCallback, errorCallback) {
54 | var message = {
55 | loginToken: WTPLAN.loginToken
56 | };
57 | WTPLAN.serverRequest("/logout", message, successCallback, errorCallback, true);
58 | };
59 |
60 |
61 | })();
62 |
--------------------------------------------------------------------------------
/src/wtplan-web/utility_functions.js:
--------------------------------------------------------------------------------
1 | // Copyright 2017 Kjell Winblad (kjellwinblad@gmail.com, http://winsh.me)
2 | // License: MIT License, see the LICENSE file
3 |
4 | var WTPLAN = WTPLAN || {};
5 |
6 | (function() {
7 |
8 | WTPLAN.rfc3339regexp =
9 | /([0-9]+)-(0[1-9]|1[012])-(0[1-9]|[12][0-9]|3[01])[Tt]([01][0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9]|60)(\.[0-9]+)?(([Zz])|([\+|\-]([01][0-9]|2[0-3]):[0-5][0-9]))/;
10 |
11 | WTPLAN.durationRegExp = /^(\s*NA\s*)|\s*(?:(\d+)h)?\s*(?:(\d+)m)?\s*$/;
12 |
13 |
14 | WTPLAN.serverRequest = function(url, dataObject, successCallback, errorCallback, noAuth){
15 | var requestFun;
16 | requestFun = function(){
17 | if(WTPLAN.loginToken === "NOT_AUTHENTICATED" && (noAuth !== true)) {
18 | errorCallback("NOT_AUTHENTICATED", requestFun);
19 | return;
20 | }
21 | if(dataObject !== null && noAuth !== true){
22 | dataObject.loginToken = WTPLAN.loginToken;
23 | }
24 | $.ajax({
25 | url: url,
26 | data: JSON.stringify(dataObject),
27 | type: 'POST',
28 | success: successCallback,
29 | error:function(msg){
30 | errorCallback(msg.responseText, requestFun);
31 | }
32 | });
33 | };
34 | requestFun();
35 | };
36 |
37 | WTPLAN.addCalendarItem = function(calendarItems, calendarItem) {
38 | calendarItems.push(calendarItem);
39 | calendarItems.sort(function(item1, item2) {
40 | return item1.startDate().getTime() - item2.startDate().getTime();
41 | });
42 | calendarItems.forEach(function(item, index) {
43 | item.id = index + 1;
44 | });
45 | };
46 |
47 | WTPLAN.updateCalendarItem = function(calendarItems, oldItem, newItem) {
48 | calendarItems.splice(oldItem.id - 1, 1);
49 | WTPLAN.addCalendarItem(calendarItems, newItem);
50 | };
51 |
52 | WTPLAN.removeCalendarItem = function(calendarItems, id) {
53 | calendarItems.splice(id - 1, 1);
54 | calendarItems.forEach(function(item, index) {
55 | item.id = index + 1;
56 | });
57 | };
58 |
59 | WTPLAN.dayStringFromDate = function(date) {
60 | var day = date.getDay();
61 | if (day === 0) {
62 | return "Sunday";
63 | } else if (day === 1) {
64 | return "Monday";
65 | } else if (day === 2) {
66 | return "Tuesday";
67 | } else if (day === 3) {
68 | return "Wednesday";
69 | } else if (day === 4) {
70 | return "Thursday";
71 | } else if (day === 5) {
72 | return "Friday";
73 | } else if (day === 6) {
74 | return "Saturday";
75 | }
76 | };
77 |
78 | WTPLAN.getLocalStartOfDay = function(dateString) {
79 | var local = new Date(dateString);
80 | local.setMinutes(local.getMinutes() + local.getTimezoneOffset());
81 | return local;
82 | };
83 |
84 |
85 | WTPLAN.getLocalDayString = function(date) {
86 | var local;
87 | if (date === undefined) {
88 | local = new Date();
89 | } else {
90 | local = new Date(date);
91 | }
92 | local.setMinutes(local.getMinutes() - local.getTimezoneOffset());
93 | return local.toJSON().split("T")[0];
94 | };
95 |
96 | WTPLAN.dateToRfc3339String = function(dateParam) {
97 | var date;
98 | if (dateParam === undefined) {
99 | date = new Date();
100 | } else {
101 | date = dateParam;
102 | }
103 |
104 | function pad(num) {
105 | var str = "" + num;
106 | var tmp = ('0' + num);
107 | return tmp.substring(str.length - 1, str.length + 1);
108 | }
109 | var offset = date.getTimezoneOffset();
110 | var absOffset = Math.abs(offset);
111 | var offsetMinutes = absOffset % 60;
112 | var offsetHours = (absOffset - offsetMinutes) / 60;
113 | return (
114 | date.getFullYear() + "-" +
115 | pad(date.getMonth() + 1) + "-" +
116 | pad(date.getDate()) + "T" +
117 | pad(date.getHours()) + ":" +
118 | pad(date.getMinutes()) + ":" +
119 | pad(date.getSeconds()) +
120 | (offset === 0 ? "Z" :
121 | ((offset < 0 ? "+" : "-") +
122 | pad(offsetHours) + ":" +
123 | pad(offsetMinutes))));
124 | };
125 |
126 |
127 | WTPLAN.template = function(string, varDict) {
128 | Object.keys(varDict).forEach(function(vari){
129 | string = string.replace(new RegExp('\<%'+vari+'%\>', 'g'), varDict[vari]);
130 | });
131 | return string;
132 | };
133 |
134 | })();
135 |
--------------------------------------------------------------------------------
/src/wtplan/generate_version_str/generate_version_str.go:
--------------------------------------------------------------------------------
1 | // Copyright 2017 Kjell Winblad (kjellwinblad@gmail.com, http://winsh.me)
2 | // License: MIT License, see the LICENSE file
3 |
4 | package main
5 |
6 | import (
7 | "bytes"
8 | "fmt"
9 | "os"
10 | "os/exec"
11 | "strings"
12 | )
13 |
14 |
15 | func main() {
16 | cmd := exec.Command("git", "rev-parse", "HEAD")
17 | buf := new(bytes.Buffer)
18 | cmd.Stdout = buf
19 | cmd.Stdin = os.Stdin
20 | cmd.Stderr = new(bytes.Buffer)
21 | cmd.Dir = "."
22 | cmd.Run()
23 | out, err := os.Create("version.go")
24 | if err != nil {
25 | fmt.Println(err)
26 | }
27 | out.Write([]byte("package main\n\n"))
28 | commitId := strings.TrimSpace(buf.String())
29 | versionStr := "var version = `" + `wtplan ` + os.Getenv("VERSIONSTR")
30 | if len(commitId) == 0 {
31 | versionStr = versionStr + "`\n"
32 | } else {
33 | versionStr = versionStr + `
34 |
35 | git commit id = ` + commitId + "`"
36 | }
37 | out.Write([]byte(versionStr))
38 | }
39 |
--------------------------------------------------------------------------------
/src/wtplan/main.go:
--------------------------------------------------------------------------------
1 | // Copyright 2017 Kjell Winblad (kjellwinblad@gmail.com, http://winsh.me)
2 | // License: MIT License, see the LICENSE file
3 |
4 | package main
5 |
6 | //go:generate go run "generate_version_str/generate_version_str.go"
7 |
8 | import (
9 | "encoding/json"
10 | "flag"
11 | "fmt"
12 | "io/ioutil"
13 | "os"
14 | "os/exec"
15 | "os/user"
16 | "path/filepath"
17 | "regexp"
18 | "sort"
19 | "strconv"
20 | "strings"
21 | "time"
22 | )
23 |
24 | var (
25 | durationRegExp = regexp.MustCompile(`(?P
\s*NA\s*)|\s*(?:(?P\d+)h)?\s*(?:(?P\d+)m)?\s*`)
26 | simpleDateRegExp = regexp.MustCompile(`\s*(?P\d\d\d\d)(?:-(?P\d\d)(?:-(?P\d\d)(?:T(?P\d\d)(?:\:(?P\d\d))?)?)?)?\s*`)
27 | defaultPostChangeCommandsWithGit = [][]string{[]string{"git", "add", "data.json"}, []string{"git", "commit", "-m", "Change!"}}
28 | defaultEditorCommands = []string{"nano"}
29 | customConfigDir = ""
30 | )
31 |
32 | const (
33 | calendarDataFileName = "data.json"
34 | configDataFileName = "config.json"
35 | configDirName = ".wtplan"
36 | )
37 |
38 | type calendarItem struct {
39 | Date string `json:"date"`
40 | Duration string `json:"duration"`
41 | Description string `json:"description"`
42 | ID int `json:"id,omitempty"`
43 | }
44 |
45 | type config struct {
46 | EditorCommand []string `json:"editor_command"`
47 | PostChangeCommands [][]string `json:"post_change_commands"`
48 | AutoAddPostChangeCommandsIfGitRepo bool `json:"auto_add_post_change_commands_if_git_repo"`
49 | SyncCommands [][]string `json:"sync_commands"`
50 | }
51 |
52 | //Implements interface for sorting
53 | type byDate []calendarItem
54 |
55 | func (a byDate) Len() int { return len(a) }
56 | func (a byDate) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
57 | func (a byDate) Less(i, j int) bool {
58 | iTime := a[i].startDate()
59 | jTime := a[j].startDate()
60 | return iTime.Before(jTime)
61 | }
62 |
63 | //Helper methods for calendarItem
64 | func (c calendarItem) startDate() time.Time {
65 | t, _ := time.Parse(time.RFC3339, c.Date)
66 | t = t.Add(1*time.Microsecond) // Makes sure that a time will not happen between days
67 | t = t.In(time.Local)
68 | return t
69 | }
70 |
71 | func (c calendarItem) endDate() time.Time {
72 | match := durationRegExp.FindStringSubmatch(c.Duration)
73 | if match[1] == "NA" {
74 | return c.startDate()
75 | }
76 | hours, _ := strconv.Atoi(match[2])
77 | minutes, _ := strconv.Atoi(match[3])
78 | duration := time.Duration(time.Hour*time.Duration(hours) + time.Minute*time.Duration(minutes))
79 | return c.startDate().Add(duration).In(time.Local)
80 | }
81 |
82 | //Error handling function
83 | func die(msg string) {
84 | fmt.Fprintf(os.Stderr, "%s\n", msg)
85 | os.Exit(1)
86 | }
87 |
88 | //Functions for handling storage and settings file
89 | func configDir() string {
90 | if customConfigDir != "" {
91 | return customConfigDir
92 | } else {
93 | usr, err := user.Current()
94 | if err != nil {
95 | die(fmt.Sprintf("Could not get home directory: %s", err.Error()))
96 | }
97 | return filepath.Join(usr.HomeDir, configDirName)
98 | }
99 | }
100 |
101 | func checkOrCreateConfigDir() {
102 | _, err := os.Stat(configDir())
103 | if os.IsNotExist(err) {
104 | if nil != os.Mkdir(configDir(), os.ModeDir|0700) {
105 | die(fmt.Sprintf("Error when createing data dir: %s", err.Error()))
106 | }
107 | } else if err != nil {
108 | die(fmt.Sprintf("Error when checking existence of data dir: %s", err.Error()))
109 | }
110 | }
111 |
112 | func createOrReadFileInConfigDir(fileName string, defaultText []byte) []byte {
113 | _, err := os.Stat(filepath.Join(configDir(), fileName))
114 | if os.IsNotExist(err) {
115 | err = ioutil.WriteFile(filepath.Join(configDir(), fileName), defaultText, 0600)
116 | if err != nil {
117 | die(fmt.Sprintf("Error when createing data file: %s", err.Error()))
118 | }
119 | } else if err != nil {
120 | die(fmt.Sprintf("Error when checking existence of data file: %s", err.Error()))
121 | }
122 | dataFileText, err := ioutil.ReadFile(filepath.Join(configDir(), fileName))
123 | if err != nil {
124 | die(fmt.Sprintf("Error when reading file: %s", err.Error()))
125 | }
126 | return dataFileText
127 | }
128 |
129 | func createOrReadData() []calendarItem {
130 | checkOrCreateConfigDir()
131 | dataFileText := createOrReadFileInConfigDir(calendarDataFileName, []byte("[]"))
132 | calendarItems := make([]calendarItem, 0)
133 | err := json.Unmarshal(dataFileText, &calendarItems)
134 | if err != nil {
135 | die(fmt.Sprintf("Error when parsing data file: %s", err.Error()))
136 | }
137 | sort.Sort(byDate(calendarItems))
138 | for i := range calendarItems {
139 | calendarItems[i].ID = i + 1
140 | }
141 | return calendarItems
142 | }
143 |
144 | func createOrReadConfig() config {
145 | checkOrCreateConfigDir()
146 | defaultConfig := config{
147 | EditorCommand: defaultEditorCommands,
148 | PostChangeCommands: [][]string{},
149 | AutoAddPostChangeCommandsIfGitRepo: true,
150 | SyncCommands: [][]string{}}
151 | b, _ := json.MarshalIndent(defaultConfig, "", " ")
152 | configData := createOrReadFileInConfigDir(configDataFileName, b)
153 | conf := config{}
154 | json.Unmarshal(configData, &conf)
155 | _, isGitDirErr := os.Stat(filepath.Join(configDir(), ".git"))
156 | if isGitDirErr == nil &&
157 | conf.AutoAddPostChangeCommandsIfGitRepo &&
158 | len(conf.PostChangeCommands) == 0 {
159 | conf.PostChangeCommands = defaultPostChangeCommandsWithGit
160 | b, _ := json.MarshalIndent(conf, "", " ")
161 | err := ioutil.WriteFile(filepath.Join(configDir(), configDataFileName), b, 0600)
162 | if err != nil {
163 | die(fmt.Sprintf("Error when editing config file: %s", err.Error()))
164 | }
165 | }
166 | return conf
167 | }
168 |
169 | func saveCalendarItems(calendarItems []calendarItem) {
170 | for i := range calendarItems {
171 | calendarItems[i].ID = 0 // sets to empty value
172 | }
173 | b, _ := json.MarshalIndent(calendarItems, "", " ")
174 | err := ioutil.WriteFile(filepath.Join(configDir(), calendarDataFileName), b, 0600)
175 | if err != nil {
176 | die(fmt.Sprintf("Error when writting data file: %s", err.Error()))
177 | }
178 | }
179 |
180 | func addCalendarItem(items []calendarItem, item calendarItem) []calendarItem {
181 | items = append(items, item)
182 | sort.Sort(byDate(items))
183 | return items
184 | }
185 |
186 | //Functions for handling commands
187 |
188 | func printReport(startDate time.Time, days int) {
189 | startDate = time.Date(startDate.Year(), startDate.Month(), startDate.Day()-1, 0, 0, 0, 0, time.Local)
190 | endDate := startDate.AddDate(0, 0, days)
191 | items := createOrReadData()
192 | itemsToReport := []calendarItem{}
193 | for _, item := range items {
194 | if item.startDate().After(startDate) && item.startDate().Before(endDate) {
195 | itemsToReport = append(itemsToReport, item)
196 | }
197 | }
198 | day := startDate.AddDate(0, 0, 1)
199 | for day.Before(endDate) && !day.Equal(endDate) {
200 | nextDay := day.AddDate(0, 0, 1)
201 | weekdays := []string{"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"}
202 | fmt.Printf("=== %s%s %d-%02d-%02d ===\n", weekdays[day.Weekday()], " "[:9-len(weekdays[day.Weekday()])], day.Year(), day.Month(), day.Day())
203 | for _, item := range itemsToReport {
204 | if (item.startDate().After(day) || item.startDate().Equal(day)) && item.startDate().Before(nextDay) &&
205 | (item.endDate().After(day) || item.endDate().Equal(day)) && item.endDate().Before(nextDay) {
206 | //Both end and start date are inside day
207 | if item.startDate().Equal(item.endDate()) {
208 | fmt.Printf("%02d:%02d ID: %d\n", item.startDate().Hour(), item.startDate().Minute(), item.ID)
209 | } else {
210 | fmt.Printf("%02d:%02d-%02d:%02d (Duration %s) ID: %d\n", item.startDate().Hour(), item.startDate().Minute(), item.endDate().Hour(), item.endDate().Minute(), item.Duration, item.ID)
211 | }
212 | fmt.Printf("%s\n", item.Description)
213 | } else if (item.startDate().After(day) || item.startDate().Equal(day)) && item.startDate().Before(nextDay) {
214 | // Start date in day
215 | fmt.Printf("%02d:%02d-(->) (Duration %s) ID: %d\n", item.startDate().Hour(), item.startDate().Minute(), item.Duration, item.ID)
216 | fmt.Printf("%s\n", item.Description)
217 | } else if (item.endDate().After(day) || item.endDate().Equal(day)) && item.endDate().Before(nextDay) {
218 | // End date in day
219 | fmt.Printf("(<-)-%02d:%02d (Duration %s) ID: %d\n", item.endDate().Hour(), item.endDate().Minute(), item.Duration, item.ID)
220 | fmt.Printf("%s\n", item.Description)
221 | } else if item.startDate().Before(day) && (item.endDate().After(nextDay) || item.endDate().Equal(nextDay)) {
222 | //Start date before day and end date after day
223 | fmt.Printf("(<-)-(->) (Duration %s) ID: %d\n", item.Duration, item.ID)
224 | fmt.Printf("%s\n", item.Description)
225 | }
226 | }
227 | day = nextDay
228 | }
229 | }
230 |
231 | func runCommands(commands [][]string) error {
232 | for _, command := range commands {
233 | cmd := exec.Command(command[0], command[1:]...)
234 | cmd.Stdout = os.Stdout
235 | cmd.Stdin = os.Stdin
236 | cmd.Stderr = os.Stderr
237 | cmd.Dir = configDir()
238 | err := cmd.Run()
239 | if err != nil {
240 | return err
241 | }
242 | }
243 | return nil
244 | }
245 |
246 | func checkDurationString(str string) {
247 | match := durationRegExp.FindStringSubmatch(str)
248 | if len(match) == 0 {
249 | die(fmt.Sprintf(`The duration string "%s" is not formatted correctly.
250 | Examples of correctly formatted duration strings are "NA", "2h", "10m" and "2h10m"`, str))
251 | }
252 | }
253 |
254 | func getCalendarItemFromEditor(initialDateString string, initialDuration string, initialDescription string) calendarItem {
255 | tmpfile, err := ioutil.TempFile(configDir(), "ADD_CALENDAR_ITEM_TEMP")
256 | if err != nil {
257 | die(fmt.Sprintf("Error when creating temp file %s", err.Error()))
258 | }
259 | content := []byte(
260 | fmt.Sprintf(`Timepoint (RFC3339):
261 | %s
262 | ##################################
263 | Duration (NA no duration, 1h30m = 1 hour and 30 minutes):
264 | %s
265 | ##################################
266 | Description (Write on next line):
267 | %s`, initialDateString, initialDuration, initialDescription))
268 | _, err = tmpfile.Write(content)
269 | if err != nil {
270 | die(fmt.Sprintf("Error when writting temp file: %s", err.Error()))
271 | }
272 | err = tmpfile.Close()
273 | if err != nil {
274 | die(fmt.Sprintf("Error when closing temp file: %s", err.Error()))
275 | }
276 | editorCommand := append(createOrReadConfig().EditorCommand, tmpfile.Name())
277 | err = runCommands([][]string{editorCommand})
278 | if err != nil {
279 | die(fmt.Sprintf(`Error when starting editor command.
280 | Note that you can change the editor command in %s: %s`, configDir(), err.Error()))
281 | }
282 | content, err = ioutil.ReadFile(tmpfile.Name())
283 | if err != nil {
284 | die(fmt.Sprintf("Error when reading temp file: %s", err.Error()))
285 | }
286 | err = os.Remove(tmpfile.Name())
287 | if err != nil {
288 | die(fmt.Sprintf("Error when removing temp file: %s", err.Error()))
289 | }
290 | stringContent := string(content)
291 | stringContentLines := strings.Split(stringContent, "\n")
292 | dateString := stringContentLines[1]
293 | _, err = time.Parse(time.RFC3339, dateString)
294 | if err != nil {
295 | die(fmt.Sprintf(`Could not parse datetime string "%s".
296 | RFC 3339 strings are accepted.
297 | %s`, dateString, err.Error()))
298 | }
299 | durationString := stringContentLines[4]
300 | checkDurationString(durationString)
301 | descriptionString := strings.Join(stringContentLines[7:], "\n")
302 | if descriptionString == "" {
303 | die("Canceling add because description string is empty.")
304 | }
305 | item := calendarItem{
306 | Date: dateString,
307 | Duration: durationString,
308 | Description: descriptionString}
309 | return item
310 | }
311 |
312 | func runPostChangeCommands() {
313 | commands := createOrReadConfig().PostChangeCommands
314 | err := runCommands(commands)
315 | if err != nil {
316 | die("Error when running post change commands")
317 | }
318 | }
319 |
320 | func addCommand(args []string) {
321 | var dateString string
322 | if len(args) == 0 {
323 | dateString = time.Now().In(time.Local).Format(time.RFC3339)
324 | } else {
325 | dateString = timeFromDateString(args[0]).Format(time.RFC3339)
326 | }
327 | durationString := "NA"
328 | if len(args) >= 2 {
329 | durationString = args[1]
330 | checkDurationString(durationString)
331 | }
332 | var item calendarItem
333 | if len(args) >= 3 {
334 | item = calendarItem{Date: dateString, Duration: durationString, Description: args[2]}
335 | } else {
336 | item = getCalendarItemFromEditor(dateString, durationString, "")
337 | }
338 | saveCalendarItems(addCalendarItem(createOrReadData(), item))
339 | runPostChangeCommands()
340 | }
341 |
342 | func timeFromDateString(str string) time.Time {
343 | rfc3339Time, err := time.Parse(time.RFC3339, str)
344 | if err == nil {
345 | return rfc3339Time
346 | }
347 | match := simpleDateRegExp.FindStringSubmatch(str)
348 | if len(match) == 0 {
349 | die(fmt.Sprintf(`Can not parse date %s.
350 | Examples of correctly formatted dates are "2016", "2016-10", "2016-10-20",
351 | "2016-10-20T13, "2016-10-20T13:10" and "2016-11-13T19:05:22+01:00" (RFC3339).", `, str))
352 | }
353 | year, _ := strconv.Atoi(match[1])
354 | month, _ := strconv.Atoi(match[2])
355 | if month == 0 {
356 | month = month + 1
357 | }
358 | day, _ := strconv.Atoi(match[3])
359 | if day == 0 {
360 | day = day + 1
361 | }
362 | hour, _ := strconv.Atoi(match[4])
363 | minute, _ := strconv.Atoi(match[5])
364 | return time.Date(year,
365 | time.Month(month),
366 | day, hour, minute, 0, 0, time.Local)
367 | }
368 |
369 | func showCommand(args []string) {
370 | if len(args) == 0 {
371 | printReport(time.Now(), 10)
372 | } else if len(args) == 1 {
373 | if args[0] == "ALLJSON" {
374 | items := createOrReadData()
375 | for i := range items {
376 | items[i].ID = 0 // sets to empty value
377 | }
378 | b, _ := json.MarshalIndent(items, "", " ")
379 | fmt.Print(string(b))
380 | return
381 | }
382 | days, err := strconv.Atoi(args[0])
383 | if err == nil {
384 | printReport(time.Now(), days)
385 | } else {
386 | printReport(timeFromDateString(args[0]), 10)
387 | }
388 | } else {
389 | days, err := strconv.Atoi(args[1])
390 | if err != nil {
391 | die(fmt.Sprintf("The number of days argument %s is not an integer", args[1]))
392 | }
393 | printReport(timeFromDateString(args[0]), days)
394 | }
395 | }
396 |
397 | func removeItems(calendarItems []calendarItem, ids []int) []calendarItem {
398 | idsToRemove := make(map[int]bool)
399 | for _, id := range ids {
400 | idsToRemove[id] = true
401 | }
402 | itemsToSave := []calendarItem{}
403 | for i := range calendarItems {
404 | if !idsToRemove[i+1] {
405 | itemsToSave = append(itemsToSave, calendarItems[i])
406 | }
407 | }
408 | return itemsToSave
409 | }
410 |
411 | func removeCommand(args []string) {
412 | items := createOrReadData()
413 | idsToRemove := []int{}
414 | for _, item := range args {
415 | id, err := strconv.Atoi(item)
416 | if err != nil {
417 | die(fmt.Sprintf("Can not parse argument %s as integer", item))
418 | }
419 | if id < 1 || id > len(items) {
420 | die(fmt.Sprintf("The ID %d is outside the range", id))
421 | }
422 | idsToRemove = append(idsToRemove, id)
423 | }
424 | saveCalendarItems(removeItems(items, idsToRemove))
425 | runPostChangeCommands()
426 | }
427 |
428 | func editCommand(args []string) {
429 | if len(args) == 0 {
430 | die("No ID passed to the edit command")
431 | }
432 | id, err := strconv.Atoi(args[0])
433 | if err != nil {
434 | die(fmt.Sprintf("The ID %s passed to edit is not an integer", args[0]))
435 | }
436 | items := createOrReadData()
437 | if id < 1 || id > len(items) {
438 | die(fmt.Sprintf("The ID %d is out of range", id))
439 | }
440 | itemToEdit := items[id-1]
441 | newItem := getCalendarItemFromEditor(itemToEdit.Date, itemToEdit.Duration, itemToEdit.Description)
442 | items = removeItems(items, []int{id})
443 | saveCalendarItems(addCalendarItem(items, newItem))
444 | runPostChangeCommands()
445 | }
446 |
447 | func gitCommand(args []string) {
448 | command := append([]string{"git"}, args...)
449 | runCommands([][]string{command})
450 | }
451 |
452 | func webCommand(args []string) {
453 | command := append([]string{"wtplan-web"}, args...)
454 | runCommands([][]string{command})
455 | }
456 |
457 | func printHelpText() {
458 | fmt.Println(
459 | `usage: wtplan []
460 |
461 | The wtplan commands are:
462 | show Show calendar items. Examples:
463 | wtplan show 10 (shows today and the following 9 days)
464 | wtplan show 2016-10-30 10 (shows 2016-10-30 and the following 9 days)
465 | wtplan show 2016-10 10 (shows 2016-10-01 and the following 9 days)
466 | wtplan show 2016 365 (shows 2016-01-01 and the following 364 days)
467 | add Add calendar item. Examples:
468 | wtplan add (adds an item using the editor -- see ~/wtplan/config.json)
469 | wtplan add 2016-10-30 (adds an item using the editor)
470 | wtplan add 2016-10-30 NA (adds an item using the editor)
471 | wtplan add 2016-10-30T14:10 1h10m "table tennis" (adds an item)
472 | remove Remove calendar item. Examples:
473 | wtplan remove 7 (removes item with ID 7,
474 | use the show command to show IDs of items)
475 | wtplan remove 7 5 3 (removes several items)
476 | edit Edits calendar item. Examples:
477 | wtplan edit 7 (edit item with ID 7 using editor)
478 | git Run git command in the calendar directory. Example:
479 | wtplan git remote add origin https://gitlab.com/user/calendar.git
480 | web Starts the wtplan web interface. Examples:
481 | wtplan web (Starts the web interface at the default port 8005)
482 | wtplan web --address :8700 --password mypass
483 | (Starts the web interface at port 8700 with password mypass)
484 |
485 | See man page for more detailed help.`)
486 | os.Exit(0)
487 | }
488 |
489 | func main() {
490 | helpPtr := flag.Bool("h", false, "get help")
491 | helpLongPtr := flag.Bool("help", false, "get help")
492 | versionPtr := flag.Bool("v", false, "show version information")
493 | versionLongPtr := flag.Bool("version", false, "show version information")
494 | configDirPtr := flag.String("c", "", "Set the configuration dir")
495 | configDirLongPtr := flag.String("config_dir", "", "Set the configuration dir")
496 | flag.Parse()
497 | if *helpPtr || *helpLongPtr {
498 | printHelpText()
499 | }
500 | if *versionPtr || *versionLongPtr {
501 | fmt.Println(version)
502 | os.Exit(0)
503 | }
504 | args := os.Args[1:]
505 | if *configDirLongPtr != ""{
506 | customConfigDir = *configDirLongPtr
507 | args = args[2:]
508 | }
509 | if *configDirPtr != "" {
510 | customConfigDir = *configDirPtr
511 | args = args[2:]
512 | }
513 | if len(args) == 0 {
514 | printHelpText()
515 | }
516 | //Init config dir if it does not exist
517 | createOrReadConfig()
518 | //Handle commands
519 | switch args[0] {
520 | case "add":
521 | addCommand(args[1:])
522 | case "show":
523 | showCommand(args[1:])
524 | case "remove":
525 | removeCommand(args[1:])
526 | case "edit":
527 | editCommand(args[1:])
528 | case "git":
529 | gitCommand(args[1:])
530 | case "web":
531 | webCommand(args[1:])
532 | default:
533 | fmt.Printf("%q is not valid command.\n", os.Args[1])
534 | os.Exit(2)
535 | }
536 |
537 | }
538 |
--------------------------------------------------------------------------------
/wtplan.1:
--------------------------------------------------------------------------------
1 | .TH WTPLAN 1
2 | .SH NAME
3 | wtplan VERSION \- keeps track of events with a command line interface or a web interface
4 | .SH SYNOPSIS
5 | .B wtplan
6 | [[\fB\-\-version\fR] | [\fB\-h\fR] | [\fB\-\-help\fR]
7 |
8 | .B wtplan\fR [\fB\-c\fR \fI\fR] | [\fB\-\-config_dir\fR \fI\fR]]
9 |
10 | \fB show\fR [\fINUMBER_OF_DAYS\fR] | [\fIISO_DATE\fR [\fINUMBER_OF_DAYS\fR]]
11 |
12 | \fB add\fR [\fIISO_DATE\fR [\fIDURATION\fR [\fIDESCRIPTION\fR]]]
13 |
14 | \fB remove\fR \fIID\fR ...
15 |
16 | \fB edit\fR \fIID\fR
17 |
18 | \fB git\fR \fIGIT_PARAMETER\fR ...
19 |
20 | \fB web\fR [\fB\-\-address\fR \fIADDRESS\fR] [\fB\-\-password\fR \fIPASSWORD\fR]
21 |
22 | .SH DESCRIPTION
23 | .B wtplan
24 | manages a calendar with events. Every event has a start time, a duration and a description.
25 | \fBwtplan\fR provides both a command line interface (see section \fBCOMMAND LINE INTERFACE\fR) as well as web based interface (see section \fBWEB INTERFACE\fR).
26 | \fBwtplan\fR integrates with git to make it easy to keep calendar data in-sync between several computers (see section \fBGIT INTEGRATION\fR).
27 | The calendar data as well as configuration files are by default located in \fI~/.wtplan\fR but this directory can be changed with the \fB\-c\fR or \fB\-\-config_dir\fR parameters.
28 | .SH OPTIONS
29 | .TP
30 | .BR \-h ", " \-\-help
31 | Shows the help text.
32 | .TP
33 | .BR \-\-version
34 | Shows version information
35 | .TP
36 | .BR \-c " " \fI\fR ", " \-\-config_dir " " \fI\fR
37 | Specifies a directory for the configuration file and the data file other than the default \fI~/.wtplan\fR.
38 |
39 | .SH COMMAND LINE INTERFACE
40 | The command line interface makes it possible to show and modify the calendar data from a command line console.
41 | The \fBadd\fR command and the \fBedit\fR command may open an editor to edit the calendar item if not enough arguments are specified.
42 | By default the editor nano is used but this can be changed using the configuration variable \fIeditor_command\fR in \fI~/wtplan/config.json\fR.
43 |
44 | The wtplan commands are:
45 | \fBshow\fR Show calendar items. Examples:
46 | \fBwtplan show 10\fR (shows today and the following 9 days)
47 | \fBwtplan show 2016-10-30 10\fR (shows 2016-10-30 and the following 9 days)
48 | \fBwtplan show 2016-10 10\fR (shows 2016-10-01 and the following 9 days)
49 | \fBwtplan show 2016 365\fR (shows 2016-01-01 and the following 364 days)
50 | \fBadd\fR Add calendar item. Examples:
51 | \fBwtplan add\fR (adds an item using the editor -- see ~/wtplan/config.json)
52 | \fBwtplan add 2016-10-30\fR (adds an item using the editor)
53 | \fBwtplan add 2016-10-30 NA\fR (adds an item using the editor)
54 | \fBwtplan add 2016-10-30T14:10 1h10m "table tennis"\fR (adds an item)
55 | \fBremove\fR Remove calendar item. Examples:
56 | \fBwtplan remove 7\fR (removes item with ID 7,
57 | use the show command to show IDs of items)
58 | \fBwtplan remove 7 5 3\fR (removes several items)
59 | \fBedit\fR Edits calendar item. Examples:
60 | \fBwtplan edit 7\fR (edit item with ID 7 using editor)
61 | \fBgit\fR Run git command in the calendar directory. Example:
62 | \fBwtplan git remote add origin https://gitlab.com/user/calendar.git\fR
63 | \fBweb\fR Starts the wtplan web interface. Examples:
64 | \fBwtplan web\fR (Starts the web interface at the default port 8005)
65 | \fBwtplan web --address 127.0.0.1:8700 --password mypass\fR
66 | (Starts the web interface at port 8700 with password mypass)
67 | .SH WEB INTERFACE
68 | The web interface is started with the \fBwtplan web\fR command.
69 | By default the web interface listen to port \fI8005\fR.
70 | The web interface can then be accessed by pointing a web browser to the address \fIhttp://127.0.0.1:8005\fR.
71 | For example, the command \fBfirefox --new-window http://127.0.0.1:8005\fR will open the web interface using the firefox web browser if it is installed in your system.
72 | The port and address that the web interface listen to can be changed by specifying the \fB--address\fR option.
73 | The command \fBwtplan web --address 0.0.0.0:8700\fR will start the web interface on port 8700 instead of the default port, and make the web interface available from external machines.
74 |
75 | The \fB--password\fR option can be used to protect the web interface with a password.
76 | Running the command \fBwtplan web --password mySecretPass\fR will start the web interface protected by the password \fImySecretPass\fR.
77 | .SH GIT INTEGRATION
78 | The purpose of the git integration is to make it more convenient to synchronize the calendar data between several computers using the git version control system.
79 | A prerequirement for using the git integration is that git is installed on your system.
80 |
81 | To initiate a git repository for your calendar data, run the command \fBwtplan git init\fR.
82 | This will create a git repository in the default wtplan configuration folder \fI~/.wtplan\fR.
83 | Typically, you want to synchronize your calendar data with a remote repository.
84 | To set this up run \fBwtplan git remote add origin yourRemoteGitRepo\fR.
85 | By default, wtplan will add and commit changes to the calendar data to the repository if it detects that \fI~/.wtplan\fR is a git repository.
86 | For example, running the command \fBwtplan add 2016-10-30T14:10 1h10m "table tennis"\fR will run \fBgit add data.json\fR and \fBgit commit -m "Change!"\fR in the \fI~/.wtplan\fR folder after adding the event.
87 | Note that the configuration variable \fIpost_change_commands\fR in \fI~/.wtplan/config.json\fR will be changed to include those two git commands automatically when the first calendar change is done after initializing a git repository in the configuration directory if the configuration variable \fIauto_add_post_change_commands_if_git_repo\fR is set to \fBtrue\fR.
88 | The \fIpost_change_commands\fR variable can then be modified if one wants to run other commands when the calendar data is changed.
89 | For example, setting the \fIpost_change_commands\fR variable to \fI[["git", "add", "data.json"], ["git", "commit", "-m", "Change!"], ["git", "push"]]\fR will also run the \fBgit push\fR command after committing the change.
90 |
91 | .SH AUTHOR
92 |
93 | Kjell Winblad (kjellwinblad@gmail.com, http://winsh.me)
94 |
95 | .SH REPORTING BUGS
96 |
97 | Bugs can be reported at the projects github page
98 |
99 | .SH COPYRIGHT
100 |
101 | Copyright © 2017 Kjell Winblad. License MIT .
102 |
--------------------------------------------------------------------------------