Exemple #1
0
    def create_new_profile(self):
        profile_name = None
        profile_faction = None

        layout = self.get_profile_layout(new=True)

        window = sg.Window("New profile", layout=layout, force_toplevel=True, modal=True)
        window.Finalize()

        while True:
            event, values = window.read()
            if event == "save":
                profile_name = values["name"]
                self.user_profile = UserProfile(profile_name, profile_faction)
                if not self.user_profile.save(values):
                    overwrite = sg.popup_ok_cancel("Profile name already exists. Overwirte?")
                    if overwrite == 'OK':
                        self.user_profile.overwrite()
                        break
                else:
                    break
            elif event == "faction":
                profile_faction = values["faction"]
            elif event in {sg.WIN_CLOSED, "Cancel"}:
                window.close()
                return

            if values and values["name"] and profile_faction:
                window["save"].Update(disabled=False)
            elif values and not values["name"]:
                window["save"].Update(disabled=True)
        window.close()
        return copy.deepcopy(self.user_profile)
Exemple #2
0
 def insertProfile(self, profile):
     info = self.splitProfile(profile)
     print(type(info))
     import hashlib
     profile = UserProfile(username=info['username'],
                           password=hashlib.sha224(
                               str.encode(info['password'])).hexdigest(),
                           categories=info['categories'],
                           sources=info['sources'])
     profile = profile.getUserProfile()
     id = self.dbOperation.dbInsert(profile, 'profiles')
     print('OK:', id)
     return str(id)
Exemple #3
0
def get_serialized_point_ranks():
    points = UserPoints.query().order(-UserPoints.all_time_total).fetch(10)
    user = users.get_current_user()
    user_id = "nope"
    if (user is not None):
        user_id = user.user_id()

    ranks = []
    for point in points:
        profile = UserProfile.get_or_insert(point.user_id,
                                            user_id=point.user_id)

        result = {
            "p": point.all_time_total,
            "n": profile.sanitized_visible_name()
        }
        if (user_id == point.user_id):
            result["s"] = True

        ranks.append(result)

    return json.dumps({
        "error": False,
        "ranks": ranks,
        "startRank": 1
    })
    def setUp(self):
        with open("profile_example.json") as json_file:
            self._profiles_json = json.load(json_file)

        self._profiles = [
            UserProfile(data) for data in self._profiles_json.values()
        ]
Exemple #5
0
    def retrieve_user_profiles(self, user_profile_url):
        raw_html = download_url(user_profile_url)
        profile_soup = BeautifulSoup.BeautifulSoup(raw_html, convertEntities=BeautifulSoup.BeautifulSoup.HTML_ENTITIES)
        user_profile = UserProfile(profile_soup, user_profile_url)

        for friend in user_profile.friends:
            self.urls_queue.put(friend.friend_url, block=False)

        return user_profile
Exemple #6
0
    def test_a_check_post(self):

        url = self.login_and_post()

        title_article = (self.post['title'])
        body_Article = (self.post['body'])

        check = CheckPost(self.driver)
        title, body = check.check_post(url)

        self.assertEqual(title_article, title)
        self.assertEqual(body_Article, body)

        profile = UserProfile(self.driver)
        last_published_article = profile.user_profile_post()

        self.assertEqual(title_article, last_published_article)
        add = AddComment(self.driver, self.comment)
        comment_add = add.add_comment()
        self.assertEqual(self.comment, comment_add)
Exemple #7
0
 def __init__(self, user_profile):
     self.prepared_data = dict()
     self.url = None
     self.method = 'GET'
     self.headers = {}
     self.profile = UserProfile(**user_profile)
     self.logger = logging.getLogger(__name__)
     self.response = ResponseHandler({
         "success": False,
         "ok": False,
         "content": ''
     })
