func LoginFilter() martini.Handler { return func(res http.ResponseWriter, r *http.Request, c martini.Context, l *log.Logger, session sessions.Session, render render.Render) { if "POST" == r.Method && strings.HasPrefix(r.RequestURI, "/action/login") { c.Next() return } userInfo := session.Get(constant.UserInfoKey) if userInfo != nil { c.Next() return } l.Printf("User has not logged in, redirect to login page\n") render.HTML(200, "index", nil) } }
func main() { fmt.Println("server start") m := martini.Classic() m.Use(render.Renderer()) m.Use(martini.Static("views")) m.Get("/", func(r *http.Request, render render.Render) { render.HTML(200, "index", map[string]interface{}{}) }) // m.Post("/stickies/") m.Run() }
func main() { m := martini.Classic() // 静的ファイルの利用 m.Use(martini.Static("static")) // テンプレート関数の登録 m.Use(render.Renderer(render.Options{ Directory: "templates", // Specify what path to load the templates from. Extensions: []string{".tmpl", ".html"}, // Specify extensions to load for templates. Funcs: []template.FuncMap{{ "nl2br": nl2br, "htmlquote": htmlquote, "str2html": str2html, "dateformat": dateformat, }}, })) // データベース初期化 dbmap := initDb() defer dbmap.Db.Close() // トップページ m.Get("/", func(render render.Render) { var greetings []Greeting _, err := dbmap.Select(&greetings, "select * from greetings order by CreateAt desc") if err != nil { panic(err) } render.HTML(200, "index", greetings) }) // 投稿 m.Post("/post", func(w http.ResponseWriter, r *http.Request, render render.Render) { greeting := Greeting{ Name: r.FormValue("name"), Comment: r.FormValue("comment"), CreateAt: time.Now().UnixNano(), } dbmap.Insert(&greeting) render.Redirect("/", 302) }) m.Run() }
func Run(config c.QuestConfig, qs *QuestStorage, ntf *ntf.Notifier, additionalNotifier *ntf.Notifier) { m := martini.New() m.Use(w.NonJsonLogger()) m.Use(martini.Recovery()) m.Use(render.Renderer(render.Options{ Directory: "templates/quests", Layout: "layout", Extensions: []string{".tmpl", ".html"}, Charset: "UTF-8", IndentJSON: true, IndentXML: true, Funcs: []template.FuncMap{ template.FuncMap{ "eq_s": func(a, b string) bool { return a == b }, "stamp_date": func(t time.Time) string { return t.Format(time.Stamp) }, }, }, })) m.Use(auth.BasicFunc(func(username, password string) bool { pwd, ok := users[username] return ok && pwd == password })) m.Use(martini.Static("static")) r := martini.NewRouter() r.Get("/", func(user auth.User, render render.Render) { render.HTML(200, "readme", map[string]interface{}{}) }) r.Get("/new_keys", func(render render.Render) { render.HTML(200, "new_keys", GetKeysErrorInfo("", qs)) }) r.Post("/add_key", func(user auth.User, render render.Render, request *http.Request) { start_key := strings.TrimSpace(request.FormValue("start-key")) next_key := strings.TrimSpace(request.FormValue("next-key")) description := request.FormValue("description") log.Printf("QUESTS WEB add key %s -> %s -> %s", start_key, description, next_key) if start_key != "" && description != "" { key, err := qs.AddStep(start_key, description, next_key) if key != nil && err != nil { render.HTML(200, "new_keys", GetKeysErrorInfo("Такой ключ уже существует. Используйте изменение ключа если хотите его изменить.", qs)) return } } else { render.HTML(200, "new_keys", GetKeysErrorInfo("Невалидные значения ключа или ответа", qs)) return } render.Redirect("/new_keys") }) r.Post("/delete_key/:key", func(params martini.Params, render render.Render) { key := params["key"] err := qs.DeleteStep(key) log.Printf("QUESTS WEB will delete %v (%v)", key, err) render.Redirect("/new_keys") }) r.Post("/update_key/:key", func(params martini.Params, render render.Render, request *http.Request) { key_id := params["key"] start_key := strings.TrimSpace(request.FormValue("start-key")) next_key := strings.TrimSpace(request.FormValue("next-key")) description := request.FormValue("description") err := qs.UpdateStep(key_id, start_key, description, next_key) log.Printf("QUESTS WEB was update key %s %s %s %s\n err? %v", key_id, start_key, description, next_key, err) render.Redirect("/new_keys") }) r.Get("/delete_key_all", func(render render.Render) { qs.Steps.RemoveAll(bson.M{}) render.Redirect("/new_keys") }) xlsFileReg := regexp.MustCompile(".+\\.xlsx?") r.Post("/load/up", func(render render.Render, request *http.Request) { file, header, err := request.FormFile("file") log.Printf("QS: Form file information: file: %+v \nheader:%v, %v\nerr:%v", file, header.Filename, header.Header, err) if err != nil { render.HTML(200, "new_keys", GetKeysErrorInfo(fmt.Sprintf("Ошибка загрузки файлика: %v", err), qs)) return } defer file.Close() data, err := ioutil.ReadAll(file) if err != nil { render.HTML(200, "new_keys", GetKeysErrorInfo(fmt.Sprintf("Ошибка загрузки файлика: %v", err), qs)) return } if xlsFileReg.MatchString(header.Filename) { xlFile, err := xlsx.OpenBinary(data) if err != nil || xlFile == nil { render.HTML(200, "new_keys", GetKeysErrorInfo(fmt.Sprintf("Ошибка обработки файлика: %v", err), qs)) return } skip_rows, errsr := strconv.Atoi(request.FormValue("skip-rows")) skip_cols, errsc := strconv.Atoi(request.FormValue("skip-cols")) if errsr != nil || errsc != nil { render.HTML(200, "new_keys", GetKeysErrorInfo("Не могу распознать количества столбцов и строк пропускаемых :(", qs)) return } log.Printf("QS: Will process file: %+v, err: %v \n with skipped rows: %v, cols: %v", xlFile, err, skip_rows, skip_cols) parse_res, errp := w.ParseExportXlsx(xlFile, skip_rows, skip_cols) if errp != nil { render.HTML(200, "new_keys", GetKeysErrorInfo("Ошибка в парсинге файла:(", qs)) return } res, val_err := ValidateKeys(parse_res) if val_err != nil { render.HTML(200, "new_keys", GetKeysErrorInfo(val_err.Error(), qs)) return } for _, prel := range parse_res { qs.AddStep(prel[0], prel[1], prel[2]) } render.HTML(200, "new_keys", GetKeysTeamsInfo(res, qs)) } else { render.HTML(200, "new_keys", GetKeysErrorInfo("Файл имеет не то расширение :(", qs)) } render.Redirect("/new_keys") }) r.Get("/chat", func(render render.Render, params martini.Params, req *http.Request) { var with string result_data := map[string]interface{}{} query := req.URL.Query() for key, value := range query { if key == "with" && len(value) > 0 { with = value[0] log.Printf("QSERV: with found is: %v", with) break } } type Collocutor struct { IsTeam bool IsMan bool IsAll bool IsWinner bool WinTime string Info interface{} Name string } collocutor := Collocutor{} var messages []Message if with != ALL && with != ALL_TEAM_MEMBERS { if team, _ := qs.GetTeamByName(with); team != nil { type TeamInfo struct { FoundedKeys []string Members []TeamMember AllKeys []Step } collocutor.Name = team.Name collocutor.IsTeam = true collocutor.IsWinner = team.Winner if collocutor.IsWinner { tm := time.Unix(team.WinTime, 0) collocutor.WinTime = tm.Format("Mon 15:04:05") } members, _ := qs.GetMembersOfTeam(team.Name) keys, _ := qs.GetSteps(bson.M{"for_team": team.Name}) keys = SortSteps(keys) collocutor.Info = TeamInfo{FoundedKeys: team.FoundKeys, Members: members, AllKeys: keys} messages, _ = qs.GetMessages(bson.M{ "$or": []bson.M{ bson.M{"from": team.Name}, bson.M{"to": team.Name}, }, }) } else { if peoples, _ := qs.GetPeoples(bson.M{"user_id": with}); len(peoples) > 0 { man := peoples[0] collocutor.IsMan = true collocutor.Name = man.Name collocutor.Info = man messages, _ = qs.GetMessages(bson.M{ "$or": []bson.M{ bson.M{"from": man.UserId}, bson.M{"to": man.UserId}, }, }) for i, _ := range messages { if messages[i].From != ME { messages[i].From = man.Name } } } else { with = "all" } } } if strings.HasPrefix(with, "all") { collocutor.IsAll = true collocutor.Name = with messages, _ = qs.GetMessages(bson.M{"to": with}) } //log.Printf("QS i return this messages: %+v", messages) result_data["with"] = with result_data["collocutor"] = collocutor if len(messages) > 100 { messages = messages[0:100] } result_data["messages"] = messages qs.SetMessagesRead(with) all_teams, _ := qs.GetAllTeams() if contacts, err := qs.GetContacts(all_teams); err == nil { result_data["contacts"] = contacts } render.HTML(200, "chat", result_data) }) r.Post("/send", func(render render.Render, req *http.Request) { type MessageFromF struct { From string `json:"from"` To string `json:"to"` Body string `json:"body"` } data, err := ioutil.ReadAll(req.Body) if err != nil { log.Printf("QS QE E: errror at reading req body %v", err) render.JSON(500, map[string]interface{}{"error": err}) return } message := MessageFromF{} err = json.Unmarshal(data, &message) if err != nil { log.Printf("QS QE E: at unmarshal json messages %v\ndata:%s", err, data) render.JSON(500, map[string]interface{}{"error": err}) return } log.Printf("QS I see this data for send message from f:\n %+v", message) var result Message if message.From != "" && message.To != "" && message.Body != "" { if message.To == "all" { peoples, _ := qs.GetPeoples(bson.M{}) log.Printf("QSERV: will send [%v] to all %v peoples", message.Body, len(peoples)) SendMessagesToPeoples(peoples, ntf, message.Body) } else if message.To == "all_team_members" { peoples, _ := qs.GetAllTeamMembers() log.Printf("QSERV: will send [%v] to all team members %v peoples", message.Body, len(peoples)) SendMessagesToPeoples(peoples, ntf, message.Body) } else { team, _ := qs.GetTeamByName(message.To) if team == nil { man, _ := qs.GetManByUserId(message.To) if man != nil { log.Printf("QSERV: will send [%v] to %v", message.Body, man.UserId) go ntf.NotifyText(man.UserId, message.Body) } } else { peoples, _ := qs.GetMembersOfTeam(team.Name) log.Printf("QSERV: will send [%v] to team members of %v team to %v peoples", message.Body, team.Name, len(peoples)) SendMessagesToPeoples(peoples, ntf, message.Body) } } result, err = qs.StoreMessage(message.From, message.To, message.Body, false) if err != nil { log.Printf("QSERV: error at storing message %v", err) render.JSON(200, map[string]interface{}{"ok": false}) return } result.TimeFormatted = result.Time.Format(time.Stamp) } else { render.JSON(200, map[string]interface{}{"ok": false}) } render.JSON(200, map[string]interface{}{"ok": true, "message": result}) }) r.Post("/messages", func(render render.Render, req *http.Request) { type NewMessagesReq struct { For string `json:"m_for"` After int64 `json:"after"` } q := NewMessagesReq{} request_body, err := ioutil.ReadAll(req.Body) if err != nil { render.JSON(500, map[string]interface{}{"ok": false, "detail": "can not read request body"}) return } err = json.Unmarshal(request_body, &q) if err != nil { render.JSON(500, map[string]interface{}{"ok": false, "detail": fmt.Sprintf("can not unmarshal request body %v \n %s", err, request_body)}) return } messages, err := qs.GetMessages(bson.M{"from": q.For, "time_stamp": bson.M{"$gt": q.After}}) if err != nil { render.JSON(500, map[string]interface{}{"ok": false, "detail": fmt.Sprintf("error in db: %v", err)}) return } for i, message := range messages { team, _ := qs.GetTeamByName(message.From) if team != nil { messages[i].From = team.Name } else { man, _ := qs.GetManByUserId(message.From) if man != nil { messages[i].From = man.Name } } messages[i].TimeFormatted = message.Time.Format(time.Stamp) } render.JSON(200, map[string]interface{}{"messages": messages, "next_": time.Now().Unix()}) }) r.Post("/contacts", func(render render.Render, req *http.Request) { type NewContactsReq struct { After int64 `json:"after"` Exist []string `json:"exist"` } cr := NewContactsReq{} request_body, err := ioutil.ReadAll(req.Body) if err != nil { render.JSON(500, map[string]interface{}{"ok": false, "detail": "can not read request body"}) return } err = json.Unmarshal(request_body, &cr) if err != nil { render.JSON(500, map[string]interface{}{"ok": false, "detail": fmt.Sprintf("can not unmarshal request body %v \n %s", err, request_body)}) return } contacts, err := qs.GetContactsAfter(cr.After) if err != nil { render.JSON(500, map[string]interface{}{"ok": false, "detail": err}) return } new_contacts := []Contact{} old_contacts := []Contact{} for _, contact := range contacts { if utils.InS(contact.ID, cr.Exist) { old_contacts = append(old_contacts, contact) } else { new_contacts = append(new_contacts, contact) } } render.JSON(200, map[string]interface{}{ "ok": true, "new": new_contacts, "old": old_contacts, "next_": time.Now().Unix(), }) }) r.Get("/manage", func(render render.Render, req *http.Request) { configResult, err := qs.GetMessageConfiguration(config.Chat.CompanyId) if err != nil { log.Printf("QS E: Can not load quest configuration for %v, because: %v", config.Chat.CompanyId, err) } render.HTML(200, "manage", map[string]interface{}{"config": configResult}) }) r.Post("/manage", binding.Bind(QuestMessageConfiguration{}), func(qmc QuestMessageConfiguration, ren render.Render, req *http.Request) { if req.FormValue("to-winner-on") == "on" { qmc.EndMessageForWinnersActive = true } if req.FormValue("to-not-winner-on") == "on" { qmc.EndMessageForNotWinnersActive = true } if req.FormValue("to-all-on") == "on" { qmc.EndMessageForAllActive = true } log.Printf("QS Manage: %+v", qmc) qmc.CompanyId = config.Chat.CompanyId err := qs.SetMessageConfiguration(qmc, true) if err != nil { log.Printf("QS ERROR at update quest message configuration for [%v], because: %v", qmc.CompanyId, err) } ren.Redirect("/manage", 302) }) r.Post("/start_quest", func(ren render.Render) { qmc, err := qs.GetMessageConfiguration(config.Chat.CompanyId) if err != nil { log.Printf("QS E: Can not load quest configuration for %v, because: %v", config.Chat.CompanyId, err) ren.JSON(500, map[string]interface{}{"ok": false, "detail": err}) return } if qmc.Started == false { qs.SetQuestStarted(config.Chat.CompanyId, true) ren.JSON(200, map[string]interface{}{"ok": true}) } else { ren.JSON(200, map[string]interface{}{"ok": false, "detail": "already started"}) } }) r.Post("/stop_quest", func(ren render.Render) { qmc, err := qs.GetMessageConfiguration(config.Chat.CompanyId) if err != nil { log.Printf("QS E: Can not load quest configuration for %v, because: %v", config.Chat.CompanyId, err) ren.JSON(500, map[string]interface{}{"ok": false, "detail": err}) return } if qmc.Started == true { qs.SetQuestStarted(config.Chat.CompanyId, false) teams, err := qs.GetAllTeams() if err != nil { log.Printf("QS QE E: errror at getting teams %v", err) } if qmc.EndMessageForAllActive == true { for _, team := range teams { log.Printf("QS Will send message to team: %v from Klichat", team.Name) members, _ := qs.GetMembersOfTeam(team.Name) SendMessagesToPeoples(members, additionalNotifier, qmc.EndMessageForAll) } } if qmc.EndMessageForWinnersActive == true { for _, team := range teams { if team.Winner == true { log.Printf("QS Will send WIN message to team: %v from quest", team.Name) members, _ := qs.GetMembersOfTeam(team.Name) SendMessagesToPeoples(members, ntf, qmc.EndMessageForWinners) } } } if qmc.EndMessageForNotWinnersActive == true { for _, team := range teams { if team.Winner == false { log.Printf("QS Will send NOT WIN message to team: %v from quest", team.Name) members, _ := qs.GetMembersOfTeam(team.Name) SendMessagesToPeoples(members, ntf, qmc.EndMessageForNotWinners) } } } ren.JSON(200, map[string]interface{}{"ok": true}) } else { ren.JSON(200, map[string]interface{}{"ok": false, "detail": "already stopped"}) } }) r.Get("/delete_chat/:between", func(params martini.Params, render render.Render, req *http.Request) { between := params["between"] qs.Messages.RemoveAll(bson.M{"$or": []bson.M{bson.M{"from": between}, bson.M{"to": between}}}) render.Redirect(fmt.Sprintf("/chat?with=%v", between)) }) r.Post("/send_messages_at_quest_end", func(render render.Render, req *http.Request) { type Messages struct { Text string `json:"text"` Teams []string `json:"teams"` Exclude bool `json:"exclude"` } messages := Messages{} data, err := ioutil.ReadAll(req.Body) if err != nil { log.Printf("QS QE E: errror at reading req body %v", err) render.JSON(500, map[string]interface{}{"error": err}) return } err = json.Unmarshal(data, &messages) if err != nil { log.Printf("QS QE E: at unmarshal json messages %v", err) render.JSON(500, map[string]interface{}{"error": err}) return } log.Printf("QS I see this data for send messages at quest end:\n %+v", messages) if messages.Exclude { teams, err := qs.GetAllTeams() if err != nil { log.Printf("QS QE E: errror at getting teams %v", err) render.JSON(500, map[string]interface{}{"error": err}) return } for _, team := range teams { if !utils.InS(team.Name, messages.Teams) { log.Printf("QS Will send message to team: %v", team.Name) members, _ := qs.GetMembersOfTeam(team.Name) SendMessagesToPeoples(members, additionalNotifier, messages.Text) } } render.JSON(200, map[string]interface{}{"ok": true}) } else { for _, team_name := range messages.Teams { members, err := qs.GetMembersOfTeam(team_name) if err != nil { log.Printf("QS QE E: errror at getting team members %v", err) continue } log.Printf("QS Will send message to team: %v", team_name) SendMessagesToPeoples(members, additionalNotifier, messages.Text) } render.JSON(200, map[string]interface{}{"ok": true}) } }) r.Post("/delete_all_keys", func(render render.Render, req *http.Request) { //1. Steps or keys: si, _ := qs.Steps.RemoveAll(bson.M{}) //2 Peoples pi, _ := qs.Peoples.UpdateAll(bson.M{ "$and": []bson.M{ bson.M{"$or": []bson.M{ bson.M{"is_passerby": false}, bson.M{"is_passerby": bson.M{"$exists": false}}, }}, bson.M{"$or": []bson.M{ bson.M{"team_name": bson.M{"$exists": true}}, bson.M{"team_sid": bson.M{"$exists": true}}, }}, }, }, bson.M{ "$set": bson.M{"is_passerby": true}, "$unset": bson.M{"team_name": "", "team_sid": ""}, }) //3 teams and messages teams := []Team{} qs.Teams.Find(bson.M{}).All(&teams) tc := 0 mc := 0 for _, team := range teams { mri, _ := qs.Messages.RemoveAll(bson.M{ "$or": []bson.M{ bson.M{"from": team.Name}, bson.M{"to": team.Name}, }}) mc += mri.Removed qs.Teams.RemoveId(team.ID) tc += 1 } render.JSON(200, map[string]interface{}{ "ok": true, "steps_removed": si.Removed, "peoples_updated": pi.Updated, "teams_removed": tc, "messages_removed": mc, }) }) r.Post("/founded_keys", func(ren render.Render, req *http.Request) { type T struct { Name string `json:"team"` } t := T{} body, _ := ioutil.ReadAll(req.Body) json.Unmarshal(body, &t) steps, _ := qs.GetSteps(bson.M{"for_team": t.Name, "is_found": true}) ren.JSON(200, map[string]interface{}{"keys": steps}) }) type FoundKey struct { Name string `bson:"name" json:"name"` Found bool `bson:"found" json:"found"` Id string `json:"id"` Description string `json:"description"` } type TeamInfo struct { TeamName string `bson:"team_name" json:"team_name"` Keys []FoundKey `json:"keys"` Steps []Step `bson:"steps"` } r.Get("/info_page", func(ren render.Render, req *http.Request) { result := []TeamInfo{} err := qs.Steps.Pipe([]bson.M{ bson.M{"$group": bson.M{ "_id": "$for_team", "team_name": bson.M{"$first": "$for_team"}, "steps": bson.M{"$push": bson.M{ "_id": "$_id", "is_found": "$is_found", "next_key": "$next_key", "start_key": "$start_key", "description": "$description", }}}}, bson.M{"$sort": bson.M{ "team_name": 1}}, }).All(&result) if err != nil { log.Printf("QS Error at aggregate info page %v", err) } for ti, teamInfo := range result { steps := SortSteps(teamInfo.Steps) keys := []FoundKey{} for _, step := range steps { keys = append(keys, FoundKey{Name: step.StartKey, Found: step.IsFound, Id: step.ID.Hex(), Description: step.Description}) } result[ti].Keys = keys result[ti].Steps = []Step{} } ren.HTML(200, "info_page", map[string]interface{}{"teams": result}) }) r.Post("/info_page/update", func(ren render.Render, req *http.Request) { found_keys, err := qs.GetSteps(bson.M{"is_found": true}) if err != nil { ren.JSON(500, map[string]interface{}{"ok": false, "error": err.Error()}) } type UpdateKeyResult struct { Id string `json:"id"` } result := []UpdateKeyResult{} for _, key := range found_keys { result = append(result, UpdateKeyResult{Id: key.ID.Hex()}) } ren.JSON(200, map[string]interface{}{"ok": true, "foundKeys": result}) }) r.Post("/start_quest", func(ren render.Render, req *http.Request) { ren.JSON(200, map[string]interface{}{"ok": true}) }) r.Post("/stop_quest") //m.MapTo(r, (*martini.Routes)(nil)) log.Printf("Will start web server for quest at: %v", config.WebPort) m.Action(r.Handle) m.RunOnAddr(config.WebPort) }
func Run(addr string, db *d.MainDb, qs *quests.QuestStorage, vdh *voting.VotingDataHandler, ntf *ntf.Notifier, cfg c.Configuration) { m := martini.New() m.Use(w.NonJsonLogger()) m.Use(martini.Recovery()) m.Use(martini.Static("static")) m.Use(render.Renderer(render.Options{ Directory: "templates/console", //Layout: "console/layout", Extensions: []string{".tmpl", ".html"}, Charset: "UTF-8", IndentJSON: true, IndentXML: true, Funcs: []template.FuncMap{ template.FuncMap{ "eq_s": func(a, b string) bool { return a == b }, "stamp_date": func(t time.Time) string { return t.Format(time.Stamp) }, "chat_with": func(with string) string { result := fmt.Sprintf("/chat?with=%v", with) return result }, "me": func() string { return ME }, "is_message_": func(msg d.MessageWrapper, attrName string) bool { return msg.IsAttrPresent(attrName) }, "has_additional_data": func(msg d.MessageWrapper) bool { return len(msg.AdditionalData) > 0 }, "is_additional_data_valid": func(ad d.AdditionalDataElement) bool { return ad.Value != "" }, "from_slice": func(slice []string) string { return strings.Join(slice, " ") }, "clear": func(s string) string { return regexp.MustCompile("[^a-zA-Z0-9]+").ReplaceAllString(s, "") }, "is_auth": func(u interface{}) bool { log.Printf("Is auth user: %v", u) if u != nil { user := u.(w.User) return user.IsAuthenticated() } return false }, }, }, })) m.MapTo(db, (*d.DB)(nil)) r := martini.NewRouter() r = w.EnsureAuth(r, db) r.Get("/klichat", w.LoginRequired, w.AutHandler.CheckIncludeAnyRole(MANAGER), func(r render.Render, req *http.Request) { r.HTML(200, "index", w.AddCurrentUser(map[string]interface{}{}, req, db), render.HTMLOptions{Layout: "base"}) }) r.Group("/profile", func(r martini.Router) { type ProfileId struct { Id string `json:"id"` } pg_conf := cfg.Main.PGDatabase ph, err := NewProfileDbHandler(pg_conf.ConnString, cfg.Main.ConfigDatabase) if err != nil { panic(err) } r.Get("", w.LoginRequired, w.AutHandler.CheckIncludeAnyRole(MANAGER), func(render render.Render) { render.HTML(200, "profile", map[string]interface{}{}) }) r.Get("/all", func(render render.Render) { log.Printf("CS start querying for all profiles...") profiles, err := ph.GetAllProfiles() if err != nil { log.Printf("CS Error at getting all profiles: %v", err) render.JSON(500, map[string]interface{}{"success": false, "error": err}) } log.Printf("CS found %v profiles.", len(profiles)) render.JSON(200, map[string]interface{}{ "success": true, "profiles": profiles, }) }) r.Get("/link_types", func(render render.Render) { render.JSON(200, map[string]interface{}{"data": ph.GetContactLinkTypes()}) }) r.Post("/read", w.LoginRequired, w.AutHandler.CheckIncludeAnyRole(MANAGER), func(render render.Render, params martini.Params, req *http.Request) { data, err := ioutil.ReadAll(req.Body) if err != nil { log.Printf("error at reading post data %v", err) } log.Printf("CS READ data: %s", data) info := ProfileId{} err = json.Unmarshal(data, &info) if err != nil { log.Printf("CS READ error at unmarshal read data %v", err) render.JSON(500, map[string]interface{}{"error": err, "success": false}) return } profile, err := ph.GetProfile(info.Id) if err != nil { log.Printf("CS READ error at unmarshal read data %v", err) render.JSON(500, map[string]interface{}{"error": err, "success": false}) return } out, err := json.Marshal(profile) if err != nil { log.Printf("CS READ error at marshal data to out") render.JSON(500, map[string]interface{}{"error": err, "success": false}) } render.JSON(200, map[string]interface{}{"success": true, "data": out}) }) r.Post("/create", w.LoginRequired, w.AutHandler.CheckIncludeAnyRole(MANAGER), func(render render.Render, params martini.Params, req *http.Request) { data, err := ioutil.ReadAll(req.Body) if err != nil { log.Printf("error at reading post data %v", err) } log.Printf("CS CREATE data: %s", data) profile := &Profile{} err = json.Unmarshal(data, profile) if err != nil { log.Printf("CS CREATE error at unmarshal data at create profile %v", err) render.JSON(500, map[string]interface{}{"error": err, "success": false}) return } profile = ProfileTextTagClear(profile) log.Printf("CS CREATE profile: %+v", profile) profile, err = ph.InsertNewProfile(profile) if err != nil { log.Printf("CS CREATE DB are not available") render.JSON(500, map[string]interface{}{"error": err, "success": false}) } out, err := json.Marshal(profile) if err != nil { log.Printf("CS CREATE error at marshal data to out") render.JSON(500, map[string]interface{}{"error": err, "success": false}) } render.JSON(200, map[string]interface{}{"success": true, "data": out}) }) r.Post("/update", w.LoginRequired, w.AutHandler.CheckIncludeAnyRole(MANAGER), func(render render.Render, params martini.Params, req *http.Request) { data, err := ioutil.ReadAll(req.Body) log.Printf("CS UPDATE data: %s", data) if err != nil { log.Printf("CS UPDATE error at reading post data %v", err) render.JSON(500, map[string]interface{}{"error": err, "success": false}) return } profile := &Profile{} err = json.Unmarshal(data, profile) if err != nil { log.Printf("CS UPDATE error at unmarshal data at create profile %v", err) render.JSON(500, map[string]interface{}{"error": err, "success": false}) return } profile = ProfileTextTagClear(profile) log.Printf("CS UPDATE profile: %+v", profile) err = ph.UpdateProfile(profile) if err != nil { render.JSON(500, map[string]interface{}{"error": err, "success": false}) return } render.JSON(200, map[string]interface{}{"success": true}) }) r.Post("/delete", w.LoginRequired, w.AutHandler.CheckIncludeAnyRole(MANAGER), func(render render.Render, params martini.Params, req *http.Request) { data, err := ioutil.ReadAll(req.Body) if err != nil { log.Printf("CS DELETE error at reading post data %v", err) render.JSON(500, map[string]interface{}{"error": err, "success": false}) return } log.Printf("CS DELETE data: %s", data) info := ProfileId{} err = json.Unmarshal(data, &info) if err != nil { log.Printf("CS DELETE error at unmarshal delete data %v", err) render.JSON(500, map[string]interface{}{"error": err, "success": false}) return } err = ph.DeleteProfile(info.Id) if err != nil { log.Printf("CS DELETE error at which return storage %v", err) render.JSON(500, map[string]interface{}{"error": err, "success": false}) return } render.JSON(200, map[string]interface{}{"success": true}) }) r.Post("/upload_img/:profile_id", func(render render.Render, params martini.Params, req *http.Request) { profile_id := params["profile_id"] path := fmt.Sprintf("%v/%v", cfg.Console.ProfileImgPath, profile_id) file, handler, err := req.FormFile("img_file") defer file.Close() if err != nil { log.Printf("CS error at forming file %v", err) render.JSON(500, map[string]interface{}{"error": err, "success": false}) return } if !strings.Contains(handler.Header.Get("Content-Type"), "image") { render.JSON(200, map[string]interface{}{"error": "Вы загружаете не картинку", "success": false}) return } err = os.Mkdir(path, 0777) if err != nil { log.Printf("CS warn at mkdir %v", err) } profile, err := ph.GetProfile(profile_id) if err != nil { log.Printf("CS error at getting profile") render.JSON(500, map[string]interface{}{"error": err, "success": false}) return } if profile == nil { profile = &Profile{UserName: profile_id} } else { splitted := strings.Split(profile.ImageURL, "/") savedFname := splitted[len(splitted)-1] err = os.Remove(filepath.Join(path, savedFname)) if err != nil { log.Printf("CS Error at remove old icon ha ha ha") } } file_path := fmt.Sprintf("%v/%v", path, handler.Filename) f, err := os.OpenFile(file_path, os.O_WRONLY|os.O_CREATE, 0664) defer f.Close() if err != nil { log.Printf("CS error at open file %v", err) render.JSON(500, map[string]interface{}{"error": err, "success": false}) return } log.Printf("CS will save file at: [%v]", file_path) io.Copy(f, file) file_url := fmt.Sprintf("%v/%v/%v", cfg.Console.ProfileImgServer, profile_id, handler.Filename) log.Printf("CS will form image at: [%v]", file_url) profile.ImageURL = file_url ph.UpdateProfile(profile) render.JSON(200, map[string]interface{}{"success": true, "url": file_url}) }) r.Get("/employee/:phone", func(render render.Render, params martini.Params, req *http.Request) { phone := params["phone"] employee, err := ph.GetEmployeeByPhone(phone) if err != nil { log.Printf("CS Error getting employee by phone") render.JSON(500, map[string]interface{}{"error": err, "success": false}) return } render.JSON(200, map[string]interface{}{"success": true, "employee": employee}) }) r.Get("/all_groups", func(ren render.Render) { log.Printf("CS start querying for all groups") groups, err := ph.GetAllGroups() if err != nil { log.Printf("CS error at groups retrieve: %v", err) ren.JSON(500, map[string]interface{}{"error": err, "success": false}) return } log.Printf("CS forming next groups: %+v", groups) ren.JSON(200, map[string]interface{}{"success": true, "groups": groups}) }) r.Get("/all_features", func(ren render.Render) { log.Printf("CS start querying for all features") features, err := ph.GetAllFeatures() if err != nil { log.Printf("CS error at features retrieve: %v", err) ren.JSON(500, map[string]interface{}{"error": err, "success": false}) return } log.Printf("CS forming next features: %+v", features) ren.JSON(200, map[string]interface{}{"success": true, "features": features}) }) }) r.Group("/chat", func(r martini.Router) { r.Get("", w.LoginRequired, w.AutHandler.CheckIncludeAnyRole(MANAGER), func(r render.Render, params martini.Params, req *http.Request) { var with string result_data := map[string]interface{}{} query := req.URL.Query() for key, value := range query { if key == "with" && len(value) > 0 { with = value[0] log.Printf("CONSOLE CHAT: [with] == [%v]", with) break } } if with == "" { with = ALL } db.Messages.SetMessagesRead(with) collocutor := Collocutor{} var messages []d.MessageWrapper if with != ALL { user, _ := db.Users.GetUserById(with) if user != nil { messages, _ = db.Messages.GetMessages(bson.M{ "$or": []bson.M{ bson.M{"from": user.UserId}, bson.M{"to": user.UserId}, }, }) for i, _ := range messages { if messages[i].From != ME { messages[i].From = user.UserName } } collocutor.Name = user.UserName collocutor.Phone = user.Phone collocutor.Email = user.Email order_count, _ := db.Orders.Collection.Find(bson.M{"whom": user.UserId}).Count() resp := []OrdersInfo{} err := db.Orders.Collection.Pipe([]bson.M{ bson.M{"$match": bson.M{"whom": user.UserId}}, bson.M{"$group": bson.M{"_id": "$source", "count": bson.M{"$sum": 1}}}}).All(&resp) if err == nil { collocutor.Info.CountOrdersByProvider = resp } collocutor.Info.CountOrdersAll = order_count collocutor.InfoPresent = true } } if strings.Contains(with, ALL) { messages, _ = db.Messages.GetMessages(bson.M{"to": with}) } result_data["collocutor"] = collocutor result_data["with"] = with result_data["messages"] = messages if contacts, err := GetContacts(db); err == nil { result_data["contacts"] = contacts } log.Printf("CS result data :%+v", result_data) r.HTML(200, "chat", w.AddCurrentUser(result_data, req, db), render.HTMLOptions{Layout: "base"}) }) r.Post("/send", w.LoginRequired, w.AutHandler.CheckIncludeAnyRole(MANAGER), func(render render.Render, req *http.Request) { type MessageFromF struct { From string `json:"from"` To string `json:"to"` Body string `json:"body"` } data, err := ioutil.ReadAll(req.Body) if err != nil { log.Printf("CS QE E: errror at reading req body %v", err) render.JSON(500, map[string]interface{}{"error": err}) return } message := MessageFromF{} err = json.Unmarshal(data, &message) if err != nil { log.Printf("CS QE E: at unmarshal json messages %v\ndata:%s", err, data) render.JSON(500, map[string]interface{}{"error": err}) return } log.Printf("SEND MESSAGE: %+v", message) var messageSID string if message.From != "" && message.To != "" && message.Body != "" { if message.To == ALL { peoples, _ := db.Users.GetBy(bson.M{"user_id": bson.M{"$ne": message.From}}) ntf.SendMessageToPeople(peoples, message.Body) } else if message.To == "all_hash_writers" { peoples, _ := db.Users.GetBy(bson.M{"last_marker": bson.M{"$exists": true}}) ntf.SendMessageToPeople(peoples, message.Body) } else { user, _ := db.Users.GetUserById(message.To) if user != nil { db.Messages.SetMessagesRead(user.UserId) _, resultMessage, _ := ntf.NotifyText(message.To, message.Body) resultMessage, _ = db.Messages.GetMessageByMessageId(resultMessage.MessageID) messageSID = resultMessage.SID } } if err != nil { render.JSON(500, map[string]interface{}{"error": err}) } } else { render.Redirect("/chat") } render.JSON(200, map[string]interface{}{"ok": true, "message": d.NewMessageForWeb(messageSID, message.From, message.To, message.Body)}) }) r.Post("/messages_read", w.LoginRequired, w.AutHandler.CheckIncludeAnyRole(MANAGER), func(render render.Render, req *http.Request) { type Readed struct { From string `json:"from"` } data, err := ioutil.ReadAll(req.Body) if err != nil { log.Printf("CS QE E: errror at reading req body %v", err) render.JSON(500, map[string]interface{}{"error": err}) return } readed := Readed{} err = json.Unmarshal(data, &readed) if err != nil { log.Printf("CS QE E: at unmarshal json messages %v\ndata:%s", err, data) render.JSON(500, map[string]interface{}{"error": err}) return } err = db.Messages.SetMessagesRead(readed.From) if err != nil { log.Printf("CS QE E: at unmarshal json messages %v\ndata:%s", err, data) render.JSON(500, map[string]interface{}{"error": err}) return } render.JSON(200, map[string]interface{}{"ok": true}) }) r.Post("/unread_messages", func(render render.Render, req *http.Request) { type NewMessagesReq struct { For string `json:"m_for"` After int64 `json:"after"` } q := NewMessagesReq{} request_body, err := ioutil.ReadAll(req.Body) if err != nil { render.JSON(500, map[string]interface{}{"ok": false, "detail": "can not read request body"}) return } err = json.Unmarshal(request_body, &q) if err != nil { render.JSON(500, map[string]interface{}{"ok": false, "detail": fmt.Sprintf("can not unmarshal request body %v \n %s", err, request_body)}) return } query := bson.M{"time_stamp": bson.M{"$gt": q.After}} if q.For == "" { query["to"] = ME } else { query["from"] = q.For } messages, err := db.Messages.GetMessages(query) if err != nil { render.JSON(500, map[string]interface{}{"ok": false, "detail": fmt.Sprintf("error in db: %v", err)}) return } result := []d.MessageWrapper{} for i, msg := range messages { if msg.From != ME { u, _ := db.Users.GetUserById(msg.From) if u.ShowedName != "" { messages[i].From = u.ShowedName } else { messages[i].From = u.UserName } result = append(result, messages[i]) } } render.JSON(200, map[string]interface{}{"messages": result, "next_": time.Now().Unix()}) }) r.Post("/contacts", func(render render.Render, req *http.Request) { type NewContactsReq struct { Exist []string `json:"exist"` } cr := NewContactsReq{} request_body, err := ioutil.ReadAll(req.Body) if err != nil { render.JSON(500, map[string]interface{}{"ok": false, "detail": "can not read request body"}) return } err = json.Unmarshal(request_body, &cr) if err != nil { render.JSON(500, map[string]interface{}{"ok": false, "detail": fmt.Sprintf("can not unmarshal request body %v \n %s", err, request_body)}) return } contacts, err := GetContacts(db) if err != nil { render.JSON(500, map[string]interface{}{"ok": false, "detail": fmt.Sprintf("db err body %v", err)}) return } new_contacts := []usrs.Contact{} old_contacts := []usrs.Contact{} for _, contact := range contacts { if u.InS(contact.ID, cr.Exist) { if contact.NewMessagesCount > 0 { old_contacts = append(old_contacts, contact) } } else { new_contacts = append(new_contacts, contact) } } render.JSON(200, map[string]interface{}{ "ok": true, "new": new_contacts, "old": old_contacts, "next_": time.Now().Unix(), }) }) r.Delete("/delete_messages", w.LoginRequired, w.AutHandler.CheckIncludeAnyRole(MANAGER), func(params martini.Params, ren render.Render, req *http.Request) { type DeleteInfo struct { From string `json:"from"` To string `json:"to"` } data, err := ioutil.ReadAll(req.Body) if err != nil { log.Printf("CS QE E: errror at reading req body %v", err) ren.JSON(500, map[string]interface{}{"error": err}) return } dInfo := DeleteInfo{} err = json.Unmarshal(data, &dInfo) if err != nil { log.Printf("CS QE E: at unmarshal json messages %v\ndata:%s", err, data) ren.JSON(500, map[string]interface{}{"error": err}) return } count, err := db.Messages.DeleteMessages(dInfo.From, dInfo.To) if err != nil { ren.JSON(500, map[string]interface{}{"error": err}) return } ren.JSON(200, map[string]interface{}{"success": true, "deleted": count}) }) r.Post("/contacts_change", w.LoginRequired, w.AutHandler.CheckIncludeAnyRole(MANAGER), func(render render.Render, req *http.Request) { type NewContactName struct { Id string `json:"id"` NewName string `json:"new_name"` } ncn := NewContactName{} request_body, err := ioutil.ReadAll(req.Body) if err != nil { render.JSON(500, map[string]interface{}{"ok": false, "detail": "can not read request body"}) return } err = json.Unmarshal(request_body, &ncn) if err != nil { render.JSON(500, map[string]interface{}{"ok": false, "detail": fmt.Sprintf("can not unmarshal request body %v \n %s", err, request_body)}) return } err = db.Users.SetUserShowedName(ncn.Id, ncn.NewName) if err != nil { render.JSON(500, map[string]interface{}{"ok": false, "detail": err}) return } render.JSON(200, map[string]interface{}{"ok": true}) }) }) r.Get("/vote_result", w.LoginRequired, w.AutHandler.CheckIncludeAnyRole(MANAGER), func(ren render.Render, req *http.Request) { votes, err := vdh.GetTopVotes(-1) if err != nil { log.Printf("CS ERROR at retrieving votes %v", err) } ren.HTML(200, "vote_result", w.AddCurrentUser(map[string]interface{}{"votes": votes}, req, db), render.HTMLOptions{Layout: "base"}) }) r = EnsureWorkWithKeys(r, qs, db) r = EnsureWorkWithUsers(r, db) r.Get("/statistic", w.LoginRequired, w.AutHandler.CheckIncludeAnyRole(MANAGER), func(render render.Render) { err := EnsureStatistic(filepath.Join(martini.Root, "static", "tmp")) if err != nil { log.Printf("CS ERROR at formin statistics :( ") render.JSON(500, map[string]interface{}{"error": err}) } log.Printf("saved: %v", martini.Root) render.Redirect("/tmp/statistic.xlsx") }) r.Get("/logout", w.LoginRequired, func(user w.User, db d.DB, ren render.Render, req *http.Request, rw http.ResponseWriter) { err := db.UsersStorage().LogoutUser(user.UniqueId()) if err != nil { log.Printf("CONSOLE error at logout user: %v", err) } w.StopAuthSession(rw) ren.Redirect(w.AUTH_URL, 302) }) m.Action(r.Handle) m.RunOnAddr(addr) }
func show_provider_chooser() martini.Handler { return func(render render.Render) { render.HTML(200, "provider_chooser", nil) } }
func EnsureWorkWithKeys(r martini.Router, qs *quests.QuestStorage, db *d.MainDb) martini.Router { //todo add group and refactor normal r.Post("/load/up", w.LoginRequired, w.AutHandler.CheckIncludeAnyRole(MANAGER), func(render render.Render, request *http.Request) { xlsFileReg := regexp.MustCompile(".+\\.xlsx?") file, header, err := request.FormFile("file") if err != nil { render.HTML(200, "new_keys", w.AddCurrentUser(GetKeysInfo(fmt.Sprintf("Ошибка загрузки файлика: %v", err), qs), request, db)) return } log.Printf("Form file information: file: %+v \nheader:%v, %v\nerr:%v", file, header.Filename, header.Header, err) defer file.Close() data, err := ioutil.ReadAll(file) if err != nil { render.HTML(200, "new_keys", w.AddCurrentUser(GetKeysInfo(fmt.Sprintf("Ошибка загрузки файлика: %v", err), qs), request, db)) return } if xlsFileReg.MatchString(header.Filename) { xlFile, err := xlsx.OpenBinary(data) log.Printf("file: %+v, err: %v", xlFile, err) if err != nil || xlFile == nil { render.HTML(200, "quests/new_keys", w.AddCurrentUser(GetKeysInfo(fmt.Sprintf("Ошибка обработки файлика: %v", err), qs), request, db)) return } skip_rows, _ := strconv.Atoi(request.FormValue("skip-rows")) skip_cols, _ := strconv.Atoi(request.FormValue("skip-cols")) parse_res, _ := w.ParseExportXlsx(xlFile, skip_rows, skip_cols) for _, prel := range parse_res { qs.AddStep(prel[0], prel[1], prel[2]) } } else { render.HTML(200, "new_keys", w.AddCurrentUser(GetKeysInfo("Файл имеет не то расширение :(", qs), request, db)) } render.Redirect("/new_keys") }) r.Get("/new_keys", w.LoginRequired, w.AutHandler.CheckIncludeAnyRole(MANAGER), func(r render.Render, req *http.Request) { log.Printf("CONSOLE WEB will show keys") r.HTML(200, "new_keys", w.AddCurrentUser(GetKeysInfo("", qs), req, db), render.HTMLOptions{Layout: "base"}) }) r.Post("/add_key", w.LoginRequired, w.AutHandler.CheckIncludeAnyRole(MANAGER), func(user auth.User, render render.Render, request *http.Request) { start_key := request.FormValue("start-key") next_key := request.FormValue("next-key") description := request.FormValue("description") log.Printf("CONSOLE WEB add key %s -> %s -> %s", start_key, description, next_key) if start_key != "" && description != "" { key, err := qs.AddStep(start_key, description, next_key) log.Printf("QW is error? %v key: %v", err, key) render.Redirect("/new_keys") } else { render.HTML(200, "console/new_keys", w.AddCurrentUser(GetKeysInfo("Невалидные значения ключа или ответа", qs), request, db)) } }) r.Post("/delete_key/:key", w.LoginRequired, w.AutHandler.CheckIncludeAnyRole(MANAGER), func(params martini.Params, render render.Render) { key := params["key"] err := qs.DeleteStep(key) log.Printf("CONSOLE WEB will delete %v (%v)", key, err) render.Redirect("/new_keys") }) r.Post("/update_key/:key", w.LoginRequired, w.AutHandler.CheckIncludeAnyRole(MANAGER), func(params martini.Params, render render.Render, request *http.Request) { key_id := params["key"] start_key := request.FormValue("start-key") next_key := request.FormValue("next-key") description := request.FormValue("description") err := qs.UpdateStep(key_id, start_key, description, next_key) log.Printf("CONSOLE WEB was update key %s %s %s %s\n err? %v", key_id, start_key, description, next_key, err) render.Redirect("/new_keys") }) r.Get("/delete_key_all", w.LoginRequired, w.AutHandler.CheckIncludeAnyRole(MANAGER), func(render render.Render) { log.Printf("CONSOLE WEB was delete all keys") qs.Steps.RemoveAll(bson.M{}) render.Redirect("/new_keys") }) return r }