コード例 #1
0
 def get_slack_token(cls, team_id, user_id=None):
     database = Database()
     database.initialize()
     try:
         slack_token_object = cls.get_token_from_database(team_id=team_id,
                                                          user_id=user_id)
     except TypeError:
         print(
             "Visit http://178.128.234.3:5000/eight_ball/begin_auth to authorize this app"
         )
         raise ValueError("Slack authorization failed")
     if slack_token_object.token_expiry_time is None:
         print(
             "Visit http://178.128.234.3:5000/eight_ball/begin_auth to authorize this app"
         )
         raise ValueError("Slack authorization failed")
     elif int(slack_token_object.token_expiry_time) < int(time.time()):
         hook = cls.get_token_from_database(team_id=team_id,
                                            user_id=user_id)
         auth_response = hook.slack_token_request(hook.auth_code)
         try:
             hook.update_token(auth_response)
         except TypeError:
             hook.add_token(auth_response)
         return SlackClient(str(auth_response['access_token']))
     else:
         return SlackClient(str(slack_token_object.access_token))
コード例 #2
0
 def find_entry(cls, text):
     database = Database()
     database.initialize()
     entry = database.find_one("samples", {"text": text})
     if entry is not None:
         return cls(**entry)
     else:
         return None
コード例 #3
0
    def get_distributors(cls, type):
        database = Database()
        database.initialize()
        distributors = database.find("distributors", {"type": type})
        return [cls(**distributor) for distributor in distributors]



#Distributor.add_distributor(type="slack", slack_channel_id="C0JS385LP")
#Distributor.add_distributor(type="email", email_address="*****@*****.**")
コード例 #4
0
 def get_release_notes(version):
     database = Database()
     database.initialize()
     jira_settings = database.find_one("jira_settings", query={})
     auth_jira = JIRA(basic_auth=(jira_settings['email'], jira_settings['password']),
                      server=jira_settings['server'])
     release_notes = "{} has been deployed to production! Release notes:\n".format(version)
     issues = auth_jira.search_issues("""fixVersion in ("{}")""".format(version))
     for issue in issues:
         release_notes = release_notes + str(issue) + " - " + auth_jira.issue(issue).fields.summary + "\n"
     return release_notes
コード例 #5
0
 def get_latest_release():
     database = Database()
     database.initialize()
     entries = database.find(collection="version_record",
                             query={})
     saved_entries = list()
     times = list()
     for i in entries:
         times.append(i['time'])
         saved_entries.append(i)
     max_time = max(times)
     for i in saved_entries:
         if i['time'] == max_time:
             version = i['version']
             return version
コード例 #6
0
ファイル: facts.py プロジェクト: phillipoliveira/puppy_facts
 def remove_fact(fact_text):
     database = Database()
     database.initialize()
     if database.find_one("facts", {"fact_text": fact_text}) is None:
         raise LookupError('Fact was not found in the database')
     else:
         database.remove("facts", {"fact_text": fact_text})
         print("Fact was successfully removed")
コード例 #7
0
 def remove_distributor(email_address=None, slack_ids=None):
     database = Database()
     database.initialize()
     if database.find_one("distributors", {"email_address": email_address,
                                           "slack_ids": slack_ids}):
         database.remove("distributors", {"email_address": email_address,
                                          "slack_ids": slack_ids})
         return True
コード例 #8
0
class MatchProducts(object):

    database = Database()
    database.initialize()

    def get_products_by_site(self, site_name):
        products = Product.get_products(
            database=self.database,
            collection=site_name,
            query={'site_name': '{0}'.format(site_name)})
        return products

    @staticmethod
    def clean_names(text):
        text = re.sub('[^a-zA-Z0-9]', '', text).lower().replace("\n", "")
        return text

    def check_matches(self, ulta, sephora):
        ulta = self.clean_names(ulta['name'])
        sephora = self.clean_names(sephora['name'])
        result = jellyfish.jaro_distance(ulta, sephora)
        return result

    def format_names(self, site_name):
        clean_products = list()
        products = self.get_products_by_site(site_name=site_name)
        for product in products:
            brand = self.clean_names(product.brand)
            brand = brand.replace(" cosmetics", "")
            item_name = self.clean_names(product.item_name)
            name = brand + " " + item_name
            clean_products.append({
                "name": name,
                "image": product.image,
                "link": product.link,
                "price": product.price
            })
        return clean_products

    def get_matches(self):
        sephora = self.format_names("sephora")
        ulta = self.format_names("ulta")
        for u_product in ulta:
            for s_product in sephora:
                if self.check_matches(s_product, u_product) > 0.95:
                    print("Match! {0}, {1}".format(s_product, u_product))
                    self.database.insert("matches",
                                         data=({
                                             "sephora": s_product,
                                             "ulta": u_product
                                         }))