Exemple #8
0
 def handle_message(self, message):
     if not self.p2p_state == 'UNREGISTERED':
         self.mob.get_user_by_id(self.id).update_nickname(message['from'])
     text = message['text']
     if self.p2p_state == 'AWAIT_PROMISE':
         if not self.promise_exists():
             self.mob.get_user_by_id(self.id).add_promise(
                 date.today().toordinal(), text)
             self.p2p_state = 'IDLE'
             return words.promise_accept, words.menu,
         else:
             self.p2p_state = 'IDLE'
             return words.promise_decline.format(
                 self.mob.get_user_by_id(self.id).promises[
                     date.today().toordinal()]), words.menu
     if self.p2p_state == 'AWAIT_STATUS':
         if self.get_status() in {-1, 2, 3}:
             self.p2p_state = 'IDLE'
             return words.status_decline, words.menu,
         if text.lower().replace(' ', '') == 'да':
             self.set_status(3)
             self.p2p_state = 'IDLE'
             return words.status_success, words.menu,
         if text.lower().replace(' ', '') == 'нет':
             self.set_status(2)
             self.p2p_state = 'IDLE'
             return words.status_fail, words.menu,
         return words.status_unknown, words.status_listen,
     if self.p2p_state == 'UNREGISTERED':
         if text.lower().replace(' ', '') == '/participate':
             self.p2p_state = 'IDLE'
             if not self.mob.user_id_present(id):
                 self.mob.users.append(UserProfile(self.id))
             return words.registered, words.menu,
         return words.greet,
     if self.p2p_state == 'IDLE':
         if text == '/stats':
             return self.mob.get_user_by_id(self.id).stats_str(),
         if text == '/promise':
             if not self.promise_exists():
                 self.p2p_state = 'AWAIT_PROMISE'
                 return words.promise_listen,
             return words.promise_decline.format(
                 self.mob.get_user_by_id(self.id).promises[
                     date.today().toordinal()]['text']), words.menu
         if text == '/complete':
             if not self.promise_exists():
                 return words.no_promise,
             if self.get_status() in {0, 1}:
                 self.set_status(3)
                 return words.status_success, words.menu,
             return words.status_decline, words.menu,
         return words.menu,
Exemple #9
0
def set_user_name():
    try:
        new_name = request.forms.get('name')
        if (new_name is None):
            return {"error": True,
                    "errorMessage": "'new_name' param must be set."}

        if (len(new_name) < min_visible_name_length):
            return {
                "error": True,
                "errorMessage": "Name can't be less than " +
                str(min_visible_name_length) +
                " characters."}

        if (len(new_name) > max_visible_name_length):
            return {
                "error": True,
                "errorMessage": "Name can't be more than " +
                str(max_visible_name_length) +
                " characters."}

        if (not visible_name_pattern.match(new_name)):
            return {"error": True,
                    "errorMessage": "Name must be alphanumeric."}

        user = users.get_current_user()
        id_to_change = str(user.user_id())

        # if we're an admin, allow changing anyone's name with the right id
        if (user and users.is_current_user_admin()
                and request.forms.get('id') is not None):
            id_to_change = request.forms.get('id')

        # get profile and set new name
        profile = UserProfile.get_or_insert(id_to_change,
                                            user_id=id_to_change,
                                            visible_name=new_name)
        profile.visible_name = new_name
        profile.put()

        return {"error": False
                }
    except Exception as e:
        return process_exception(e)
Exemple #10
0
    def __init__(self, user_profile):
        """Initialization method for Delhivery base class, which sets
        credentials for using Delhivery API

        Args:
            user_profile - This will be the dictionary containing
            client name and api token.
        """
        self.prepared_data = None
        self.url = None
        self.method = 'GET'
        self.headers = {}
        self.profile = UserProfile(**user_profile)
        self.logger = logging.getLogger(__name__)
        self.response = ResponseHandler({
            "success": False,
            "ok": False,
            "content": ''
        })
    def test_username(self):
        test_data = [(UserProfile(data), data["username"])
                     for data in self._profiles_json.values()]

        for profile, username in test_data:
            self.assertEqual(profile.get_username(), username)
Exemple #12
0
 def __init__(self):
     self.default_user = UserProfile()
     self.user_profile = UserProfile()
