Source Code for Module coprs.helpers

 1  import math 
 2  import random 
 3  import string 
 4   
 5  import flask 
 6   
 7  from coprs import constants 
 8   
 9 -def generate_api_token(size=30): 
10      """ Generate a random string used as token to access the API 
11      remotely. 
12   
13      :kwarg: size, the size of the token to generate, defaults to 30 
14          chars. 
15      :return: a string, the API token for the user. 
16      """ 
17      return ''.join(random.choice(string.ascii_lowercase) for x in range(size)) 
18   
19   
20 -class EnumType(type): 
21 -    def __call__(self, attr): 
22          if isinstance(attr, int): 
23              for k, v in self.vals.items(): 
24                  if v == attr: 
25                      return k 
26              raise KeyError('num {0} is not mapped'.format(attr)) 
27          else: 
28              return self.vals[attr] 
29   
30 -class PermissionEnum(object): 
31      __metaclass__ = EnumType 
32      vals = {'nothing': 0, 'request': 1, 'approved': 2} 
33   
34      @classmethod 
35 -    def choices_list(cls, without = -1): 
36          return [(n, k) for k, n in cls.vals.items() if n != without] 
37   
38 -class ActionTypeEnum(object): 
39      __metaclass__ = EnumType 
40      vals = {'delete': 0, 'rename': 1, 'legal-flag': 2} 
41   
42 -class BackendResultEnum(object): 
43      __metaclass__ = EnumType 
44      vals = {'waiting': 0, 'success': 1, 'failure': 2} 
45   
46 -class RoleEnum(object): 
47      __metaclass__ = EnumType 
48      vals = {'user': 0, 'admin': 1} 
49   
50 -class Paginator(object): 
51 -    def __init__(self, query, total_count, page = 1, per_page_override = None, urls_count_override = None): 
52          self.query = query 
53          self.total_count = total_count 
54          self.page = page 
55          self.per_page = per_page_override or constants.ITEMS_PER_PAGE 
56          self.urls_count = urls_count_override or constants.PAGES_URLS_COUNT 
57          self._sliced_query = None 
58   
59 -    def page_slice(self, page): 
60          return (constants.ITEMS_PER_PAGE * (page - 1), constants.ITEMS_PER_PAGE * page) 
61   
62      @property 
63 -    def sliced_query(self): 
64          if not self._sliced_query: 
65              self._sliced_query = self.query[slice(*self.page_slice(self.page))] 
66          return self._sliced_query 
67   
68      @property 
69 -    def pages(self): 
70          return int(math.ceil(self.total_count / float(self.per_page))) 
71   
72 -    def border_url(self, request, start): 
73          if start: 
74              if self.page - 1 > self.urls_count / 2: 
75                  return (self.url_for_other_page(request, 1), 1) 
76          else: 
77              if self.page < self.pages - self.urls_count / 2: 
78                  return (self.url_for_other_page(request, self.pages), self.pages) 
79   
80          return None 
81   
82 -    def get_urls(self, request): 
83          left_border = self.page - self.urls_count / 2 
84          left_border = 1 if left_border < 1 else left_border 
85          right_border = self.page + self.urls_count / 2 
86          right_border = self.pages if right_border > self.pages else right_border 
87   
88          return [(self.url_for_other_page(request, i), i) for i in range(left_border, right_border + 1)] 
89   
90 -    def url_for_other_page(self, request, page): 
91          args = request.view_args.copy() 
92          args['page'] = page 
93          return flask.url_for(request.endpoint, **args) 
94