patchwork/patchwork/forms.py at main · getpatchwork/patchwork · GitHub

History

255 lines (207 loc) · 7.74 KB

Raw

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

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

# Patchwork - automated patch tracking system

# SPDX-License-Identifier: GPL-2.0-or-later

from django.contrib.auth.models import User

from django import forms

from django.forms import renderers

from django.db.models import Q

from django.db.utils import ProgrammingError

from django.template.backends import django as django_template_backend

from patchwork.models import Bundle

from patchwork.models import Patch

from patchwork.models import State

from patchwork.models import UserProfile

class PatchworkTableRenderer(renderers.EngineMixin, renderers.BaseRenderer):

backend = django_template_backend.DjangoTemplates

form_template_name = 'django/forms/table.html'

formset_template_name = 'django/forms/formsets/table.html'

class RegistrationForm(forms.Form):

first_name = forms.CharField(max_length=30, required=False)

last_name = forms.CharField(max_length=30, required=False)

username = forms.RegexField(

regex=r'^\w+$',

max_length=30,

label='Username',

)

email = forms.EmailField(max_length=100, label='Email address')

password = forms.CharField(widget=forms.PasswordInput(), label='Password')

def clean_username(self):

value = self.cleaned_data['username']

try:

User.objects.get(username__iexact=value)

except User.DoesNotExist:

return self.cleaned_data['username']

raise forms.ValidationError(

'This username is already taken. Please choose another.'

)

def clean_email(self):

value = self.cleaned_data['email']

try:

user = User.objects.get(email__iexact=value)

except User.DoesNotExist:

return self.cleaned_data['email']

raise forms.ValidationError(

'This email address is already in use '

'for the account "%s".\n' % user.username

)

def clean(self):

return self.cleaned_data

class BundleForm(forms.ModelForm):

name = forms.RegexField(

regex=r'^[^/]+$',

min_length=1,

max_length=50,

required=False,

error_messages={'invalid': "Bundle names can't contain slashes"},

widget=forms.TextInput(

attrs={'class': 'create-bundle', 'placeholder': 'Bundle name'}

)

class Meta:

model = Bundle

fields = ['name', 'public']

class CreateBundleForm(BundleForm):

def clean_name(self):

name = self.cleaned_data['name']

if not name:

raise forms.ValidationError(

'No bundle name was specified', code='invalid'

)

count = Bundle.objects.filter(

owner=self.instance.owner, name=name

).count()

if count > 0:

raise forms.ValidationError(

'A bundle called %(name)s already exists',

code='invalid',

params={'name': name},

)

return name

class Meta:

model = Bundle

fields = ['name']

class DeleteBundleForm(forms.Form):

name = 'deletebundleform'

form_name = forms.CharField(initial=name, widget=forms.HiddenInput)

bundle_id = forms.IntegerField(widget=forms.HiddenInput)

class EmailForm(forms.Form):

email = forms.EmailField(max_length=200)

class UserProfileForm(forms.ModelForm):

class Meta:

model = UserProfile

fields = ['items_per_page', 'show_ids']

labels = {'show_ids': 'Show Patch IDs:'}

def _get_delegate_qs(project, instance=None):

if instance and not project:

project = instance.project

if not project:

raise ValueError('Expected a project')

q = Q(

profile__in=UserProfile.objects.filter(maintainer_projects=project)

.values('pk')

.query

)

if instance and instance.delegate:

q = q | Q(username=instance.delegate)

return User.objects.complex_filter(q)

class PatchForm(forms.ModelForm):

def __init__(self, instance=None, project=None, *args, **kwargs):

super(PatchForm, self).__init__(instance=instance, *args, **kwargs)

self.fields['delegate'] = forms.ModelChoiceField(

queryset=_get_delegate_qs(project, instance),

widget=forms.Select(attrs={'class': 'change-property-delegate'}),

required=False,

)

class Meta:

model = Patch

fields = ['state', 'archived', 'delegate']

widgets = {

'state': forms.Select(attrs={'class': 'change-property-state'}),

'archived': forms.CheckboxInput(

attrs={'class': 'archive-patch-check'}

}

class OptionalModelChoiceField(forms.ModelChoiceField):

no_change_choice = ('*', 'No change')

to_field_name = None

def __init__(self, *args, placeholder, className, **kwargs):

self.no_change_choice = ('*', placeholder)

self.widget = forms.Select(attrs={'class': className})

super(OptionalModelChoiceField, self).__init__(

initial=self.no_change_choice[0], *args, **kwargs

)

def _get_choices(self):

# _get_choices queries the database, which can fail if the db

# hasn't been initialised yet. catch that and give an empty

# set of choices for now.

try:

choices = list(

super(OptionalModelChoiceField, self)._get_choices()

)

except ProgrammingError:

choices = []

choices.append(self.no_change_choice)

return choices

choices = property(_get_choices, forms.ChoiceField.choices.fset)

def is_no_change(self, value):

return value == self.no_change_choice[0]

def clean(self, value):

if value == self.no_change_choice[0]:

return value

return super(OptionalModelChoiceField, self).clean(value)

class OptionalBooleanField(forms.TypedChoiceField):

def __init__(self, className, *args, **kwargs):

self.widget = forms.Select(attrs={'class': className})

super(OptionalBooleanField, self).__init__(*args, **kwargs)

def is_no_change(self, value):

return value == self.empty_value

class MultiplePatchForm(forms.Form):

action = 'update'

archived = OptionalBooleanField(

className='archive-patch-select',

choices=[

('*', 'No change'),

('True', 'Archive'),

('False', 'Unarchive'),

coerce=lambda x: x == 'True',

empty_value='*',

label='Archived',

)

def __init__(self, project, *args, **kwargs):

super(MultiplePatchForm, self).__init__(*args, **kwargs)

self.fields['delegate'] = OptionalModelChoiceField(

queryset=_get_delegate_qs(project=project),

placeholder='Delegate to',

className='change-property-delegate',

label='Delegate to',

required=False,

)

self.fields['state'] = OptionalModelChoiceField(

queryset=State.objects.all(),

placeholder='Change state',

className='change-property-state',

label='Change state',

)

def save(self, instance, commit=True):

opts = instance.__class__._meta

if self.errors:

raise ValueError(

'The %s could not be changed because the data '

"didn't validate." % opts.object_name

)

data = self.cleaned_data

# Update the instance

for f in opts.fields:

if f.name not in data:

continue

field = self.fields.get(f.name, None)

if not field:

continue

if field.is_no_change(data[f.name]):

continue

setattr(instance, f.name, data[f.name])

if commit:

instance.save()

return instance

patchwork/patchwork/forms.py at main · getpatchwork/patchwork · GitHub

Uh oh!

Expand file tree

Breadcrumbs

forms.py

Latest commit

History

Breadcrumbs

forms.py

File metadata and controls