コード例 #9
0
ファイル: facts.py プロジェクト: phillipoliveira/puppy_facts
 def add_fact(fact_type, fact_text):
     if not any([(fact_type == "puppy_fact"),
                 (fact_type == "cat_fact"),
                 (fact_type == "horse_fact")]):
         print("fact_type must be one of the following: puppy_fact, cat_fact, horse_fact")
     else:
         database = Database()
         database.initialize()
         fact = Facts(fact_type = fact_type, fact_text = fact_text)
         database.insert("facts", fact.json())
         print("Fact successfully added")
コード例 #10
0
 def log_staging_deploy(msg):
     pattern = re.compile("finished deploying branch.* version.* to staging")
     if pattern.findall(msg):
         version = msg.split("branch")[1].split("version")[0].strip()
         database = Database()
         database.initialize()
         database.insert(collection="version_record",
                         data={
                             "version": version,
                             "time": int(time.time())
                         })
コード例 #11
0
 def add_token(self, auth_response):
     database = Database()
     database.initialize()
     self.access_token = auth_response['bot']['bot_access_token']
     self.user_id = auth_response['user_id']
     self.team_id = auth_response['team_id']
     numbers = re.compile('\d+(?:\.\d+)?')
     max_age = int(
         numbers.findall(
             auth_response['headers']['Strict-Transport-Security'])[0])
     self.token_expiry_time = int(time.time()) + max_age
     database.insert(collection="slack_tokens", data=self.json())
コード例 #12
0
ファイル: facts.py プロジェクト: phillipoliveira/puppy_facts
 def migrate_facts():
     dirpath = os.path.dirname(__file__)
     fact_files = {'horse_fact': 'facts/horse_facts.txt',
                   'cat_fact': 'facts/cat_facts.txt',
                   'puppy_fact': 'facts/puppy_facts.txt'}
     database = Database()
     database.initialize()
     for k, v in fact_files.items():
         lines = open(os.path.join(dirpath, v)).read().splitlines()
         for line in lines:
             if line == "":
                 continue
             else:
                 fact = Facts(fact_type=k, fact_text=line)
                 database.insert("facts", fact.json())
コード例 #13
0
 def get_token_from_database(cls, team_id, user_id=None):
     database = Database()
     database.initialize()
     if user_id is not None:
         credentials = database.find_one("slack_tokens",
                                         query=({
                                             "team_id": team_id,
                                             "user_id": user_id
                                         }))
     else:
         credentials = database.find_one("slack_tokens",
                                         query=({
                                             "team_id": team_id
                                         }))
     return cls(**credentials)
コード例 #14
0
 def add_distributor(type, email_address=None, slack_ids=None):
     if "type" == "email":
         if email_address is not None:
             return "Please pass an email address"
     if "type" == "slack":
         if email_address is not None:
             return "Please pass an slack_channel_id"
     elif all([(type != "slack"), (type != "email")]):
         return "Valid 'type's are 'slack' and 'email'"
     else:
         distributor = Distributor(type=type,
                                   email_address=email_address,
                                   slack_ids=slack_ids)
         database = Database()
         database.initialize()
         database.insert("distributors", distributor.json())
コード例 #15
0
 def get_email_credentials(cls, returnless=False):
     database = Database()
     database.initialize()
     emailer_credential_object = database.find_one("emailer_credentials",
                                                   ({}))
     if emailer_credential_object is None:
         email_address = input(
             "Please enter the gmail account address you would like to use to send emails:"
         )
         email_password = input("Please enter your gmail password:"******"Login failed. Please enter your GMAIL address:")
             email_password = input("Please enter your GMAIL password:"******"emailer_credentials",
                         ({
                             "email_address": email_address,
                             "email_password": email_password
                         }))
     else:
         email_address = emailer_credential_object['email_address']
         email_password = emailer_credential_object['email_password']
     if returnless is False:
         return email_address, email_password
