Source Code for Module coprs.forms

  1  import re 
  2  import urlparse 
  3   
  4  import flask 
  5   
  6  from flask.ext import wtf 
  7   
  8  from coprs import constants 
  9  from coprs import helpers 
 10  from coprs import models 
 11  from coprs.logic import coprs_logic 
 12   
 13 -class UrlListValidator(object): 
 14 -    def __init__(self, message = None): 
 15          if not message: 
 16              message = 'A list of URLs separated by whitespace characters is needed ("{0}" doesn\'t seem to be a URL).' 
 17          self.message = message 
 18   
 19 -    def __call__(self, form, field): 
 20          urls = field.data.split() 
 21          for u in urls: 
 22              if not self.is_url(u): 
 23                  raise wtf.ValidationError(self.message.format(u)) 
 24   
 25 -    def is_url(self, url): 
 26          parsed = urlparse.urlparse(url) 
 27          is_url = True 
 28   
 29          if not parsed.scheme.startswith('http'): 
 30              is_url = False 
 31          if not parsed.netloc: 
 32              is_url = False 
 33   
 34          return is_url 
 35   
 36   
 37 -class CoprUniqueNameValidator(object): 
 38 -    def __init__(self, message = None): 
 39          if not message: 
 40              message = 'You already have copr named "{0}".' 
 41          self.message = message 
 42   
 43 -    def __call__(self, form, field): 
 44          existing = coprs_logic.CoprsLogic.exists_for_user(flask.g.user, field.data).first() 
 45   
 46          if existing and str(existing.id) != form.id.data: 
 47              raise wtf.ValidationError(self.message.format(field.data)) 
 48   
 49   
 50 -class StringListFilter(object): 
 51 -    def __call__(self, value): 
 52          if not value: 
 53              return '' 
 54          # Replace every whitespace string with one newline 
 55          # Formats ideally for html form filling, use replace('\n', ' ') 
 56          # to get space-separated values or split() to get list 
 57          result = value.strip() 
 58          regex = re.compile(r'\s+') 
 59          return regex.sub(lambda x: '\n', result) 
 60   
 61 -class ValueToPermissionNumberFilter(object): 
 62 -    def __call__(self, value): 
 63          if value: 
 64              return helpers.PermissionEnum('request') 
 65          return helpers.PermissionEnum('nothing') 
 66   
 67 -class CoprFormFactory(object): 
 68      @staticmethod 
 69 -    def create_form_cls(mock_chroots=None): 
 70          class F(wtf.Form): 
 71              # also use id here, to be able to find out whether user is updating a copr 
 72              # if so, we don't want to shout that name already exists 
 73              id = wtf.HiddenField() 
 74              name = wtf.TextField('Name', 
 75                                   validators = [wtf.Required(), 
 76                                   wtf.Regexp(re.compile(r'^[\w.-]+$'), message='Name must contain only letters, digits, underscores, dashes and dots.'), 
 77                                   CoprUniqueNameValidator()]) 
 78              description = wtf.TextAreaField('Description') 
 79              instructions = wtf.TextAreaField('Instructions') 
 80              repos = wtf.TextAreaField('Repos', 
 81                                        validators = [UrlListValidator()], 
 82                                        filters = [StringListFilter()]) 
 83              initial_pkgs = wtf.TextAreaField('Initial packages to build', 
 84                                               validators = [UrlListValidator()], 
 85                                               filters = [StringListFilter()]) 
 86   
 87              @property 
 88              def selected_chroots(self): 
 89                  selected = [] 
 90                  for ch in self.chroots_list: 
 91                      if getattr(self, ch).data: 
 92                          selected.append(ch) 
 93                  return selected 
 94   
 95              def validate(self): 
 96                  if not super(F, self).validate(): 
 97                      return False 
 98   
 99                  if not self.validate_mock_chroots_not_empty(): 
