def AuthenticatedGet(self, org, event):
global_admin = False
local_admin = False
if org.name == GLOBAL_ADMIN_NAME:
global_admin = True
if org.is_admin == True and global_admin == False:
local_admin = True
if global_admin == False and local_admin == False:
self.redirect("/")
return
form = organization.OrganizationAdminForm()
events_list = None
if global_admin:
query_string = "SELECT * FROM Event"
events_list = db.GqlQuery(query_string)
if local_admin:
events_list = []
query_string = "SELECT * FROM Event"
query_first = db.GqlQuery(query_string)
for q in query_first:
if q.key() == org.incident.key():
events_list.append(q)
suggested_password = random_password.generate_password()
self.response.out.write(template.render(
{
"create_admin": True,
"form": form,
"events_list": events_list,
"auto_password": suggested_password,
"global_admin": global_admin,
}))
return
def AuthenticatedGet(self, org, _):
global_admin = False
local_admin = False
if org.name == GLOBAL_ADMIN_NAME:
global_admin = True
if org.is_admin == True and global_admin == False:
local_admin = True
if global_admin == False and local_admin == False:
self.redirect("/")
return
# create form
form = (GlobalAdminCreateOrganizationForm()
if global_admin else CreateOrganizationForm())
events = self._get_events(org, global_admin, local_admin)
form.incident.choices = [(str(event.key().id()), event.name)
for event in events]
form.password.data = random_password.generate_password()
# render template
self.response.out.write(
template.render({
"form": form,
"global_admin": global_admin,
}))
def AuthenticatedGet(self, org, _):
global_admin = False
local_admin = False
if org.name == GLOBAL_ADMIN_NAME:
global_admin = True
if org.is_admin == True and global_admin == False:
local_admin = True
if global_admin == False and local_admin == False:
self.redirect("/")
return
# create form
form = (
GlobalAdminCreateOrganizationForm() if global_admin
else CreateOrganizationForm()
)
events = self._get_events(org, global_admin, local_admin)
form.incident.choices = [(str(event.key().id()), event.name) for event in events]
form.password.data = random_password.generate_password()
# render template
self.response.out.write(template.render({
"form": form,
"global_admin": global_admin,
}))
def AuthenticatedGet(self, org, event):
global_admin = False
local_admin = False
if org.name == GLOBAL_ADMIN_NAME:
global_admin = True
if org.is_admin == True and global_admin == False:
local_admin = True
if global_admin == False and local_admin == False:
self.redirect("/")
return
if self.request.get("new_organization"):
try:
id = int(self.request.get("new_organization"))
except:
self.response.set_status(400)
return
obj = organization.Organization.get(db.Key.from_path("Organization", id))
if local_admin:
if not obj.incident.key() == org.incident.key():
self.redirect("/admin")
return
query = db.GqlQuery("SELECT * FROM Contact WHERE organization = :1 LIMIT 1", obj.key())
contact_id = None
contact = None
for q in query:
contact_id = q.key().id()
if contact_id:
contact = primary_contact_db.Contact.get_by_id(contact_id)
suggested_password = random_password.generate_password()
self.response.out.write(
template.render(
{
"form": True,
"new_organization": obj,
"contact": contact,
"suggested_password": suggested_password,
"global_admin": global_admin,
}
)
)
return
else:
self.redirect("/")
return
def AuthenticatedGet(self, org, event):
if not org.name == GLOBAL_ADMIN_NAME:
self.redirect("/")
return
form = event_db.NewEventForm()
query_string = "SELECT * FROM Event"
events_list = db.GqlQuery(query_string)
count = events_list.count()
auto_password = random_password.generate_password()
self.response.out.write(template.render(
{
"auto_password": auto_password,
"form": form,
"case_label": CASE_LABELS[count]
}))
def AuthenticatedPost(self, org, event):
name = self.request.get("name")
form = GetOrganizationForm(self.request.POST)
event_name = None
if form.event.data:
event_name = form.event.data
if event_name == "None" or event_name == None:
event_name = self.request.get("event_name")
logging.info("new password")
logging.info(name)
logging.info(event_name)
password = self.request.get("password")
# raise Exception(event_name)
if self.request.get("accept") == "true":
event_name = self.request.get("event_name")
this_event = event_db.Event.all().filter("name =",
event_name).get()
org = organization.Organization.all().filter(
"name =", name).filter("incidents =", this_event.key()).get()
password_hash = generate_hash.recursive_hash(password)
if org:
if password_hash in org._password_hash_list:
self.rediect(
"/admin?message=That password already exists for that organization"
)
return
org._password_hash_list.append(password_hash)
org._password_hash_list = list(set(org._password_hash_list))
organization.PutAndCache(org)
audit = audit_db.new_password(org, password_hash)
url = "/admin?message=New password added to " + name + " working on " + event_name
self.redirect(url)
return
else:
url = "/admin-generate-new-password?error_message=Could not find " + name + "for: " + event_name
self.redirect(url)
return
password = random_password.generate_password()
template_params = page_db.get_page_block_dict()
template_params.update({
"password": password,
"name": name,
"event_name": event_name
})
self.response.out.write(post_template.render(template_params))
def AuthenticatedGet(self, org, event):
global_admin = (org.name == GLOBAL_ADMIN_NAME)
if not global_admin:
self.redirect("/")
return
form = event_db.NewEventForm()
query_string = "SELECT * FROM Event"
events_list = db.GqlQuery(query_string)
count = events_list.count()
auto_password = random_password.generate_password()
self.response.out.write(
template.render({
"auto_password": auto_password,
"form": form,
"case_label": CASE_LABELS[count],
"global_admin": global_admin,
}))
def AuthenticatedPost(self, org, event):
data = primary_contact_db.ContactFormFull(self.request.POST)
if data.validate():
organization_id = self.request.get("choose_organization")
try:
id = int(organization_id)
except:
return
this_organization = organization.Organization.get_by_id(id)
contact = primary_contact_db.Contact(
first_name=data.first_name.data,
last_name=data.last_name.data,
phone=data.phone.data,
email=data.email.data,
is_primary=bool(data.is_primary.data),
organization=this_organization.key(),
)
primary_contact_db.PutAndCache(contact, ten_minutes)
self.redirect(
"/organization-settings?message=Contact created. It may take a few moments for the contact to show up on your list."
)
return
else:
suggested_password = random_password.generate_password()
query_string = "SELECT * FROM Organization"
organization_list = db.GqlQuery(query_string)
self.response.out.write(
template.render(
{
"form": data,
"errors": data.errors,
"create_contact": True,
"organization_list": organization_list,
}
)
)
return
def post(self):
# create inactive, unverified org with a random password
org = organization.Organization(
name=self.request.get("name"),
is_active=False,
org_verified=False,
voad_referral=self.request.get("voad_referral"),
password=random_password.generate_password()
)
# set non-contact org attributes by type
for k, v in self.request.POST.iteritems():
if not any(k.startswith(prop) for prop in self.CONTACT_PROPERTIES_LIST):
if k == "choose_event":
chosen_event = event_db.Event.get_by_id(int(v))
setattr(org, "incidents", [chosen_event.key()])
elif k in self.BOOLEAN_PROPERTIES_LIST:
setattr(org, k, bool(int(v)))
else:
# clean away known pre-supplied strings
if v.strip() in ('http://', '@'):
v = None
setattr(org, k, v)
# create contacts
def get_contact_field(field_name, contact_num):
field_value = self.request.get(field_name + '_%d' % i)
return field_value.strip() if field_value else None
new_contacts = []
for i in range(10):
first_name = get_contact_field('first_name', i)
last_name = get_contact_field('last_name', i)
title = get_contact_field('title', i)
email = get_contact_field('personal_email', i)
phone = get_contact_field('personal_phone', i)
if first_name and last_name and email and phone: # required fields
new_contacts.append(primary_contact_db.Contact(
first_name=first_name,
last_name=last_name,
title=title,
email=email,
phone=phone,
is_primary=(i == 0) # the first contact is the primary one
))
# save
organization.PutAndCacheOrganizationAndContact(org, new_contacts)
# email primary contacts & administrators
organization_form = organization.OrganizationForm(None, org)
contact_forms = [
primary_contact_db.ContactFormFull(None, contact)
for contact in new_contacts
]
messaging.email_contacts_using_templates(
event=chosen_event,
contacts=[c for c in new_contacts if c.is_primary],
subject_template_name='new_organization.to_contacts.subject.txt',
body_template_name='new_organization.to_contacts.body.txt',
new_organization=org,
primary_contact=new_contacts[0],
application_id=messaging.get_application_id(),
organization_form=organization_form,
contact_forms=contact_forms,
)
approval_url = "%s://%s/admin-new-organization?new_organization=%d" % (
urlparse(self.request.url).scheme,
urlparse(self.request.url).netloc,
org.key().id()
)
messaging.email_administrators_using_templates(
event=chosen_event,
subject_template_name='new_organization.to_admins.subject.txt',
body_template_name='new_organization.to_admins.body.txt',
new_organization=org,
primary_contact=new_contacts[0],
application_id=messaging.get_application_id(),
approval_url=approval_url,
organization_form=organization_form,
contact_forms=contact_forms,
)
self.redirect("/welcome")
def AuthenticatedPost(self, org, event):
global_admin = False
local_admin = False
if org.name == GLOBAL_ADMIN_NAME:
global_admin = True
if org.is_admin == True and global_admin == False:
local_admin = True
if global_admin == False and local_admin == False:
self.redirect("/")
return
if self.request.get("create_contact"):
data = primary_contact_db.ContactFormFull(self.request.POST)
if data.validate():
organization_id = self.request.get("choose_organization")
try:
id = int(organization_id)
except:
return
this_organization = organization.Organization.get_by_id(id)
if not org.may_administer(this_organization):
self.abort(403)
contact = primary_contact_db.Contact(
first_name=data.first_name.data,
last_name=data.last_name.data,
title=data.title.data,
phone=data.phone.data,
email=data.email.data,
is_primary=bool(data.is_primary.data),
organization=this_organization.key(),
)
primary_contact_db.PutAndCache(contact, ten_minutes)
self.redirect(
"/admin-create-contact?selected_org=%s&message=Contact Created"
% this_organization.key().id())
return
else:
#query_string = "SELECT * FROM Event"
#events_list = db.GqlQuery(query_string)
suggested_password = random_password.generate_password()
query_string = "SELECT * FROM Organization"
organization_list = db.GqlQuery(query_string)
self.response.out.write(
template.render({
"form": data,
"errors": data.errors,
"create_contact": True,
"organization_list": organization_list,
}))
return
if self.request.get("create_admin"):
data = organization.OrganizationAdminForm(self.request.POST)
event_id = self.request.get("choose_event")
try:
id = int(event_id)
except:
return
this_event = event_db.Event.get_by_id(id)
if local_admin:
if not this_event.key() == event.key():
self.redirect("/")
return
if data.validate():
new_org = organization.Organization(
name=data.name.data,
email=data.email.data,
phone=data.phone.data,
address=data.address.data,
city=data.city.data,
state=data.state.data,
zip_code=data.zip_code.data,
physical_presence=True,
number_volunteers="0",
voad_member=False,
org_verified=True,
twitter=data.twitter.data,
url=data.url.data,
facebook=data.facebook.data,
incidents=[this_event.key()],
password=self.request.get("password"),
is_active=True,
is_admin=True,
)
# set all phase fields true for admin
for phase_name in new_org.get_phase_boolean_names():
setattr(new_org, phase_name, True)
new_contact = primary_contact_db.Contact(
first_name=data.contact_first_name.data,
last_name=data.contact_last_name.data,
title=data.contact_title.data,
email=data.contact_email.data,
phone=data.contact_phone.data,
is_primary=True)
organization.PutAndCacheOrganizationAndContact(
organization=new_org,
contact=new_contact,
)
self.redirect("/admin?message=Admin Created")
return
else:
# needs events lists, password, errors
query_string = "SELECT * FROM Event"
suggested_password = random_password.generate_password()
self.response.out.write(
template.render({
"form": data,
"errors": data.errors,
"create_admin": True,
#"events_list": events_list,
"auto_password": suggested_password,
}))
return
if self.request.get("delete_org_id"):
# delete organization
try:
id = int(self.request.get("delete_org_id"))
org_by_id = organization.Organization.get_by_id(id)
except:
self.abort(400)
if not org.may_administer(org_by_id):
self.abort(403)
primary_contact_db.RemoveOrgFromContacts(org_by_id)
db.delete(org_by_id)
self.redirect("/admin")
return
if self.request.get("delete_contact_id"):
# delete contact
try:
id = int(self.request.get("delete_contact_id"))
contact_by_id = primary_contact_db.Contact.get_by_id(id)
except:
self.abort(400)
if not org.may_administer(org_by_id):
self.abort(403)
db.delete(contact_by_id)
self.redirect("/admin")
return
if self.request.get("verify_organization"):
# verify organization
try:
id = int(self.request.get("verify_organization"))
org_by_id = organization.Organization.get_by_id(id)
except:
self.abort(400)
# check we are allowed
if not org.may_administer(org_by_id):
self.abort(403)
# perform verification
org_by_id.verify()
# cache
organization.PutAndCache(org_by_id, 600)
self.redirect("/admin")
return
if self.request.get("save_org_id"):
# save org (?)
try:
id = int(self.request.get("save_org_id"))
org_by_id = organization.Organization.get_by_id(id)
except:
self.abort(400)
if not org.may_administer(org_by_id):
self.abort(403)
org_by_id.org_verified = True
organization.PutAndCache(org_by_id, 600)
self.redirect("/admin")
return
def post(self):
# create inactive, unverified org with a random password
org = organization.Organization(
name=self.request.get("name"),
is_active=False,
org_verified=False,
voad_referral=self.request.get("voad_referral"),
password=random_password.generate_password())
# set non-contact org attributes by type
for k, v in self.request.POST.iteritems():
if not any(
k.startswith(prop)
for prop in self.CONTACT_PROPERTIES_LIST):
if k == "choose_event":
chosen_event = event_db.Event.get_by_id(int(v))
setattr(org, "incidents", [chosen_event.key()])
elif k in self.BOOLEAN_PROPERTIES_LIST:
setattr(org, k, bool(int(v)))
else:
# clean away known pre-supplied strings
if v.strip() in ('http://', '@'):
v = None
setattr(org, k, v)
# create contacts
def get_contact_field(field_name, contact_num):
field_value = self.request.get(field_name + '_%d' % i)
return field_value.strip() if field_value else None
new_contacts = []
for i in range(10):
first_name = get_contact_field('first_name', i)
last_name = get_contact_field('last_name', i)
title = get_contact_field('title', i)
email = get_contact_field('personal_email', i)
phone = get_contact_field('personal_phone', i)
if first_name and last_name and email and phone: # required fields
new_contacts.append(
primary_contact_db.Contact(
first_name=first_name,
last_name=last_name,
title=title,
email=email,
phone=phone,
is_primary=(i == 0
) # the first contact is the primary one
))
# save
organization.PutAndCacheOrganizationAndContact(org, new_contacts)
# email primary contacts & administrators
organization_form = organization.OrganizationForm(None, org)
contact_forms = [
primary_contact_db.ContactFormFull(None, contact)
for contact in new_contacts
]
messaging.email_contacts_using_templates(
event=chosen_event,
contacts=[c for c in new_contacts if c.is_primary],
subject_template_name='new_organization.to_contacts.subject.txt',
body_template_name='new_organization.to_contacts.body.txt',
new_organization=org,
primary_contact=new_contacts[0],
application_id=messaging.get_application_id(),
organization_form=organization_form,
contact_forms=contact_forms,
)
approval_url = "%s://%s/admin-new-organization?new_organization=%d" % (
urlparse(self.request.url).scheme, urlparse(
self.request.url).netloc, org.key().id())
messaging.email_administrators_using_templates(
event=chosen_event,
subject_template_name='new_organization.to_admins.subject.txt',
body_template_name='new_organization.to_admins.body.txt',
new_organization=org,
primary_contact=new_contacts[0],
application_id=messaging.get_application_id(),
approval_url=approval_url,
organization_form=organization_form,
contact_forms=contact_forms,
)
self.redirect("/welcome")
def AuthenticatedPost(self, org, event):
global_admin = False
local_admin = False
if org.name == GLOBAL_ADMIN_NAME:
global_admin = True
if org.is_admin == True and global_admin == False:
local_admin = True
if global_admin == False and local_admin == False:
self.redirect("/")
return
events_list = None
if global_admin:
query_string = "SELECT * FROM Event"
events_list = db.GqlQuery(query_string)
if local_admin:
events_list = []
query_string = "SELECT * FROM Event"
events = db.GqlQuery(query_string)
for e in events:
if e.key() == org.incident.key():
events_list.append(e)
if self.request.get("create_contact"):
data = primary_contact_db.ContactFormFull(self.request.POST)
if data.validate():
organization_id = self.request.get("choose_organization")
try:
id = int(organization_id)
except:
return
this_organization = organization.Organization.get_by_id(id)
if local_admin:
if not this_organization.incident.key() == org.incident.key():
self.redirect("/")
return
contact = primary_contact_db.Contact(first_name = data.first_name.data,
last_name = data.last_name.data,
phone = data.phone.data,
email = data.email.data,
is_primary = bool(data.is_primary.data),
organization = this_organization.key(),
)
primary_contact_db.PutAndCache(contact, ten_minutes)
self.redirect("/admin?message=Contact Created")
return
else:
#query_string = "SELECT * FROM Event"
#events_list = db.GqlQuery(query_string)
suggested_password = random_password.generate_password()
query_string = "SELECT * FROM Organization"
organization_list = db.GqlQuery(query_string)
self.response.out.write(template.render(
{
"form": data,
"errors": data.errors,
"create_contact": True,
"organization_list": organization_list,
}))
return
if self.request.get("create_admin"):
data = organization.OrganizationAdminForm(self.request.POST)
event_id = self.request.get("choose_event")
try:
id = int(event_id)
except:
return
this_event = event_db.Event.get_by_id(id)
if local_admin:
if not this_event.key() == event.key():
self.redirect("/")
return
if data.validate():
new_org = organization.Organization(name = data.name.data,
email = data.email.data,
phone = data.phone.data,
address = data.address.data,
city = data.city.data,
state = data.state.data,
zip_code = data.zip_code.data,
physical_presence = True,
number_volunteers = "0",
voad_member = False,
org_verified=True,
twitter = data.twitter.data,
url = data.url.data,
facebook = data.facebook.data,
incident = this_event.key(),
password = self.request.get("password"),
is_active = True,
is_admin = True,
)
# set all phase fields true for admin
for phase_name in new_org.get_phase_boolean_names():
setattr(new_org, phase_name, True)
new_contact = primary_contact_db.Contact(first_name = data.contact_first_name.data,
last_name = data.contact_last_name.data,
email = data.contact_email.data,
phone=data.contact_phone.data,
is_primary=True
)
organization.PutAndCacheOrganizationAndContact(organization = new_org,
contact = new_contact,
)
self.redirect("/admin?message=Admin Created")
return
else:
# needs events lists, password, errors
query_string = "SELECT * FROM Event"
events_list = db.GqlQuery(query_string)
suggested_password = random_password.generate_password()
self.response.out.write(template.render(
{
"form": data,
"errors": data.errors,
"create_admin": True,
#"events_list": events_list,
"auto_password": suggested_password,
}))
return
if self.request.get("edit_contact_final"):
try:
id = int(self.request.get("edit_contact_final"))
except:
self.response.set_status(400)
return
org_id = None
org_key = None
# check to see if organization was edited
if self.request.get("organization") != "None":
try:
org_id = int(self.request.get("organization"))
except:
self.response.set_status(400)
return
org = organization.Organization.get_by_id(org_id)
org_key = org.key()
if local_admin:
if not org_key.incident.key() == org.incident.key():
self.redirect("/")
return
###########################
this_contact = primary_contact_db.Contact.get(db.Key.from_path('Contact', id))
if not this_contact.organization.incident.key() == org.incident.key():
self.redirect("/")
return
data = primary_contact_db.ContactFormFull(self.request.POST)
if data.validate():
contact = this_contact
contact.first_name=data.first_name.data
contact.last_name = data.last_name.data
contact.phone=data.phone.data
contact.email = data.email.data
if org_key is not None:
contact.organization = org_key
contact.is_primary=bool(data.is_primary.data)
primary_contact_db.PutAndCache(contact, ten_minutes)
self.redirect("/admin")
return
else:
try:
id = int(self.request.get("edit_contact_final"))
except:
self.response.set_status(400)
return
contact = primary_contact_db.Contact.get_by_id(id)
form = primary_contact_db.ContactFormFull(first_name = contact.first_name, last_name = contact.last_name, phone = contact.phone, email = contact.email, is_primary=int(contact.is_primary))
self.response.out.write(template.render(
{
"edit_contact_id": id,
"form": form,
"errors": data.errors
}))
return
if self.request.get("create_org"):
data = organization.OrganizationFormNoContact(self.request.POST)
is_active_bool = False
activate = self.request.get("is_active")
if activate:
is_active_bool = True
if data.validate():
# create new org
new_org_data = data.data
event = event_db.Event.get_by_id(int(data.data['choose_event']))
new_org_data['incident'] = event.key()
new_org = organization.Organization(**new_org_data)
organization.PutAndCache(new_org, ten_minutes)
else:
# show the form again
self.response.out.write(template.render(
{
"form": data,
"errors": data.errors,
"events_list": events_list,
"create_org": True,
}))
return
self.redirect("/admin")
return
if self.request.get("delete_org_id"):
try:
org_by_id = organization.Organization.get(db.Key.from_path('Organization', int(self.request.get("delete_org_id"))))
except:
self.response.set_status(400)
return
if local_admin:
if not org_by_id.incident.key() == org.incident.key():
self.redirect("/")
return
primary_contact_db.RemoveOrgFromContacts(org_by_id)
db.delete(org_by_id)
self.redirect("/admin")
return
if self.request.get("activate_organization"):
try:
id = int(self.request.get("activate_organization"))
except:
self.response.set_status(400)
return
org_by_id = organization.Organization.get(db.Key.from_path('Organization', id))
if local_admin:
if not org_by_id.incident.key() == org.incident.key():
self.redirect("/")
return
org_by_id.org_verified=True
org_by_id.is_active=True
organization.PutAndCache(org_by_id, 600)
self.redirect("/admin")
return
if self.request.get("save_org_id"):
try:
id = int(self.request.get("save_org_id"))
except:
self.response.set_status(400)
return
org_by_id = organization.Organization.get(db.Key.from_path('Organization', id))
if local_admin:
if not org_by_id.incident.key() == org.incident.key():
self.redirect("/")
return
org_by_id.org_verified=True
organization.PutAndCache(org_by_id, 600)
self.redirect("/admin")
return
if self.request.get("edit_org"):
data = organization.OrganizationEditForm(self.request.POST)
if data.validate():
try:
id = int(self.request.get("edit_org"))
except:
self.response.set_status(400)
return
org_by_id = organization.Organization.get(db.Key.from_path('Organization', id))
org_by_id.name = data.name.data
org_by_id.org_verified = bool(data.org_verified.data)
org_by_id.is_active = bool(data.is_active.data)
org_by_id.email = data.email.data
org_by_id.phone = data.phone.data
org_by_id.address = data.address.data
org_by_id.city = data.city.data
org_by_id.state = data.state.data
org_by_id.zip_code = data.zip_code.data
org_by_id.twitter = data.twitter.data
org_by_id.facebook = data.facebook.data
org_by_id.url = data.url.data
org_by_id.physical_presence = bool(data.physical_presence.data)
org_by_id.number_volunteers = data.number_volunteers.data
org_by_id.voad_member = bool(data.voad_member.data)
org_by_id.voad_referral = data.voad_referral.data
org_by_id.work_area = data.work_area.data
org_by_id.voad_member_url = data.voad_member_url.data
# phase fields
for phase_field_name in org_by_id.get_phase_boolean_names():
setattr(org_by_id, phase_field_name, bool(data[phase_field_name].data))
organization.PutAndCache(org_by_id, 600)
self.redirect("/admin")
return
else:
self.response.out.write(template.render(
{
"edit_org": True,
"form": data,
"errors": data.errors,
"org_id": int(self.request.get("edit_org")),
}))
return
def AuthenticatedPost(self, org, event):
global_admin = False
local_admin = False
if org.name == GLOBAL_ADMIN_NAME:
global_admin = True
if org.is_admin == True and global_admin == False:
local_admin = True
if global_admin == False and local_admin == False:
self.redirect("/")
return
if self.request.get("create_contact"):
data = primary_contact_db.ContactFormFull(self.request.POST)
if data.validate():
organization_id = self.request.get("choose_organization")
try:
id = int(organization_id)
except:
return
this_organization = organization.Organization.get_by_id(id)
if not org.may_administer(this_organization):
self.abort(403)
contact = primary_contact_db.Contact(
first_name=data.first_name.data,
last_name=data.last_name.data,
title=data.title.data,
phone=data.phone.data,
email=data.email.data,
is_primary=bool(data.is_primary.data),
organization=this_organization.key(),
)
primary_contact_db.PutAndCache(contact, ten_minutes)
self.redirect("/admin-create-contact?selected_org=%s&message=Contact Created" % this_organization.key().id())
return
else:
#query_string = "SELECT * FROM Event"
#events_list = db.GqlQuery(query_string)
suggested_password = random_password.generate_password()
query_string = "SELECT * FROM Organization"
organization_list = db.GqlQuery(query_string)
self.response.out.write(template.render(
{
"form": data,
"errors": data.errors,
"create_contact": True,
"organization_list": organization_list,
}))
return
if self.request.get("create_admin"):
data = organization.OrganizationAdminForm(self.request.POST)
event_id = self.request.get("choose_event")
try:
id = int(event_id)
except:
return
this_event = event_db.Event.get_by_id(id)
if local_admin:
if not this_event.key() == event.key():
self.redirect("/")
return
if data.validate():
new_org = organization.Organization(name = data.name.data,
email = data.email.data,
phone = data.phone.data,
address = data.address.data,
city = data.city.data,
state = data.state.data,
zip_code = data.zip_code.data,
physical_presence = True,
number_volunteers = "0",
voad_member = False,
org_verified=True,
twitter = data.twitter.data,
url = data.url.data,
facebook = data.facebook.data,
incidents = [this_event.key()],
password = self.request.get("password"),
is_active = True,
is_admin = True,
)
# set all phase fields true for admin
for phase_name in new_org.get_phase_boolean_names():
setattr(new_org, phase_name, True)
new_contact = primary_contact_db.Contact(
first_name=data.contact_first_name.data,
last_name=data.contact_last_name.data,
title=data.contact_title.data,
email=data.contact_email.data,
phone=data.contact_phone.data,
is_primary=True
)
organization.PutAndCacheOrganizationAndContact(organization = new_org,
contact = new_contact,
)
self.redirect("/admin?message=Admin Created")
return
else:
# needs events lists, password, errors
query_string = "SELECT * FROM Event"
suggested_password = random_password.generate_password()
self.response.out.write(template.render(
{
"form": data,
"errors": data.errors,
"create_admin": True,
#"events_list": events_list,
"auto_password": suggested_password,
}))
return
if self.request.get("delete_org_id"):
# delete organization
try:
id = int(self.request.get("delete_org_id"))
org_by_id = organization.Organization.get_by_id(id)
except:
self.abort(400)
if not org.may_administer(org_by_id):
self.abort(403)
primary_contact_db.RemoveOrgFromContacts(org_by_id)
db.delete(org_by_id)
self.redirect("/admin")
return
if self.request.get("delete_contact_id"):
# delete contact
try:
id = int(self.request.get("delete_contact_id"))
contact_by_id = primary_contact_db.Contact.get_by_id(id)
except:
self.abort(400)
if not org.may_administer(org_by_id):
self.abort(403)
db.delete(contact_by_id)
self.redirect("/admin")
return
if self.request.get("verify_organization"):
# verify organization
try:
id = int(self.request.get("verify_organization"))
org_by_id = organization.Organization.get_by_id(id)
except:
self.abort(400)
# check we are allowed
if not org.may_administer(org_by_id):
self.abort(403)
# perform verification
org_by_id.verify()
# cache
organization.PutAndCache(org_by_id, 600)
self.redirect("/admin")
return
if self.request.get("save_org_id"):
# save org (?)
try:
id = int(self.request.get("save_org_id"))
org_by_id = organization.Organization.get_by_id(id)
except:
self.abort(400)
if not org.may_administer(org_by_id):
self.abort(403)
org_by_id.org_verified = True
organization.PutAndCache(org_by_id, 600)
self.redirect("/admin")
return
