diff --git a/.Dockerignore b/.Dockerignore new file mode 100644 index 0000000..ce6c5eb --- /dev/null +++ b/.Dockerignore @@ -0,0 +1,2 @@ +domogeek +.git diff --git a/.gitignore b/.gitignore index bfa6a22..33cfe79 100644 --- a/.gitignore +++ b/.gitignore @@ -1 +1,111 @@ # Created by .ignore support plugin (hsz.mobi) +### Go template +# Binaries for programs and plugins +*.exe +*.exe~ +*.dll +*.so +*.dylib + +# Test binary, built with `go test -c` +*.test + +# Output of the go coverage tool, specifically when used with LiteIDE +*.out + +# Dependency directories (remove the comment below to include it) +# vendor/ + +### JetBrains template +# Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio and WebStorm +# Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839 + +# User-specific stuff +.idea/**/workspace.xml +.idea/**/tasks.xml +.idea/**/usage.statistics.xml +.idea/**/dictionaries +.idea/**/shelf + +# Generated files +.idea/**/contentModel.xml + +# Sensitive or high-churn files +.idea/**/dataSources/ +.idea/**/dataSources.ids +.idea/**/dataSources.local.xml +.idea/**/sqlDataSources.xml +.idea/**/dynamic.xml +.idea/**/uiDesigner.xml +.idea/**/dbnavigator.xml + +# Gradle +.idea/**/gradle.xml +.idea/**/libraries + +# Gradle and Maven with auto-import +# When using Gradle or Maven with auto-import, you should exclude module files, +# since they will be recreated, and may cause churn. Uncomment if using +# auto-import. +# .idea/modules.xml +# .idea/*.iml +# .idea/modules +# *.iml +# *.ipr + +# CMake +cmake-build-*/ + +# Mongo Explorer plugin +.idea/**/mongoSettings.xml + +# File-based project format +*.iws + +# IntelliJ +out/ + +# mpeltonen/sbt-idea plugin +.idea_modules/ + +# JIRA plugin +atlassian-ide-plugin.xml + +# Cursive Clojure plugin +.idea/replstate.xml + +# Crashlytics plugin (for Android Studio and IntelliJ) +com_crashlytics_export_strings.xml +crashlytics.properties +crashlytics-build.properties +fabric.properties + +# Editor-based Rest Client +.idea/httpRequests + +# Android studio 3.1+ serialized cache file +.idea/caches/build_file_checksums.ser + +### Vim template +# Swap +[._]*.s[a-v][a-z] +[._]*.sw[a-p] +[._]s[a-rt-v][a-z] +[._]ss[a-gi-z] +[._]sw[a-p] + +# Session +Session.vim +Sessionx.vim + +# Temporary +.netrwhist +*~ +# Auto-generated tag files +tags +# Persistent undo +[._]*.un~ + + +# Binary +domogeek diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 0000000..27afccf --- /dev/null +++ b/Dockerfile @@ -0,0 +1,15 @@ +FROM golang:alpine as builder + +WORKDIR /go/src +ADD . . +RUN CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -mod=vendor -tags netgo -o /go/bin/domogeek cmd/domogeek/domogeek.go + + + + +FROM gcr.io/distroless/static + +USER 1234 +COPY --from=builder /go/bin/domogeek /go/bin/domogeek +EXPOSE 8080 +ENTRYPOINT ["/go/bin/domogeek"] diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..261eeb9 --- /dev/null +++ b/LICENSE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/README.md b/README.md new file mode 100644 index 0000000..ec18809 --- /dev/null +++ b/README.md @@ -0,0 +1,8 @@ +# domogeek + +Tools for domotic + +## Calendar + +Return calendar informations about today + diff --git a/calendar/calendar.go b/calendar/calendar.go new file mode 100644 index 0000000..b27d34c --- /dev/null +++ b/calendar/calendar.go @@ -0,0 +1,101 @@ +package calendar + +import ( + "math" + "time" +) + +type Calendar struct { + Location *time.Location +} + +func (cal *Calendar) GetEasterDay(year int) time.Time { + g := float64(year % 19.0) + c := math.Floor(float64(year) / 100.0) + c4 := math.Floor(c / 4.0) + h := float64(int(19.0*g+c-c4-math.Floor((8.0*c+13)/25)+15) % 30.0) + k := math.Floor(h / 28.0) + i := (k*math.Floor(29./(h+1.))*math.Floor((21.-g)/11.)-1.)*k + h + + // jour de Pâques (0=dimanche, 1=lundi....) + dayWeek := int(math.Floor(float64(year)/4.)+float64(year)+i+2+c4-c) % 7 + + // Jour de Pâques en jours enpartant de 1 = 1er mars + presJour := int(28 + int(i) - dayWeek) + + // mois (0 = janvier, ... 2 = mars, 3 = avril) + month := 2 + if presJour > 31 { + month = 3 + } + + // Mois dans l'année + month += 1 + + // jour du mois + day := presJour - 31 + if month == 2 { + day = presJour + } + + return time.Date(year, 3, 31, 0, 0, 0, 0, cal.Location).AddDate(0, 0, day) +} + +func (cal *Calendar) GetHolidays(year int) *[]time.Time { + + // Calcul du jour de pâques + paques := cal.GetEasterDay(year) + + joursFeries := []time.Time{ + // Jour de l'an + time.Date(year, time.January, 1, 0, 0, 0, 0, cal.Location), + // Easter + paques, + // 1 mai + time.Date(year, time.May, 1, 0, 0, 0, 0, cal.Location), + // 8 mai + time.Date(year, time.May, 8, 0, 0, 0, 0, cal.Location), + // Ascension + paques.AddDate(0, 0, 39), + // 14 juillet + time.Date(year, time.July, 14, 0, 0, 0, 0, cal.Location), + // 15 aout + time.Date(year, time.August, 15, 0, 0, 0, 0, cal.Location), + // Toussaint + time.Date(year, time.November, 1, 0, 0, 0, 0, cal.Location), + // 11 novembre + time.Date(year, time.November, 11, 0, 0, 0, 0, cal.Location), + // noël + time.Date(year, time.December, 25, 0, 0, 0, 0, cal.Location), + } + + return &joursFeries +} + +func (cal *Calendar) GetHolidaysSet(year int) *map[time.Time]bool { + holidays := cal.GetHolidays(year) + result := make(map[time.Time]bool, len(*holidays)) + for _, h := range *holidays { + result[h] = true + } + return &result +} + +func(cal *Calendar) IsHoliday(date time.Time) bool{ + h := cal.GetHolidaysSet(date.Year()) + d := date.In(cal.Location) + day := time.Date(d.Year(), d.Month(), d.Day(), 0, 0, 0, 0, cal.Location) + return (*h)[day] +} + +func (cal *Calendar) IsWorkingDay(date time.Time) bool { + return !cal.IsHoliday(date) && date.Weekday() >= time.Monday && date.Weekday() <= time.Friday +} + +func (cal *Calendar) IsWorkingDayToday() bool { + return cal.IsWorkingDay(time.Now()) +} + +func (cal *Calendar) IsWeekDay(day time.Time) bool{ + return day.Weekday() >= time.Monday && day.Weekday() <= time.Friday +} diff --git a/calendar/calendar_test.go b/calendar/calendar_test.go new file mode 100644 index 0000000..7a5cf6d --- /dev/null +++ b/calendar/calendar_test.go @@ -0,0 +1,166 @@ +package calendar + +import ( + "testing" + "time" +) + +func TestCalendar_GetEasterDay(t *testing.T) { + loc, err := time.LoadLocation("Europe/Paris") + if err != nil { + t.Errorf("unable to load time location: %v", err) + t.Fail() + } + + easterDays := []time.Time{ + time.Date(2019, time.April, 21, 0, 0, 0, 0, loc), + time.Date(2020, time.April, 12, 0, 0, 0, 0, loc), + time.Date(2021, time.April, 4, 0, 0, 0, 0, loc), + } + + c := Calendar{loc} + + for _, d := range easterDays { + easter := c.GetEasterDay(d.Year()) + if easter != d { + t.Errorf("bad date for year %d, expected:%v ; actual:%v", d.Year(), d, easter) + } + } +} + +func TestCalendar_GetHolidays(t *testing.T) { + loc, err := time.LoadLocation("Europe/Paris") + if err != nil { + t.Errorf("unable to load time location: %v", err) + t.Fail() + } + + expectedHolidays := map[time.Time]bool{ + time.Date(2020, time.January, 1, 0, 0, 0, 0, loc): true, + time.Date(2020, time.April, 12, 0, 0, 0, 0, loc): true, + time.Date(2020, time.May, 1, 0, 0, 0, 0, loc): true, + time.Date(2020, time.May, 8, 0, 0, 0, 0, loc): true, + time.Date(2020, time.May, 21, 0, 0, 0, 0, loc): true, + time.Date(2020, time.July, 14, 0, 0, 0, 0, loc): true, + time.Date(2020, time.August, 15, 0, 0, 0, 0, loc): true, + time.Date(2020, time.November, 1, 0, 0, 0, 0, loc): true, + time.Date(2020, time.November, 11, 0, 0, 0, 0, loc): true, + time.Date(2020, time.December, 25, 0, 0, 0, 0, loc): true, + } + + c := Calendar{loc} + holidays := c.GetHolidays(2020) + if len(*holidays) != len(expectedHolidays) { + t.Errorf("bad number of holidays, %d but %d are expected", len(*holidays), len(expectedHolidays)) + } + for _, h := range *holidays { + if !expectedHolidays[h] { + t.Errorf("%v is not a holiday", h) + } + } +} + +func TestCalendar_GetHolidaysSet(t *testing.T) { + loc, err := time.LoadLocation("Europe/Paris") + if err != nil { + t.Errorf("unable to load time location: %v", err) + t.Fail() + } + + expectedHolidays := []time.Time{ + time.Date(2020, time.January, 1, 0, 0, 0, 0, loc), + time.Date(2020, time.April, 12, 0, 0, 0, 0, loc), + time.Date(2020, time.May, 1, 0, 0, 0, 0, loc), + time.Date(2020, time.May, 8, 0, 0, 0, 0, loc), + time.Date(2020, time.May, 21, 0, 0, 0, 0, loc), + time.Date(2020, time.July, 14, 0, 0, 0, 0, loc), + time.Date(2020, time.August, 15, 0, 0, 0, 0, loc), + time.Date(2020, time.November, 1, 0, 0, 0, 0, loc), + time.Date(2020, time.November, 11, 0, 0, 0, 0, loc), + time.Date(2020, time.December, 25, 0, 0, 0, 0, loc), + } + + c := Calendar{loc} + holidays := c.GetHolidaysSet(2020) + if len(*holidays) != len(expectedHolidays) { + t.Errorf("bad number of holidays, %d but %d are expected", len(*holidays), len(expectedHolidays)) + } + for _, h := range expectedHolidays { + if !(*holidays)[h] { + t.Errorf("%v is not a holiday", h) + } + } +} + +func TestCalendar_IsHolidays(t *testing.T) { + loc, err := time.LoadLocation("Europe/Paris") + if err != nil { + t.Errorf("unable to load time location: %v", err) + t.Fail() + } + + expectedHolidays := []time.Time{ + time.Date(2020, time.January, 1, 0, 0, 0, 0, loc), + time.Date(2020, time.April, 12, 0, 0, 0, 0, loc), + time.Date(2020, time.May, 1, 0, 0, 0, 0, loc), + time.Date(2020, time.May, 8, 0, 0, 0, 0, loc), + time.Date(2020, time.May, 21, 0, 0, 0, 0, loc), + time.Date(2020, time.July, 14, 0, 0, 0, 0, loc), + time.Date(2020, time.August, 15, 0, 0, 0, 0, loc), + time.Date(2020, time.November, 1, 0, 0, 0, 0, loc), + time.Date(2020, time.November, 11, 0, 0, 0, 0, loc), + time.Date(2020, time.December, 25, 0, 0, 0, 0, loc), + } + + c := Calendar{loc} + holidays := c.GetHolidaysSet(2020) + if len(*holidays) != len(expectedHolidays) { + t.Errorf("bad number of holidays, %d but %d are expected", len(*holidays), len(expectedHolidays)) + } + for _, h := range expectedHolidays { + if !c.IsHoliday(h) { + t.Errorf("%v is a holiday", h) + } + } + if c.IsHoliday(time.Date(2019, time.January, 02, 0, 0, 0, 0, loc)) { + t.Error("02 january should not be a holiday") + } +} + +func TestCalendar_IsWorkingDay(t *testing.T) { + loc, err := time.LoadLocation("Europe/Paris") + if err != nil { + t.Errorf("unable to load time location: %v", err) + t.Fail() + } + c := Calendar{loc} + + if c.IsWorkingDay(time.Date(2019, time.January, 01, 0, 0, 0, 0, loc)) { + t.Error("1st january is not a working day") + } + if !c.IsWorkingDay(time.Date(2019, time.January, 02, 0, 0, 0, 0, loc)) { + t.Error("02 january should be a working day") + } + + if !c.IsWorkingDay(time.Date(2019, time.January, 7, 0, 0, 0, 0, loc)) { + t.Error("Monday should be a working day") + } + if !c.IsWorkingDay(time.Date(2019, time.January, 8, 0, 0, 0, 0, loc)) { + t.Error("Tuesday should be a working day") + } + if !c.IsWorkingDay(time.Date(2019, time.January, 9, 0, 0, 0, 0, loc)) { + t.Error("Wednesday should be a working day") + } + if !c.IsWorkingDay(time.Date(2019, time.January, 10, 0, 0, 0, 0, loc)) { + t.Error("Thursday should be a working day") + } + if !c.IsWorkingDay(time.Date(2019, time.January, 11, 0, 0, 0, 0, loc)) { + t.Error("Friday should be a working day") + } + if c.IsWorkingDay(time.Date(2019, time.January, 12, 0, 0, 0, 0, loc)) { + t.Error("Saturday should not be a working day") + } + if c.IsWorkingDay(time.Date(2019, time.January, 13, 0, 0, 0, 0, loc)) { + t.Error("Sunday should not be a working day") + } +} diff --git a/cmd/domogeek/domogeek.go b/cmd/domogeek/domogeek.go new file mode 100644 index 0000000..c872a86 --- /dev/null +++ b/cmd/domogeek/domogeek.go @@ -0,0 +1,69 @@ +package main + +import ( + "domogeek/calendar" + "encoding/json" + "flag" + "fmt" + "log" + "net/http" + "time" +) + +func init() { + loc, err := time.LoadLocation("Europe/Paris") + if err != nil { + log.Fatalf("unable to load time location: %v", err) + } + cal = calendar.Calendar{loc} +} + +type CalendarDay struct { + Day time.Time `json:"day"` + WorkingDay bool `json:"working_day"` + Ferie bool `json:"ferie"` + Holiday bool `json:"holiday"` + Weekday bool `json:"weekday"` +} + +var cal calendar.Calendar + +type CalendarHandler struct{} + +func (c *CalendarHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) { + now := time.Now() + cd := CalendarDay{ + Day: now, + WorkingDay: cal.IsWorkingDay(now), + Ferie: cal.IsHoliday(now), + Holiday: cal.IsHoliday(now), + Weekday: cal.IsWeekDay(now), + } + + content, err := json.Marshal(cd) + if err != nil { + w.WriteHeader(http.StatusInternalServerError) + log.Printf("unable to marshall response %v, %v", content, err) + } else { + _, err = w.Write(content) + if err != nil { + w.WriteHeader(http.StatusInternalServerError) + log.Printf("unable to marshall response %v, :%v", content, err) + } + } +} + +func main() { + var port int + var host string + + flag.StringVar(&host, "host", "", "host to listen, default all addresses") + flag.IntVar(&port, "port", 8080, "port to listen") + flag.Parse() + + addr := fmt.Sprintf("%s:%d", host, port) + log.Printf("start server on %s", addr) + + http.Handle("/calendar", &CalendarHandler{}) + log.Fatal(http.ListenAndServe(addr, nil)) +} diff --git a/go.mod b/go.mod new file mode 100644 index 0000000..a5ef4a9 --- /dev/null +++ b/go.mod @@ -0,0 +1,3 @@ +module domogeek + +go 1.13