SpellIt/FlaskProj/Processing_engine.py at develop · Hun-Spell-It/SpellIt · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
from CouchAPI import CouchAPI

class Processing_engine():

    def __init__(self):
        self.couch = CouchAPI('Administrator', 'password', 'localhost')
        self.lang_name = None
        self.user = None

    def verify_user(self, request_data):

        username = request_data['user']
        password = request_data['pass']

        print(username)

        self.couch.open_bucket('auth')
        result = self.couch.authenticate(username, password)

        if result == True:
            self.user = username

        else:
            print('invalid user')
            return {'Error': 'Unable to authenticate user "'+username+'"'}

        return result

    def store_user(self, request_data):

        username = request_data['user']
        password = request_data['pass']

        bucket = self.couch.open_bucket('auth')

        try:
            bucket.upsert(username, password)
        except:
            raise

    def save_data(self, request_data):

        try:

            words_data = {}
            meta = request_data['meta']
            data = request_data['data']
            username = self.user

            # Creating Key, Value pairs of the data
            for x in data:
                if not x['root_data']:
                    continue
                root_words = filter(None, x['root_data'].split('\n'))
                words_data[x['root_word']] = root_words

            if len(words_data) <= 0:
                return
                # (Key)Language Name : Value ->(Tuple) (Language Dictionary, Language Symbol)
            final_data = {meta['lang_name']: (words_data, meta['lang_symbol'])}

            # Open data bucket and store data
            self.couch.open_bucket('data')

            try:
                user_data = self.couch.retrieve_data(username).value
                user_data[meta['lang_name']] = (words_data, meta['lang_symbol'])
                self.couch.replace_data(username, user_data)
            except:
                self.couch.store_data(username, final_data)

            return True

        except:
            raise

    def retrieve_lang_names(self):

        try:

            username = self.user
            print username
            self.couch.open_bucket('data')
            user_data = self.couch.retrieve_data(username).value
            user_langs = list(user_data.keys())
            return user_langs

        except:
            raise

    def retrieve_lang_data(self, para_name):

        try:


            username = self.user
            self.couch.open_bucket('data')
            self.paradigm_name = para_name['para_name']
            user_data = self.couch.retrieve_data(username).value
            lang_data = user_data[self.lang_name]
            self.paradigm_data = lang_data[self.paradigm_name]
            paradigm_words = list(self.paradigm_data.keys())
            return paradigm_words

        except:
            raise

    def retrieve_word_data(self, word):
        return self.paradigm_data[word]

    def retrieve_paradigm_names(self, lang_name):

        try:

            username = globals()['user']
            self.couch.open_bucket('data')
            lang_name = lang_name['lang']
            self.lang_name = lang_name
            user_data = self.couch.retrieve_data(username).value
            paradigm_data = user_data[lang_name]
            paradigm_names = list(paradigm_data.keys())
            return paradigm_names

        except:
            raise


couchOBJ = CouchAPI('Administrator', 'password', 'localhost')
# user = 'admin'
# e = Processing_engine()
# lang_name = e.retrieve_lang_names()
# print lang_name
# print e.retrieve_lang_data(lang_name[0])[0]