EvernoteMgr.create_tag() - Code Metrics - foxmask/django-th - Measure and Improve Code Quality continuously with Scrutinizer

EvernoteMgr.create_tag() A
last analyzed 2017-10-09 22:02 UTC

↳ Parent: EvernoteMgr

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	4
c	0
b	0
f	0
dl	0
loc	15
rs	9.2

# coding: utf-8
import evernote.edam.type.ttypes as Types
from evernote.edam.error.ttypes import EDAMSystemException, EDAMUserException
from evernote.edam.error.ttypes import EDAMErrorCode
from evernote.edam.notestore import NoteStore

from django.utils.translation import ugettext as _
from logging import getLogger
from django.core.cache import caches

from django_th.models import update_result

logger = getLogger('django_th.trigger_happy')
cache = caches['django_th']


class EvernoteMgr(object):
    @staticmethod
    def get_notebook(note_store, my_notebook):
        """
            get the notebook from its name
        """
        notebook_id = 0
        notebooks = note_store.listNotebooks()
        # get the notebookGUID ...
        for notebook in notebooks:
            if notebook.name.lower() == my_notebook.lower():
                notebook_id = notebook.guid
                break
        return notebook_id

    @staticmethod
    def set_notebook(note_store, my_notebook, notebook_id):
        """
            create a notebook
        """
        if notebook_id == 0:
            new_notebook = Types.Notebook()
            new_notebook.name = my_notebook
            new_notebook.defaultNotebook = False
            notebook_id = note_store.createNotebook(new_notebook).guid
        return notebook_id

    @staticmethod
    def get_tag(note_store, my_tags):
        """
            get the tags from his Evernote account
            :param note_store Evernote Instance
            :param my_tags string
            :return: array of the tag to create
        """
        tag_id = []
        listtags = note_store.listTags()
        # cut the string by piece of tag with comma
        if ',' in my_tags:
            for my_tag in my_tags.split(','):
                for tag in listtags:
                    # remove space before and after
                    # thus we keep "foo bar"
                    # but not " foo bar" nor "foo bar "
                    if tag.name.lower() == my_tag.lower().lstrip().rstrip():
                        tag_id.append(tag.guid)
                        break
        else:
            for tag in listtags:
                if tag.name.lower() == my_tags.lower():
                    tag_id.append(tag.guid)
                    break

        return tag_id

    @staticmethod
    def set_tag(note_store, my_tags, tag_id):
        """
            create a tag if not exists
            :param note_store evernote instance
            :param my_tags string
            :param tag_id id of the tag(s) to create
            :return: array of the tag to create
        """
        new_tag = Types.Tag()
        if ',' in my_tags:
            for my_tag in my_tags.split(','):
                new_tag.name = my_tag
                note_tag_id = EvernoteMgr.create_tag(note_store, new_tag)
                if note_tag_id is not False:
                    tag_id.append(note_tag_id)
                else:
                    return False
        elif my_tags:
            new_tag.name = my_tags
            note_tag_id = EvernoteMgr.create_tag(note_store, new_tag)
            if note_tag_id is not False:
                tag_id.append(note_tag_id)
            else:
                return False
        return tag_id

    @staticmethod
    def create_note(note_store, note, trigger_id, data):
        """
            create a note
            :param note_store Evernote instance
            :param note
            :param trigger_id id of the trigger
            :param data to save or to put in cache
            :type note_store: Evernote Instance
            :type note: Note instance
            :type trigger_id: int
            :type data: dict
            :return boolean
            :rtype boolean
        """
        # create the note !
        try:
            created_note = note_store.createNote(note)
            sentence = str('note %s created') % created_note.guid
            logger.debug(sentence)
            return True
        except EDAMSystemException as e:
            if e.errorCode == EDAMErrorCode.RATE_LIMIT_REACHED:
                sentence = "Rate limit reached {code} " \
                           "Retry your request in {msg} seconds".format(
                            code=e.errorCode, msg=e.rateLimitDuration)
                logger.warn(sentence)
                # put again in cache the data that could not be
                # published in Evernote yet
                cache.set('th_evernote_' + str(trigger_id), data, version=2)
                update_result(trigger_id, msg=sentence, status=True)
                return True
            else:
                logger.critical(e)
                return False
        except EDAMUserException as e:
            if e.errorCode == EDAMErrorCode.ENML_VALIDATION:
                sentence = "Data ignored due to validation" \
                           " error : err {code} {msg}".format(
                            code=e.errorCode, msg=e.parameter)
                logger.warn(sentence)
                update_result(trigger_id, msg=sentence, status=True)
                return True
        except Exception as e:
            logger.critical(e)
            update_result(trigger_id, msg=e, status=False)
            return False

    @staticmethod
    def create_tag(note_store, new_tag):
        """
            :param note_store Evernote instance
            :param new_tag: create this new tag
            :return: new tag id
        """
        try:
            return note_store.createTag(new_tag).guid
        except EDAMUserException as e:
            if e.errorCode == EDAMErrorCode.DATA_CONFLICT:
                logger.info("Evernote Data Conflict Err {0}".format(e))
            elif e.errorCode == EDAMErrorCode.BAD_DATA_FORMAT:
                logger.critical("Evernote Err {0}".format(e))
            return False

    @staticmethod
    def set_header():
        """
            preparing the hearder of Evernote
        """
        return '<?xml version="1.0" encoding="UTF-8"?>' \
               '<!DOCTYPE en-note SYSTEM ' \
               '"http://xml.evernote.com/pub/enml2.dtd">\n'

    @staticmethod
    def set_note_attribute(data):
        """
           add the link of the 'source' in the note
        """
        na = False
        if data.get('link'):
            na = Types.NoteAttributes()
            # add the url
            na.sourceURL = data.get('link')
            # add the object to the note
        return na

    @staticmethod
    def set_note_footer(data, trigger):
        """
            handle the footer of the note
        """
        footer = ''
        if data.get('link'):
            provided_by = _('Provided by')
            provided_from = _('from')
            footer_from = "<br/><br/>{} <em>{}</em> {} <a href='{}'>{}</a>"

            footer = footer_from.format(
                provided_by, trigger.trigger.description, provided_from,
                data.get('link'), data.get('link'))

        return footer

    @staticmethod
    def set_note_filter(filter_string):
        """
            set the filter of the notes
        """
        my_filter = NoteStore.NoteFilter()
        my_filter.words = filter_string
        return my_filter

    @staticmethod
    def set_evernote_spec():
        spec = NoteStore.NotesMetadataResultSpec()
        spec.includeTitle = True
        spec.includeAttributes = True
        return spec