コード例 #16
0
 def add_entry(data):
     database = Database()
     database.initialize()
     database.insert("logging", data)
コード例 #17
0
class Sephora(object):

    main_url = "https://www.sephora.com"
    sitemap_url = "/sitemap/departments/"

    database = Database()
    database.initialize()

    webfunctions = WebFunctions()
    session = WebFunctions.get_session()

    def get_department_links(self):
        url = self.main_url + self.sitemap_url
        soup = WebFunctions.make_soup(url=url, session=self.session)
        raw_links = soup.find("div", {
            "class": "Sitemap u-bt u-bw2"
        }).findAll("h2")
        clean_links = set()
        for i in raw_links:
            clean_links.add(i.find("a").get("href"))
        # pprint(clean_links)
        return clean_links

    def get_category_links(self, page_url):
        url = self.main_url + page_url
        soup = WebFunctions.make_soup(url=url, session=self.session)
        raw_category_links = soup.findAll("a",
                                          {"data-at": "top_level_category"})
        clean_category_links = set()
        for i in raw_category_links:
            clean_category_links.add(i.get("href"))
            # print(i.get("href"))
        return clean_category_links

    def get_all_category_links(self):
        departments = self.get_department_links()
        all_category_links = set()
        for department in departments:
            category_links = self.get_category_links(page_url=department)
            all_category_links = all_category_links | category_links
        # pprint(all_category_links)
        return all_category_links

    def get_subcategory_links(self, page_url):
        url = self.main_url + page_url
        soup = WebFunctions.make_soup(url=url, session=self.session)
        raw_subcategory_links = soup.findAll("a", {"data-at": "nth_level"})
        if len(raw_subcategory_links) == 0:
            raw_subcategory_links = soup.findAll("a",
                                                 {"class": "SideNav-link"})
        clean_subcategory_links = set()
        for i in raw_subcategory_links:
            clean_subcategory_links.add(i.get("href"))
            # print(i.get("href"))
        return clean_subcategory_links

    def get_all_subcategory_links(self):
        category_links = self.get_all_category_links()
        all_subcategory_links = set()
        count = 0
        for category in category_links:
            count += 1
            subcategory_links = self.get_subcategory_links(category)
            all_subcategory_links = all_subcategory_links | subcategory_links
            # print(subcategory_links)
            # print(count, len(category_links))
            print("Done {0}/{1}".format(count, len(category_links)))
        return all_subcategory_links

    @classmethod
    def get_pages(cls, soup):
        try:
            num_str = soup.find("span", {"data-at": "number_of_products"}).text
            num_of_products = WebFunctions.only_digits(num_str)
            pages_num = int(math.ceil(num_of_products / 12))
            pages_num += 1
            pages = [int(i) for i in range(1, pages_num)]
            return pages
        except AttributeError:
            return

    def save_product(self, product):
        link = product.find("a").get("href")
        image = product.find("img").get("src")
        site_product_id = product.find("button", {
            "data-comp": "ProductQuicklook"
        }).get("data-sku-number")
        brand = product.find("span", {"data-at": "sku_item_brand"}).text
        item_name = product.find("span", {"data-at": "sku_item_name"}).text
        price = WebFunctions.only_digits(
            product.find("span", {
                "data-at": "sku_item_price_list"
            }).text)
        product = Product(site_name="sephora",
                          link=link,
                          image=image,
                          site_product_id=site_product_id,
                          brand=brand,
                          item_name=item_name,
                          price=price)
        product.add_product(self.database)

    def get_products(self, page_url):
        main_url = self.main_url + page_url
        print(page_url)
        soup = WebFunctions.make_soup(url=main_url, session=self.session)
        pages = self.get_pages(soup)
        if pages is None:
            return
        for page in pages:
            url = main_url + "?pageSize=12" + "&currentPage={0}".format(page)
            print(url)
            soup = WebFunctions.make_soup(url=url, session=self.session)
            products = soup.findAll("div", {"class": "css-12egk0t"})
            for product in products:
                self.save_product(product)
