func GetChatSendHandler(start_addr string, notifier *ntf.Notifier, db *d.MainDb, config c.ChatConfig, cs *ChatStorage) http.Handler {
	m := GetMartini(config.Name, config.CompanyId, start_addr, db)
	m.Post(start_addr, web.LoginRequired, web.AutHandler.CheckWriteRights(config.CompanyId), 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("CS message to send: %v", message)
		var messageSID string
		if message.From != "" && message.To != "" && message.Body != "" {
			if message.To == ALL {
				peoples, _ := cs.GetUsersOfCompany(config.CompanyId)
				notifier.SendMessageToPeople(peoples, message.Body)
			} else {
				user, _ := db.Users.GetUserById(message.To)
				if user != nil {
					db.Messages.SetMessagesRead(user.UserId)
					_, resultMessage, _ := notifier.NotifyText(message.To, message.Body)
					resultMessage, _ = db.Messages.GetMessageByMessageId(resultMessage.MessageID)
					messageSID = resultMessage.SID
				}
				db.Messages.SetMessagesAnswered(message.To, config.CompanyId, config.CompanyId)
			}
		} else {
			render.Redirect("/chat")
		}
		render.JSON(200, map[string]interface{}{"ok": true, "message": d.NewMessageForWeb(messageSID, message.From, message.To, message.Body)})
	})
	return m
}
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)
}