100                      self._mock_chroots_error = 'At least one chroot must be selected' 
101                      return False 
102                  return True 
103   
104              def validate_mock_chroots_not_empty(self): 
105                  have_any = False 
106                  for c in self.chroots_list: 
107                      if getattr(self, c).data: 
108                          have_any = True 
109                  return have_any 
110   
111          F.chroots_list = map(lambda x: x.chroot_name, models.MockChroot.query.filter(models.MockChroot.is_active==True).all()) 
112          F.chroots_list.sort() 
113          F.chroots_sets = {} # sets of chroots according to how we should print them in columns 
114          for ch in F.chroots_list: 
115              checkbox_default = False 
116              if mock_chroots and ch in map(lambda x:x.chroot_name, mock_chroots): 
117                  checkbox_default = True 
118              setattr(F, ch, wtf.BooleanField(ch, default=checkbox_default)) 
119              if ch[0] in F.chroots_sets: 
120                  F.chroots_sets[ch[0]].append(ch) 
121              else: 
122                  F.chroots_sets[ch[0]] = [ch] 
123   
124          return F 
125   
126 -class CoprDeleteForm(wtf.Form): 
127      verify = wtf.TextField('Confirm deleting by typing "yes"', 
128                             validators=[wtf.Required(), wtf.Regexp(r'^yes$', message='Type "yes" - without the quotes, lowercase.')]) 
129   
130 -class BuildForm(wtf.Form): 
131      pkgs = wtf.TextAreaField('Pkgs', 
132                               validators = [wtf.Required(), UrlListValidator()], 
133                               filters = [StringListFilter()]) 
134      memory_reqs = wtf.IntegerField('Memory requirements', 
135                                     validators = [wtf.NumberRange(min = constants.MIN_BUILD_MEMORY, max = constants.MAX_BUILD_MEMORY)], 
136                                     default = constants.DEFAULT_BUILD_MEMORY) 
137      timeout = wtf.IntegerField('Timeout', 
138                                 validators = [wtf.NumberRange(min = constants.MIN_BUILD_TIMEOUT, max = constants.MAX_BUILD_TIMEOUT)], 
139                                 default = constants.DEFAULT_BUILD_TIMEOUT) 
140   
141 -class CoprLegalFlagForm(wtf.Form): 
142      comment = wtf.TextAreaField('Comment') 
143   
144 -class PermissionsApplierFormFactory(object): 
145      @staticmethod 
146 -    def create_form_cls(permission = None): 
147          class F(wtf.Form): 
148              pass 
149   
150          builder_default = False 
151          admin_default = False 
152   
153          if permission: 
154              if permission.copr_builder != helpers.PermissionEnum('nothing'): 
155                  builder_default = True 
156              if permission.copr_admin != helpers.PermissionEnum('nothing'): 
157                  admin_default = True 
158   
159          setattr(F, 'copr_builder', wtf.BooleanField(default = builder_default, filters = [ValueToPermissionNumberFilter()])) 
160          setattr(F, 'copr_admin', wtf.BooleanField(default = admin_default, filters = [ValueToPermissionNumberFilter()])) 
161   
162          return F 
163   
164   
165 -class PermissionsFormFactory(object): 
166      """Creates a dynamic form for given set of copr permissions""" 
167      @staticmethod 
168 -    def create_form_cls(permissions): 
169          class F(wtf.Form): 
170              pass 
171   
172          for perm in permissions: 
173              builder_choices = helpers.PermissionEnum.choices_list() 
174              admin_choices = helpers.PermissionEnum.choices_list() 
175   
176              builder_default = perm.copr_builder 
177              admin_default = perm.copr_admin 
178   
179              setattr(F, 'copr_builder_{0}'.format(perm.user.id), wtf.SelectField(choices = builder_choices, default = builder_default, coerce = int)) 
180              setattr(F, 'copr_admin_{0}'.format(perm.user.id), wtf.SelectField(choices = admin_choices, default = admin_default, coerce = int)) 
181   
182          return F 
183