def pipedrive_notification(self):
        """Web hook push notification endpoint from Pipedrive subscription(s) when a deal moves.

        https://developers.pipedrive.com/v1#methods-PushNotifications / REST Hooks / Web hooks
        """
        assert self.request.json and "current" in self.request.json and "previous" in self.request.json
        body = self.request.json
        payload = self.generate_payload(body)

        if not self._passes_through_whitelist_blacklist(body['current']):
            return 'OK'

        if self._pipedrive_deal_status_won(body):
            message = rendered_template("pipedrive_won.html", context=payload)
            self.say(message, html=True, color="green")

        elif self._pipedrive_deal_status_lost(body):
            message = rendered_template("pipedrive_lost.html", context=payload)
            self.say(message, html=True, color="red")

        elif self._pipedrive_deal_stage_changed(body):
            message = rendered_template("pipedrive_update.html", context=payload)
            self.say(message, html=True, color="green")

        return 'OK'

 def get_uid(self, message, mention=None):
     if mention !='@all':
         hipchat_user_details  = HipChatMixin().get_hipchat_user(user_id=mention)
         sender_email = hipchat_user_details.get('email')
         context = stats(user_name=sender_email)
         self.say(rendered_template("group_user.html", context), message, html=True)
     else:
         context = group_stats()
         self.say("@all Group Stats",message, notify=True, color='green')
         self.say(rendered_template("group_stats.html", context),message, notify=True,
                  color='green', html=True)

    def search(self, message, module, query):
        self.say("Alright, I'm on it...", message=message)

        accounts_words = ['accounts', 'businesses', 'companies']
        contacts_words = ['contacts', 'people']
        module = lower(module)
        last_name = None

        if module in accounts_words:
            module = 'Accounts'
            return_fields = ['Account Name', 'Phone', 'Company Site']

        elif module in contacts_words:
            module = 'Contacts'
            return_fields = ['First Name', 'Last Name', 'Phone', 'Email']

            if len(split(query, ' ')) > 1:
                first_name = get_first_name(query)
                last_name = get_last_name(query)
                query = first_name

        else:
            self.say("I don't know of any '%s' module in Zoho" % module, message=message)
            return None

        record_ids = self.get_search_records(module, return_fields, query)

        results = []
        for record_id in record_ids:
            record = self.get_record_by_id(record_id, module, return_fields)

            record_fields = []
            ignore_fields = ['ACCOUNTID', 'CONTACTID']
            skip_record = False

            for field in record:
                for field_label in field:

                    if field_label not in ignore_fields:
                        field_value = field[field_label]
                        record_fields.append(field_value)

                        if field_label == 'Last Name' and last_name is not None:
                            if not lower(last_name) in lower(field_value):
                                skip_record = True

            if not skip_record:
                result = join(record_fields, ', ')
                results.append(result)

        results_context = {
            'results': results,
            'module': module,
            'query': query,
            'count': len(results)
        }
        results_html = rendered_template("zoho_search_results.html", results_context)
        self.say(results_html, html=True, message=message)

        return results_context

 def google_poem(self, message, topic):
     """make a poem about __: show a google poem about __"""
     r = requests.get("http://www.google.com/complete/search?output=toolbar&q=" + topic + "%20")
     xmldoc = minidom.parseString(r.text)
     item_list = xmldoc.getElementsByTagName("suggestion")
     context = {"topic": topic, "lines": [x.attributes["data"].value for x in item_list[:4]]}
     self.say(rendered_template("gpoem.html", context), message, html=True)

    def hear_dkcwd_team_timezones(self, message):

        context = {
            "date": time.strftime('%Y%m%d')
        }

        self.say(rendered_template("dkcwd_team_timezone_times.html", context), message=message, html=True, notify=True)

    def packt_book_of_the_day_new_available(self):

        context = {
            "book": self.get_packt_book_of_the_day_name()
        }

        self.say(rendered_template("dkcwd_packt_book_of_the_day_new_available.html", context), html=True, notify=True)

    def packt_book_of_the_day_almost_over(self):

        context = {
            "book": self.get_packt_book_of_the_day_name()
        }

        self.say(rendered_template("dkcwd_packt_book_of_the_day_almost_over.html", context), html=True, notify=True)

    def hear_packt_book_of_the_day(self, message):

        context = {
            "book": self.get_packt_book_of_the_day_name()
        }

        self.say(rendered_template("dkcwd_packt_book_of_the_day.html", context), message=message, html=True, notify=True)

 def available_branches(self, message):
     """list deployable branches: list all the branches that can be deployed"""
     print "available_branches"
     repos = self.get_github_deployable_repos()
     context = {"repos": repos}
     branches_html = rendered_template("available_branches.html", context)
     self.say(branches_html, message=message, html=True)

 def list_rooms(self, message):
     """what are the rooms?: List all the rooms I know about."""
     if len(self.available_rooms.keys()) >= 100:
         context = {"rooms": self.available_rooms.values()[0:100]}
     else:
         context = {"rooms": self.available_rooms.values(), }
     self.say(rendered_template("rooms.html", context), message=message, html=True)

 def respond_to_contact_info(self, message):
     contacts = self.load("contact_info", {})
     context = {
         "contacts": contacts,
     }
     contact_html = rendered_template("contact_info.html", context)
     self.say(contact_html)

 def remind_staging_servers(self):
     context = {
         "stacks": self.stacks,
         "no_stacks": self.stacks == {}
     }
     servers_html = rendered_template("active_staging_server_reminder.html", context)
     self.say(servers_html, html=True)

    def render_lp(self, bug):

        bug_info = {
            'link': bug.web_link,
            'title': bug.title,
            'milestones': []
        }

        for task in bug.bug_tasks:

            task_info = {
                'status': 'Unknown',
                'assignee': 'None',
                'title': 'None'
            }
            try:
                (task_info['status'], ) = task.status
            except Exception:
                pass
            try:
                task_info['assignee'] = task.assignee.name
            except Exception:
                pass
            try:
                task_info['title'] = task.target.name
            except Exception:
                pass
            bug_info['milestones'].append(task_info)

        return rendered_template("lp_bug.html", bug_info)

 def group_users(self, message):
     response = requests.get(
         settings.FIT_BOT_URL + 'get_group_users/1/')
     data = response.json()
     userlist = data.get('userlist', '')
     context = {"userlist": userlist}
     self.say(rendered_template("group_users.html", context), message, html=True)

    def hear_dkcwd_team_escalation_process(self, message):

        context = {
            "link": 'some web address',
            "text": 'Here is the link to the escalation process'
        }

        self.say(rendered_template("dkcwd_generic_team_link.html", context), message=message, html=True, notify=True)

    def tutor_application(self):
        assert self.request.json and "user_name" in self.request.json
        payload = self.request.json
        message = rendered_template("tutor_application.html", context=payload)
        color = "green"
        self.say(message, color=color)

        return "OK"

    def event_added(self):
        assert self.request.json and "event_name" in self.request.json
        payload = self.request.json
        message = rendered_template("event_added.html", context=payload)
        color = "green"
        self.say(message, color=color)

        return "OK"

    def hear_dkcwd_mom_number(self, message):

        context = {
            "link": 'https://www.youtube.com/watch?v=AhYP7HSKiGc',
            "text": 'Here is the only link you need'
        }

        self.say(rendered_template("dkcwd_generic_team_link.html", context), message=message, html=True, notify=True)

 def respond_to_contact_info(self, message):
     """contact info: Show everyone's emergency contact info."""
     contacts = self.load("contact_info", {})
     context = {
         "contacts": contacts,
     }
     contact_html = rendered_template("contact_info.html", context)
     self.say(contact_html, message=message)

 def seriously_remind_staging_servers(self):
     if self.stacks != {}:
         context = {
             "stacks": self.stacks,
             "no_stacks": self.stacks == {}
         }
         servers_html = rendered_template("active_staging_server_reminder.html", context)
         self.say(servers_html, html=True, color="red")