1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
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
|
#the purpose of that module is to make widget automation
#for registered minion modules so we dont hace to write
#that same boring stuff for every added module !
from turbogears.widgets.base import Widget,WidgetsList
from turbogears import widgets
class WidgetListFactory(object):
"""
The class is responsible for taking the method arguments
and converting them to the appropriate widget equivalents
Examples :
"""
#which type matches for which InputWidget
__convert_table={
'int':{
'default_value':"TextField",
},
'string':{
'default_value':"TextField",
'options':"SingleSelectField"},
'boolean':{
'default_value':"CheckBox"},
'float':{
'default_value':"TextField",
},
'hash':{
'default_value':"TextArea"},
'list':{
'default_value':"TextArea"}
}
#will contain the input widget created in that class
__widget_list={}
def __init__(self,argument_dict):
"""
Initiated with argument_dict of a method to return back
a WidgetsList object to be placed into a form object
@param:argument_dict : The structure we got here is like
{'arg1':{'type':'int'..},'arg2':{'min':111} ...}
"""
self.__argument_dict = argument_dict
def __add_general_widget(self):
#key is the argument_name and the argument are options
for key,argument in self.__argument_dict.iteritems():
#get the type of the argument
current_type = argument['type']
act_special = False #if it has some special parameters
#it should be passed to its specialized method,if it has
#for example options in its key it should be shown as a
#SingleSelectField not a TextFiled
for type_match in self.__convert_table[current_type].keys():
if type_match!='default_value' and argument.has_key(type_match):
act_special = True
# print key,argument
if act_special:
#calling for example __add_specialized_string(..)
getattr(self,"_%s__add_specialized_%s"%(self.__class__.__name__,current_type))(argument,key)
else:
temp_object = getattr(widgets,self.__convert_table[current_type]['default_value'])()
#add common options to it
self.__add_commons_to_object(temp_object,argument,key)
#add a new entry to final list
self.__widget_list[key]=temp_object
#print "That have the object :",getattr(self.__widget_list[key],"default")
del temp_object
#print "That have the object :",getattr(self.__widget_list["list_default"],"default")
def __add_specialized_string(self,argument,argument_name):
"""
Specialized option adder, called when the type:string is used
with option 'options' so we should create a new SingleSelectField
that one canno be created like others because user should supply options
in the constructor of the SingleSelectField so it becomes a special one
@param : argument : the argument options,
@param : argument_name : the name of the argument also the name of the widget
@return : Nothing
"""
#allittle bit difficult to follow but that structure does
#temp_object = SingleSelectField() for example
temp_object = getattr(widgets,self.__convert_table[argument['type']]['options'])(options = argument['options'])
self.__add_commons_to_object(temp_object,argument,argument_name)
#add a new entry to final list
self.__widget_list[argument_name]=temp_object
del temp_object
def __add_commons_to_object(self,object,argument,argument_name):
"""
As it was thought all input widgets have the same
common parameters they take so that method will add
them to instantiated object for ex (TextField) if they
occur into the argument ...
@param object : instantiated inputwidget object
@param method argument to lookup {type:'int','max':12 ...}
@return :None
"""
#firstly set the name of the argument
setattr(object,"name",argument_name)
#print "The argument name is :",argument_name
#print "The argument options are :",argument
if argument.has_key('default'):
setattr(object,"default",argument["default"])
if argument.has_key('description'):
setattr(object,'help_text',argument['description'])
def get_widgetlist(self):
"""
Return back a dictionay with argument_name : input_widget
pairs. That method may not be called directly,get_widgetlist_object
is better for using in web interface
"""
#compute the list
self.__add_general_widget()
return self.__widget_list
def get_widgetlist_object(self):
"""
Method return back the final widgetlist object
which is turbogears.widgets.WidgetsList
"""
if len(self.__widget_list.keys())==0:
self.__add_general_widget() #not very efficient
widget_list_object = widgets.WidgetsList()
for name,input_widget in self.__widget_list.iteritems():
setattr(widget_list_object,name,input_widget)
#get the object back
return widget_list_object
####################################################################################################################
from turbogears.widgets.base import CoreWD
from turbogears.widgets import RemoteForm
from turbogears import validators, expose
class RemoteFormAutomation(CoreWD):
"""
Base class for ajaxian Form creation
"""
name = "Ajaxian Minion Submit Form"
template = """
<div>
{for_widget.display()}
<div id="loading"></div>
<div id="post_data"></div>
</div>
"""
full_class_name = "turbogears.widgets.RemoteForm"
def __init__(self,generated_fields,*args,**kwarg):
"""
The constructor part same as normal one except
it takes a WidgetsList object into generated_fields
which is generated by WidgetListFactory
"""
#call the master :)
super(RemoteFormAutomation,self).__init__(*args,**kwarg)
self.for_widget = RemoteForm(
fields = generated_fields,
name = "minion_form",
update = "post_data",
before='getElement(\'loading\').innerHTML=\'Submiting form!\';',
on_complete='getElement(\'loading\' ).innerHTML=\'Done!\';',
action = "%s/post_form"%(self.full_class_name)
)
def post_form(self,**kw):
"""
Data processing part
"""
return "I got that data from the remote minion form :<br/>%r"%kw
post_form = expose()(post_form)
|