class NeedEditForm(BaseForm):
id = "NeedEdit"
label = ""
fields = NeedCreateForm.fields
@classmethod
def on_success(cls, request, values):
_ = request._
need = request.context.need
round = request.context.round
values['token'] = need.token
advisor = unpack_advisor(request, values.pop('advisor', {}))
newNeed = not need.added
if newNeed:
AddNeedToRound(request, {
'Round': {
'token': round.token,
'Needs': [{
'token': need.token
}]
}
})
try:
round = EditNeedProc(request, {'Needs': [values]})
except DBNotification, e:
if e.message == 'Need_Already_Exists':
return {
'success': False,
'errors': {
'name':
_("TaskSetup.ErrorMessage.This task already exists, if you intend to Edit this task, please change its name to something less ambiguous!"
)
}
}
else:
raise e
if advisor: invite_advisor_to_need(request, need, advisor)
if newNeed:
request.session.flash(
GenericSuccessMessage(
_("TaskSetup.SuccessMessage.Task added to round!")),
"generic_messages")
return {
'success': True,
'redirect': request.resource_url(request.context.__parent__)
}
else:
request.session.flash(
GenericSuccessMessage(
_("TaskSetup.SuccessMessage.Changes saved!")),
"generic_messages")
return {
'success': True,
'redirect': request.resource_url(request.context)
}
class PageCreateForm(BaseForm):
label = "Create Page"
fields = [
StringField('url', "URL", REQUIRED),
StringField('title', "title", REQUIRED),
CheckboxPostField('active', "Enabled"),
StringField('metaKeywords', "Meta Keywords"),
StringField('metaDescription', "Meta Description"),
TextareaField('content', "Content", input_classes='x-high')
]
@classmethod
def on_success(cls, request, values):
values['Need'] = [{'name': n} for n in values.pop('Need', [])]
try:
need = AdminPageCreateProc(request, values)
except DBNotification, e:
if e.message in ('Page_Already_Exists', 'Url already exists'):
return {
'success': False,
'errors': {
'url':
"This Page already exists, please change the url."
}
}
else:
raise e
request.session.flash(
GenericSuccessMessage("Page created successfully!"),
"generic_messages")
return {
'success': True,
'redirect': request.resource_url(request.context)
}
class ServiceCreateForm(BaseForm):
label = "Create Service"
fields = [
StringField('name', "Name", REQUIRED),
URLField('url', "Website", REQUIRED),
PictureUploadField("logo", "Logo", picWidth=100, picHeight=100)
]
@classmethod
def on_success(cls, request, values):
try:
need = AdminServiceCreateProc(request, values)
except DBNotification, e:
if e.message == 'Service_Already_Exists':
return {
'success': False,
'errors': {
'name':
"This service already exists, please change the name to a unique name."
}
}
else:
raise e
request.session.flash(
GenericSuccessMessage("Service created successfully!"),
"generic_messages")
return {
'success': True,
'redirect': request.resource_url(request.context)
}
def on_success(cls, request, values):
_ = request._
user = request.root.user
company = request.context.company
need = request.context.need
params = {
'name': values['name'],
'email': values['email'],
'invitorToken': user.token,
'invitorName': user.name,
'companySlug': company.slug,
'companyName': company.name,
'Need': {
"slug": need.slug,
"name": need.name
}
}
RecommendNeedProc(request, {'Invite': params})
request.session.flash(
GenericSuccessMessage(
_(u"TaskDetailsPage.Message:You successfully recommended this task to {name}!"
).format(**values)), "generic_messages")
return {
'success': True,
'redirect': request.resource_url(request.context)
}
def add_top_mentor(context, request):
mentorToken = request.params.get('m')
mentor = GetProfileProc(request, {'token': mentorToken})
if not mentor:
request.session.flash(GenericErrorMessage("Not a valid mentor!"),
"generic_messages")
raise HTTPFound(request.resource_url(request.context, 'mentor'))
user = request.root.user
company = request.context.company
values = {
'invitorToken': user.token,
'invitorName': user.name,
'companySlug': company.slug,
'userToken': mentorToken,
'role': 'MENTOR',
'email': mentor.email,
'name': mentor.name
}
InviteToCompanyProc(request, {'Invite': [values]})
request.session.flash(
GenericSuccessMessage(
u"You successfully invited {name} to your company!".format(
**values)), "generic_messages")
raise HTTPFound(request.resource_url(request.context))
def on_success(cls, request, values):
values['name'] = request.context.service.name
need = AdminServiceEditProc(request, values)
request.session.flash(
GenericSuccessMessage("Service updated successfully!"),
"generic_messages")
return {
'success': True,
'redirect': request.resource_url(request.context.__parent__)
}
def on_success(cls, request, values):
values['key'] = request.context.__name__
values['Need'] = [{'name': n} for n in values.pop('Need', [])]
need = AdminPageEditProc(request, values)
request.session.flash(
GenericSuccessMessage("Page updated successfully!"),
"generic_messages")
return {
'success': True,
'redirect': request.resource_url(request.context)
}
def on_success(cls, request, values):
values['key'] = request.context.__name__
needs = values.pop('Need', [])
if not isinstance(needs, list): needs = [needs]
values['Need'] = [{'name': n} for n in needs]
need = AdminTemplatesEditProc(request, values)
request.session.flash(
GenericSuccessMessage("Template updated successfully!"),
"generic_messages")
return {
'success': True,
'redirect': request.resource_url(request.context.__parent__)
}
def on_success(cls, request, values):
_ = request._
need = request.context.need
advisor = unpack_advisor(request, values)
invite_advisor_to_need(request, need, advisor)
request.session.flash(
GenericSuccessMessage(
_(u"TaskDetailsPage.Message:You successfully invited {name} to advise you with this task!"
).format(**values)), "generic_messages")
return {
'success': True,
'redirect': request.resource_url(request.context)
}
def on_success(cls, request, values):
data = request.context.contentsMap
data.update({v['key']: v['value'] for v in values['values']})
contents = SetStaticContentProc(
request,
{'Static': [{
'key': k,
'value': v
} for k, v in data.items()]})
request._.refresh(request)
request.session.flash(
GenericSuccessMessage("Content created successfully!"),
"generic_messages")
return {'success': True, 'redirect': fwd_url(request)}
def delete_view_inner(context, request):
data = request.context.contentsMap
data.pop(request.context.content.key, None)
contents = SetStaticContentProc(
request,
{'Static': [{
'key': k,
'value': v
} for k, v in data.items()]})
request._.refresh(request)
request.session.flash(
GenericSuccessMessage("Content updated successfully!"),
"generic_messages")
request.fwd_raw(fwd_url(request))
class TaskEditForm(TaskCreateForm):
label = "Edit Task"
@classmethod
def on_success(cls, request, values):
values['key'] = request.context.task.key
try:
need = AdminNeedEditProc(request, values)
except (DBNotification, DBException), e:
return {'success': False, 'message': e.message}
request.session.flash(
GenericSuccessMessage("Task updated successfully!"),
"generic_messages")
return {
'success': True,
'redirect': request.resource_url(request.context.__parent__)
}
def on_success(cls, request, values):
user = request.root.user
company = request.context.company
values['invitorToken'] = user.token
values['invitorName'] = user.name
values['companySlug'] = company.slug
InviteToCompanyProc(request, {'Invite': [values]})
request.session.flash(
GenericSuccessMessage(
u"You successfully invited {name} to your company!".format(
**values)), "generic_messages")
return {
'success': True,
'redirect': request.resource_url(request.context)
}
class TemplateCreateForm(BaseForm):
label = "Create Template"
fields = [
BS3_NCOL(
Sequence(
StringField('name', "Name", REQUIRED),
TextareaField('description',
"Description",
REQUIRED,
input_classes='x-high'),
PictureUploadField("picture",
"Picture",
picWidth=277,
picHeight=230),
CheckboxPostField('active', "Active?")),
NeedSelector('Need', "Task List"))
]
@classmethod
def on_success(cls, request, values):
needs = values.pop('Need', [])
if not isinstance(needs, list): needs = [needs]
values['Need'] = [{'name': n} for n in needs]
try:
need = AdminTemplatesCreateProc(request, values)
except DBNotification, e:
if e.message == 'Template_Already_Exists':
return {
'success': False,
'errors': {
'name':
"This template already exists, please change the name to a unique name."
}
}
else:
raise e
request.session.flash(
GenericSuccessMessage("Template created successfully!"),
"generic_messages")
return {
'success': True,
'redirect': request.resource_url(request.context)
}
def on_success(cls, request, values):
_ = request._
ApplyForNeedProc(
request, {
'token': request.context.need.token,
'Application': {
'User': {
'token': request.root.user.token
},
'message': values['message']
}
})
request.session.flash(
GenericSuccessMessage(
_("TaskDetailsPage.Apply.Success:You have successfully applied for this task. One of the team members will contact you shortly."
)), "generic_messages")
return {
'success': True,
'redirect': request.resource_url(request.context)
}
class NeedCreateForm(BaseForm):
id = "NeedCreate"
label = ""
fields = [
PictureUploadField("picture",
_("TaskSetup.FormLabel.Picture"),
group_classes='file-upload-control'),
TypeAheadField('name',
_("TaskSetup.FormLabel.Title"),
'/web/need/name',
'Needs',
attrs=REQUIRED,
js_module="views/company/need_switch",
api_allow_new=True),
CheckboxPostField('parttime', _("TaskSetup.FormLabel.is part time")),
CurrencyIntField(
'cash',
_("TaskSetup.FormLabel.Cash Value"),
HtmlAttrs(
required=True,
data_control_help=_("TaskSetup.FormLabel.Cash Value.Help")),
input_classes='data-input cash',
maxlength=8),
CurrencyIntField(
'equity',
_("TaskSetup.FormLabel.Equity Value"),
HtmlAttrs(
required=True,
data_control_help=_("TaskSetup.FormLabel.Equity Value.Help")),
input_classes='data-input equity',
maxlength=8),
SanitizedHtmlField("customText",
_("TaskSetup.FormLabel.Description"),
REQUIRED,
input_classes='x-high'),
TagSearchField("Tags",
_("TaskSetup.FormLabel.Related Tags"),
'/web/tag/search',
'Tags',
attrs=HtmlAttrs(required=True,
data_required_min=3,
placeholder="Add Tags")),
ServiceSearchField("Services",
_("TaskSetup.FormLabel.Related Services"),
'/web/service/search',
'Services',
attrs=HtmlAttrs(placeholder="Add Services")),
StringField("advisor.name",
_("TaskSetup.FormLabel.Advisor.Name"),
input_classes="ignore"),
EmailField("advisor.email",
_("TaskSetup.FormLabel.Advisor.EmailAddress"),
input_classes="ignore")
]
@classmethod
def on_success(cls, request, values):
_ = request._
try:
advisor = unpack_advisor(request, values.pop('advisor', {}))
need = CreateNeedProc(request, {
'Needs': [values],
'token': request.context.round.token
})
except DBNotification, e:
if e.message == 'Need_Already_Exists':
return {
'success': False,
'errors': {
'name':
_("TaskSetup.ErrorMessage.This task already exists, if you intend to create this task, please change its name to something less ambiguous!"
)
}
}
else:
raise e
if advisor: invite_advisor_to_need(request, need, advisor)
request.session.flash(
GenericSuccessMessage(
_("TaskSetup.SuccessMessage.Task created successfully!")),
"generic_messages")
return {
'success': True,
'redirect': request.resource_url(request.context)
}
need = AdminNeedCreateProc(request, values)
except DBNotification, e:
if e.message == 'Need_Already_Exists':
return {
'success': False,
'errors': {
'name':
"This task already exists, please change the name to a unique name."
}
}
else:
return {'success': False, 'message': e.message}
except DBException, e:
return {'success': False, 'message': e.message}
request.session.flash(
GenericSuccessMessage("Task created successfully!"),
"generic_messages")
return {
'success': True,
'redirect': request.resource_url(request.context)
}
class TaskCreateHandler(FormHandler):
form = TaskCreateForm
class TaskEditForm(TaskCreateForm):
label = "Edit Task"
@classmethod
values = variable_decode(self.request.params)
schema_id = values.get('type')
if not schema_id: raise HTTPNotImplemented()
try:
resp = self.validate_values(values)
except Invalid, error:
log.error(error.error_dict)
self.result['values'][schema_id] = error.value or {}
self.result['errors'][schema_id] = error.error_dict or {}
self.request.response.status_int = 401
else:
### if validate_values/on_success returns anything else than a redirect, it must be some validation error
if resp.get('message'):
if resp.get('success') == True:
self.request.session.flash(
GenericSuccessMessage(resp.get('message')),
'generic_messages')
elif resp.get('success') == False:
self.request.session.flash(
GenericErrorMessage(resp.get('message')),
'generic_messages')
if resp.get('redirect'):
# cannot be redirect exception inside an exception view
return redirect_response(resp.get('redirect'))
self.result['values'][schema_id] = resp.get('values', values)
self.result['errors'][schema_id] = resp.get('errors', {})
self.request.response.status_int = 401
self.result = self.add_globals(self.request, self.result)
return self.result
def accept_application(context, request):
ApproveApplicationProc(request, {'token': context.application.token})
request.session.flash(
GenericSuccessMessage("The application has been accepted!"),
"generic_messages")
raise HTTPFound(request.resource_url(context.__parent__))
