set_evernote_spec() - Code Metrics - Inspection of "coverage and test" - foxmask/django-th - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 07086e...069f57 )

by Fox

created 2016-08-20 11:52 UTC

set_evernote_spec() A

↳ Parent: Project

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	1
c	1
b	0
f	0
dl	0
loc	5
rs	9.4285

# 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 django.utils.log import getLogger
from django.core.cache import caches

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


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


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


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


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
            tag_id.append(create_tag(note_store, new_tag))
    elif my_tags:
        new_tag.name = my_tags
        tag_id.append(create_tag(note_store, new_tag))

    return tag_id


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"
            logger.warn(sentence.format(
                code=e.errorCode,
                msg=e.rateLimitDuration))
            # put again in cache the data that could not be
            # published in Evernote yet
            cache.set('th_evernote_' + str(trigger_id), data, version=2)
            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}"
            logger.warn(sentence.format(
                code=e.errorCode,
                msg=e.parameter))
            return True
    except Exception as e:
        logger.critical(e)
        return False


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))


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'


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


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


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


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

foxmask / django-th

Push — master ( 07086e...069f57 )

set_evernote_spec() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like