class CommonWizard(TemplateView):
step_list = None
template_dir = None
wizard_name = None
done_step = 'done'
url_name = None
def __init__(self,*args,**kwargs):
super(CommonWizard,self).__init__(*args,**kwargs)
self.request = None
self.instance = None
self.is_ajax = False
self.args = ()
self.kwargs = {}
form_list = OrderedDict()
step_labels = OrderedDict()
self.extra_context = {}
last = None
for step in self.step_list:
if not isinstance(step,(tuple,list)):
step = [step]
name = step[0]
form = step[1] if len(step) > 1 else None
label = step[2] if len(step)> 2 else None
form_list[name] = form
if label:
step_labels[name] = label
last = name
self.done_step = last
form_list[self.done_step] = None
self.step_labels = step_labels
self.form_list = form_list
self.has_step_label = False
def get_instance_from_storage(self,storage):
return self.load_instance()
def get_instance_from_request(self,request,*args,**kwargs): pass
def get_request_step(self,request,*args,**kwargs):
return kwargs.get('step',None)
def load_for_session_key(self,session_key):
self.storage = SessionStorage(self.get_prefix(),session_key)
self.instance = self.get_instance_from_storage(self.storage)
self.steps = StepsHelper(self)
self.kwargs = self.storage.get("kwargs",{})
self.args = self.storage.get("args",())
def load_for_request(self,request):
self.storage = SessionStorage(self.get_prefix(),request.session)
if self.current_step == self.done_step:
self.instance = self.load_instance()
else:
self.instance = self.get_instance_from_request(self.request,*self.args,**self.kwargs)
if self.instance: self.store_instance(self.instance)
self.steps = StepsHelper(self)
@property
def name(self):
return self.wizard_name or self.__class__.__name__.lower().replace('wizard','')
@classmethod
def clsid(cls):
return hash("%s.%s"%(cls.__module__,cls.__name__))
@classmethod
def get_clsid_map(cls):
result = {}
for c in get_subclasses(cls):
clsid = c.clsid()
c = "%s.%s"%(cls.__module__,c.__name__)
result[ clsid ] = c
return result
@classmethod
def get_class_for_clsid(cls,cid):
cid = int(cid)
for c in get_subclasses(cls):
if c.clsid() == cid:
return c
@classmethod
def get_instance_for_clsid(cls, clsid, session_key):
klass = cls.get_class_for_clsid(clsid)
if not klass:
raise ValueError("No wizard class found for the given id: %s"%clsid)
ins = klass()
ins.load_for_session_key(session_key)
return ins
@classmethod
def as_url(cls,prefix,pk=False):
from django.conf.urls import url
pattern = r'(?:/(?P<step>\w+))?/'
prefix = prefix.strip("/")
if not cls.url_name :
raise Exception("URL name not specified for %s"% (cls.__name__))
pk = r'(?:/(?P<pk>\d+))?' if pk else ''
pattern = "^%s%s%s"%(prefix,pk,pattern)
return url(pattern, cls.as_view(), name=cls.url_name )
def get_template_names(self):
return [ os.path.join(self.template_dir,"%s.html"%self.current_step) ]
def is_marked(self):
return self.storage.get("__mark",False) is True
def mark(self):
self.storage.set("__mark",True)
def get_prefix(self):
return camel_to_underscore(self.__class__.__name__)
def dispatch(self, request,*args, **kwargs):
self.args = args
self.kwargs = kwargs
self.request = request
self.is_ajax = request.is_ajax()
current_step = self.get_request_step(request,*args,**kwargs)
self.current_step = current_step
self.has_step_label = current_step in self.step_labels
if current_step is not None and current_step not in self.get_form_list() :
raise Http404
self.load_for_request(request)
if current_step == self.done_step:
return self.render_done()
self.storage.set("user",self.request.user)
self.storage.set('ip', get_client_ip(self.request))
self.storage.set('args',args)
self.storage.set('kwargs',kwargs)
self.storage.set('subdomain',getattr(request,'subdomain',None))
#if somebody arrives in the middle without having started from the beginning then
#they should be sent back to the first url
if current_step == None or not self.is_marked() :
self.clear()
if self.is_forbidden(current_step):
return self.render_forbidden()
self.mark()
return self.redirect(self.get_step_url(self.steps.first))
response = super(CommonWizard,self).dispatch(request,*args,**kwargs)
return response
def get(self, request, *args, **kwargs):
#if step is the last step then, it cannot be an action
step = self.current_step
form_class = self.form_list[ step ]
if request.GET and 'GET' == get_form_method(form_class):
return self.render_submit(step,request.GET,{})
else:
return self.render_step(step)
def post(self, request, *args, **kwargs):
step = self.current_step
return self.render_submit(step,request.POST,request.FILES)
def is_enabled(self,step):
return True
def is_forbidden(self,step):
return False
def is_committed(self,step):
next_step = self.steps.next
return not next_step or next_step == self.done_step
def render_forbidden(self):
raise NotImplementedError
def get_request_subdomain(self):
if self.request:
return self.request.subdomain
else:
return self.storage.get('subdomain')
def get_request_ip(self):
return get_client_ip(self.request) if self.request else self.storage.get("ip")
def get_request_user(self):
return self.request.user if self.request else self.storage.get("user")
def get_form_list(self):
result = OrderedDict()
for key, form in self.form_list.iteritems() :
if self.is_enabled(key):
result[key] = form
return result
def form_valid(self,form):
pass
def form_invalid(self,form):
pass
def get_form_kwargs(self,step):
return {}
def get_form_initial(self,step):
return {}
def get_next_step_url(self,step=None):
if not step:
step = self.current_step
next_step = self.get_next_step(step)
if next_step:
return self.get_step_url(next_step)
def get_next_step(self, step=None):
"""
Returns the next step after the given `step`. If no more steps are
available, None will be returned. If the `step` argument is None, the
current step will be determined automatically.
"""
if step is None:
step = self.steps.current
form_list = self.get_form_list()
key = form_list.keys().index(step) + 1
if len(form_list.keys()) > key:
return form_list.keys()[key]
return None
def get_prev_step(self, step=None):
"""
Returns the previous step before the given `step`. If there are no
steps available, None will be returned. If the `step` argument is
None, the current step will be determined automatically.
"""
if step is None:
step = self.steps.current
form_list = self.get_form_list()
key = form_list.keys().index(step) - 1
if key >= 0:
return form_list.keys()[key]
return None
def get_step_index(self, step=None):
"""
Returns the index for the given `step` name. If no step is given,
the current step will be used to get the index.
"""
if step is None:
step = self.steps.current
return self.get_form_list().keys().index(step)
def get_form_instance(self,step):
return self.instance
def get_step_url(self,step):
data = self.kwargs.copy()
if step:
data['step'] = step
return reverse(self.url_name,kwargs=data)
def get_done_url(self):
return self.get_step_url(self.done_step)
def get_first_url(self):
return self.get_step_url(None)
def get_stored_data_for_step(self,form_key):
form_class = self.get_form_list().get(form_key,None)
if not form_class: return None
data = self.storage.get_step_cleaned_data(form_key)
if not data: return None
model = None
meta = getattr(form_class,'Meta',None)
if meta: model = getattr(meta,'model',None)
return StorageForm(data,model=model)
def get_cleaned_data_for_step(self, step):
if step in self.form_list:
form_obj = self.get_form(step=step,
data=self.storage.get_step_data(step),
files=self.storage.get_step_files(step))
if form_obj and form_obj.is_valid():
return form_obj.cleaned_data
return None
def get_step_data(self, step):
func = self.get_cleaned_data_for_step if self.request else self.get_stored_data_for_step
return func(step)
def get_form(self,step=None,data=None,files=None):
if not step: step = self.current_step
form_list = self.get_form_list()
form_class = form_list[step]
if not form_class: return None
kwargs = self.get_form_kwargs(step)
kwargs['initial'] = self.get_form_initial(step)
if issubclass(form_class, forms.ModelForm):
kwargs['instance'] = self.get_form_instance(step)
kwargs['data'] = data
kwargs['files'] = files
form = form_class(**kwargs)
return form
def get_invalid_form_step(self):
for form_key in self.get_form_list():
data = self.storage.get_step_data(form_key)
files = self.storage.get_step_files(form_key)
form_obj = self.get_form(step=form_key,data=data,files=files)
if form_obj is None: continue
valid = form_obj.is_valid()
if not valid and self.request :
return form_key
def get_all_stored_data(self):
result = {}
for step in self.get_form_list():
data = self.get_stored_data_for_step(step)
if data is None: continue
result[step] = data
return result
def redirect(self,url,**kwargs):
if not self.is_ajax:
return redirect(url)
external = url.startswith("https") or url == self.get_done_url()
return ajax_redirect(url,not external,**kwargs)
def render_step(self,step):
"""
Render all non-form get requests
"""
data = self.storage.get_step_data(step)
files = self.storage.get_step_files(step)
form = self.get_form(step,data,files)
self.clean_for_commit()
return self.render(form)
def render_submit(self,step,data,files):
form = self.get_form(step,data,files)
if form.is_valid():
cleaned_data = form.cleaned_data
self.storage.set_step_data(step,form.data)
self.storage.set_step_files(step,form.files)
self.storage.set_step_cleaned_data(step, cleaned_data)
self.form_valid(form)
if self.is_committed(step or self.current_step):
step = self.get_invalid_form_step()
if step:
return self.render_revalidation_failure(step)
self.prepare_for_commit()
return self.render_commit()
return self.redirect(self.get_step_url(self.steps.next or self.done_step))
else:
self.form_invalid(form)
return self.render(form)
def render_commit(self):
self.process_commit()
return self.redirect( self.get_done_url() )
def render(self,form):
context = self.get_context_data() or {}
context.update( self.extra_context )
self.form = form
context['wizard'] = self
context['form'] = form
return self.render_to_response(context)
def render_revalidation_failure(self,failed_step):
"""
When a step fails, we have to redirect the user to the first failing
step.
"""
return self.redirect(self.get_step_url(failed_step))
def render_done(self):
item = self.load_instance()
if not item: raise Http404
return self.done(item)
def done(self,item):
"""
I should return a valid response
"""
self.extra_context['object'] = item
return self.render(None)
def clean_for_commit(self):
"""
Run for all steps that are not commited i.e for all get requests
"""
def prepare_for_commit(self):
"""
Run just before committed step i.e. after submission of form in the second last step
"""
def process_commit(self,clean=True):
self.request = None
ins = self.commit(self.get_all_stored_data())
self.store_instance(ins)
if clean: self.clear()
self.storage.save()
return ins
def commit(self,form_list):
"""
I have to return something. This is the only way to ensure that
only legitimate users reach this page.
"""
raise NotImplementedError
def clear(self):
self.storage.clear()
def store_instance(self,ins):
session = self.storage.session
key = "%s-instance"%self.get_prefix()
session[key] = ins
session.modified = True
def load_instance(self):
if self.instance: return self.instance
session = self.storage.session
key = "%s-instance"%self.get_prefix()
item = session.get(key,None)
if item:
#this is interesting. stored instance has incorrect kind during the upgrade
#and this gets persisted during login process.
#this overwrites all changes to the user.
item = item.__class__.objects.get(pk=item.pk)
# post_init.send(sender=item.__class__,instance=item)
return item