1			# coding: utf-8
2			import evernote.edam.type.ttypes as Types
3			from evernote.edam.error.ttypes import EDAMSystemException, EDAMUserException
4			from evernote.edam.error.ttypes import EDAMErrorCode
5			from evernote.edam.notestore import NoteStore
6
7			from django.utils.translation import ugettext as _
8			from logging import getLogger
9			from django.core.cache import caches
10
11			from django_th.models import update_result
12
13			logger = getLogger('django_th.trigger_happy')
14			cache = caches['django_th']
15
16
17			class EvernoteMgr(object):
18			@staticmethod
19			def get_notebook(note_store, my_notebook):
20			"""
21			get the notebook from its name
22			"""
23			notebook_id = 0
24			notebooks = note_store.listNotebooks()
25			# get the notebookGUID ...
26			for notebook in notebooks:
27			if notebook.name.lower() == my_notebook.lower():
28			notebook_id = notebook.guid
29			break
30			return notebook_id
31
32			@staticmethod
33			def set_notebook(note_store, my_notebook, notebook_id):
34			"""
35			create a notebook
36			"""
37			if notebook_id == 0:
38			new_notebook = Types.Notebook()
39			new_notebook.name = my_notebook
40			new_notebook.defaultNotebook = False
41			notebook_id = note_store.createNotebook(new_notebook).guid
42			return notebook_id
43
44			@staticmethod
45			def get_tag(note_store, my_tags):
46			"""
47			get the tags from his Evernote account
48			:param note_store Evernote Instance
49			:param my_tags string
50			:return: array of the tag to create
51			"""
52			tag_id = []
53			listtags = note_store.listTags()
54			# cut the string by piece of tag with comma
55			if ',' in my_tags:
56			for my_tag in my_tags.split(','):
57			for tag in listtags:
58			# remove space before and after
59			# thus we keep "foo bar"
60			# but not " foo bar" nor "foo bar "
61			if tag.name.lower() == my_tag.lower().lstrip().rstrip():
62			tag_id.append(tag.guid)
63			break
64			else:
65			for tag in listtags:
66			if tag.name.lower() == my_tags.lower():
67			tag_id.append(tag.guid)
68			break
69
70			return tag_id
71
72			@staticmethod
73			def set_tag(note_store, my_tags, tag_id):
74			"""
75			create a tag if not exists
76			:param note_store evernote instance
77			:param my_tags string
78			:param tag_id id of the tag(s) to create
79			:return: array of the tag to create
80			"""
81			new_tag = Types.Tag()
82			if ',' in my_tags:
83			for my_tag in my_tags.split(','):
84			new_tag.name = my_tag
85			note_tag_id = EvernoteMgr.create_tag(note_store, new_tag)
86			if note_tag_id is not False:
87			tag_id.append(note_tag_id)
88			else:
89			return False
90			elif my_tags:
91			new_tag.name = my_tags
92			note_tag_id = EvernoteMgr.create_tag(note_store, new_tag)
93			if note_tag_id is not False:
94			tag_id.append(note_tag_id)
95			else:
96			return False
97			return tag_id
98
99			@staticmethod
100			def create_note(note_store, note, trigger_id, data):
101			"""
102			create a note
103			:param note_store Evernote instance
104			:param note
105			:param trigger_id id of the trigger
106			:param data to save or to put in cache
107			:type note_store: Evernote Instance
108			:type note: Note instance
109			:type trigger_id: int
110			:type data: dict
111			:return boolean
112			:rtype boolean
113			"""
114			# create the note !
115			try:
116			created_note = note_store.createNote(note)
117			sentence = str('note %s created') % created_note.guid
118			logger.debug(sentence)
119			return True
120			except EDAMSystemException as e:
121			if e.errorCode == EDAMErrorCode.RATE_LIMIT_REACHED:
122			sentence = "Rate limit reached {code} " \
123			"Retry your request in {msg} seconds".format(
124			code=e.errorCode, msg=e.rateLimitDuration)
125			logger.warn(sentence)
126			# put again in cache the data that could not be
127			# published in Evernote yet
128			cache.set('th_evernote_' + str(trigger_id), data, version=2)
129			update_result(trigger_id, msg=sentence, status=True)
130			return True
131			else:
132			logger.critical(e)
133			return False
134			except EDAMUserException as e:
135			if e.errorCode == EDAMErrorCode.ENML_VALIDATION:
136			sentence = "Data ignored due to validation" \
137			" error : err {code} {msg}".format(
138			code=e.errorCode, msg=e.parameter)
139			logger.warn(sentence)
140			update_result(trigger_id, msg=sentence, status=True)
141			return True
142			except Exception as e:
143			logger.critical(e)
144			update_result(trigger_id, msg=e, status=False)
145			return False
146
147			@staticmethod
148			def create_tag(note_store, new_tag):
149			"""
150			:param note_store Evernote instance
151			:param new_tag: create this new tag
152			:return: new tag id
153			"""
154			try:
155			return note_store.createTag(new_tag).guid
156			except EDAMUserException as e:
157			if e.errorCode == EDAMErrorCode.DATA_CONFLICT:
158			logger.info("Evernote Data Conflict Err {0}".format(e))
159			elif e.errorCode == EDAMErrorCode.BAD_DATA_FORMAT:
160			logger.critical("Evernote Err {0}".format(e))
161			return False
162
163			@staticmethod
164			def set_header():
165			"""
166			preparing the hearder of Evernote
167			"""
168			return '<?xml version="1.0" encoding="UTF-8"?>' \
169			'<!DOCTYPE en-note SYSTEM ' \
170			'"http://xml.evernote.com/pub/enml2.dtd">\n'
171
172			@staticmethod
173			def set_note_attribute(data):
174			"""
175			add the link of the 'source' in the note
176			"""
177			na = False
178			if data.get('link'):
179			na = Types.NoteAttributes()
180			# add the url
181			na.sourceURL = data.get('link')
182			# add the object to the note
183			return na
184
185			@staticmethod
186			def set_note_footer(data, trigger):
187			"""
188			handle the footer of the note
189			"""
190			footer = ''
191			if data.get('link'):
192			provided_by = _('Provided by')
193			provided_from = _('from')
194			footer_from = "<br/><br/>{} <em>{}</em> {} <a href='{}'>{}</a>"
195
196			footer = footer_from.format(
197			provided_by, trigger.trigger.description, provided_from,
198			data.get('link'), data.get('link'))
199
200			return footer
201
202			@staticmethod
203			def set_note_filter(filter_string):
204			"""
205			set the filter of the notes
206			"""
207			my_filter = NoteStore.NoteFilter()
208			my_filter.words = filter_string
209			return my_filter
210
211			@staticmethod
212			def set_evernote_spec():
213			spec = NoteStore.NotesMetadataResultSpec()
214			spec.includeTitle = True
215			spec.includeAttributes = True
216			return spec
217

foxmask / django-th

EvernoteMgr.create_tag() A last analyzed 2017-10-09 22:02 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

EvernoteMgr.create_tag() A
last analyzed 2017-10-09 22:02 UTC