Exemple #13
0
class GUIUserProfile():
    def __init__(self):
        self.default_user = UserProfile()
        self.user_profile = UserProfile()

    def create_new_profile(self):
        profile_name = None
        profile_faction = None

        layout = self.get_profile_layout(new=True)

        window = sg.Window("New profile", layout=layout, force_toplevel=True, modal=True)
        window.Finalize()

        while True:
            event, values = window.read()
            if event == "save":
                profile_name = values["name"]
                self.user_profile = UserProfile(profile_name, profile_faction)
                if not self.user_profile.save(values):
                    overwrite = sg.popup_ok_cancel("Profile name already exists. Overwirte?")
                    if overwrite == 'OK':
                        self.user_profile.overwrite()
                        break
                else:
                    break
            elif event == "faction":
                profile_faction = values["faction"]
            elif event in {sg.WIN_CLOSED, "Cancel"}:
                window.close()
                return

            if values and values["name"] and profile_faction:
                window["save"].Update(disabled=False)
            elif values and not values["name"]:
                window["save"].Update(disabled=True)
        window.close()
        return copy.deepcopy(self.user_profile)

    def edit_user_profile(self, user_profile):
        profile_name = user_profile.profile_name
        profile_faction = user_profile.profile_faction

        if profile_name:
            self.user_profile = user_profile
            layout = self.get_profile_layout()

            window = sg.Window("New profile", layout=layout, force_toplevel=True, modal=True)
            window.Finalize()
            window["save"].Update(disabled=False)
            window["name"].Update(profile_name, disabled=True)
            window["faction"].Update(profile_faction, disabled=True)

            while True:
                event, values = window.read()
                if event == "save":
                    if not self.user_profile.save(values):
                        overwrite = sg.popup_ok_cancel("Save changes?")
                        if overwrite == 'OK':
                            self.user_profile.overwrite()
                    else:
                        break
                elif event in {sg.WIN_CLOSED, "Cancel"}:
                    window.close()
                    return
            window.close()
            return copy.deepcopy(self.user_profile)
        else:
            return self.create_new_profile()

    def load_user_profile(self):
        layout = self.get_load_layout()

        window = sg.Window("Load profile", layout=layout, force_toplevel=True, modal=True)
        window.Finalize()

        while True:
            event, values = window.read()
            if event == "load":
                profile_name = values["listbox"][0]
                self.user_profile.load(profile_name)
                break
            elif event in {sg.WIN_CLOSED, "Cancel"}:
                window.close()
                return
        window.close()
        return copy.deepcopy(self.user_profile)

    def get_skills_layout(self, new=False):
        if new:
            skill_levels = self.default_user.get_skills_data()
        else:
            skill_levels = self.user_profile.get_skills_data()
        skills_data = self.default_user.get_full_skills_data()
        layout = []
        for skill_group in skills_data:
            skill_types = skills_data[skill_group]
            skill_types_layout = []
            skill_group_layout = []
            for skill_type in skill_types:
                skill_names = skill_types[skill_type]
                skill_names_layout = [[sg.Text(skill_name, size=(50, 1))] + [sg.Combo([0, 1, 2, 3, 4, 5], key=skill_name, size=(10, 1), default_value=skill_levels[skill_name])] for skill_name in skill_names]
                skill_types_layout.append(sg.Tab(skill_type, layout=skill_names_layout))
            skill_group_layout.append(sg.TabGroup([skill_types_layout]))
            layout.append(sg.Tab(skill_group, [skill_group_layout]))
        return [sg.TabGroup([layout])]

    def get_profile_layout(self, new=False):
        name_layout = [sg.Text('Name: ', size=(8, 1))] + [sg.InputText("", key="name", enable_events=True, size=(20, 1))]
        factions_layout = [sg.Text('Faction: ', size=(8, 1))] + [sg.Combo(FACTIONS, key="faction", enable_events=True, size=(20, 1))]

        save_button = sg.Button("Save", key="save", disabled=True)
        cancel_button = sg.Cancel()
        buttons_layout = [save_button] + [cancel_button]
        skills_layout = self.get_skills_layout(new=new)
        layout = [
            name_layout,
            factions_layout,
            skills_layout,
            buttons_layout,
        ]
        return layout

    def get_load_layout(self):
        available_profiles = glob("saved_profiles/*.yaml")

        available_profiles_list = [profile.replace("\\", "/").split("/")[-1].split(".")[0] for profile in available_profiles]

        load_button = sg.Button("Load", key="load")
        cancel_button = sg.Cancel()

        available_profiles_layout = [
            [sg.Listbox(available_profiles_list, enable_events=True, default_values=available_profiles_list[0], select_mode="single", key="listbox", size=(25, 10))],
            [load_button] + [cancel_button]
        ]

        return available_profiles_layout