コード例 #18
0
 def get_app_credentials():
     database = Database()
     database.initialize()
     result = database.find_one("slack_credentials", query=({}))
     return result
コード例 #19
0
ファイル: giphy.py プロジェクト: phillipoliveira/release_bot
 def get_token_from_database():
     database = Database()
     database.initialize()
     result = database.find_one("giphy_tokens", query=({}))
     return result['giphy_token']
コード例 #20
0
 def add_entry(self):
     database = Database()
     database.initialize()
     database.insert("message_log", self.json())
コード例 #21
0
 def remove_user(self):
     database = Database()
     database.initialize()
     database.remove("users", {"_id": self._id})
     print("User successfully removed")
コード例 #22
0
 def get_one_user(cls, query=({})):
     database = Database()
     database.initialize()
     user = database.find_one("users", query)
     return cls(**user)
コード例 #23
0
 def get_users(cls, query=({})):
     database = Database()
     database.initialize()
     users = database.find("users", query)
     return [cls(**user) for user in users]
コード例 #24
0
 def onboard_user(self):
     database = Database()
     database.initialize()
     database.insert("users", self.json())
     print("User successfully added")
コード例 #25
0
import re
import os
from commons.config import Config
from commons.validations import Validations
from commons.database import Database
from commons.dns import DNS

def error(message):
    print message
    sys.exit(-1)

if __name__ == "__main__":

    config = Config()
    dns = DNS(config.get("domain").get("dns"))
    db = Database(config.get("database"))
    validations = Validations(db, config.get("domain"))

    parser = argparse.ArgumentParser(description="Manage RED redirections with command-line utility")
    parser.add_argument("action", choices=['add', 'del', 'list', 'check'], help="Action")
    parser.add_argument("domain", help="Domain name", nargs='?')
    parser.add_argument("url", nargs='?', help="Destination URL")
    args = parser.parse_args()

    domain = args.domain
    action = args.action

    if action == 'list':
        for red in db.get_redirections():
            print "%(date_added)s %(domain)s -> %(url)s" % red
    elif action == 'add':
コード例 #26
0
ファイル: facts.py プロジェクト: phillipoliveira/puppy_facts
 def get_facts(cls, query=({})):
     database = Database()
     database.initialize()
     facts = database.find("facts", query)
     return [cls(**fact) for fact in facts]
コード例 #27
0
 def get_entry_by_ts(cls, ts):
     database = Database()
     database.initialize()
     result = database.find_one("message_log", {"trigger_ts": ts})
     if result is not None:
         return cls(**result)
コード例 #28
0
 def add_to_send_count(self):
     database = Database()
     database.initialize()
     self.send_count += 1
     database.update("users", {"_id": self._id}, self.json())
コード例 #29
0
ファイル: giphy.py プロジェクト: phillipoliveira/release_bot
 def get_keyword_from_database():
     database = Database()
     database.initialize()
     result = database.find_one("giphy_keyword", query=({}))
     return result['giphy_keyword']
コード例 #30
0
ファイル: manage.py プロジェクト: universitatjaumei/red
import re
import os
from commons.config import Config
from commons.validations import Validations
from commons.database import Database
from commons.dns import DNS

def error(message):
    print message
    sys.exit(-1)

if __name__ == "__main__":

    config = Config()
    dns = DNS(config.get("domain").get("dns"))
    db = Database(config.get("database"))
    validations = Validations(db, config.get("domain"))

    parser = argparse.ArgumentParser(description="Manage RED redirections with command-line utility")
    parser.add_argument("action", choices=['add', 'del', 'list', 'check'], help="Action")
    parser.add_argument("domain", help="Domain name", nargs='?')
    parser.add_argument("url", nargs='?', help="Destination URL")
    args = parser.parse_args()

    domain = args.domain
    action = args.action

    if action == 'list':
        for red in db.get_redirections():
            print "%(date_added)s %(domain)s -> %(url)s" % red
    elif action == 'add':
コード例 #31
0
 def update_user(self, update):
     database = Database()
     database.initialize()
     database.update("users", {"_id": self._id}, update)
     print("User successfully updated")