Exemplo n.º 1
0
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)
}
Exemplo n.º 2
0
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)
}