def load_countries():
"""Load countries from output.txt into database."""
print "Start loading Countries"
# Delete all rows in table, so if we need to run this a second time,
# we won't be trying to add duplicate items
Country.query.delete()
# Read file and insert data
for row in open("seed_data/output.txt"):
r = row.splitlines()
for rn in r:
name, country_id = rn.split(",")
country = Country(name=name, country_id=country_id)
# Add to the session
db.session.add(country)
# Add Soviet Union
sovu = Country(name='Soviet Union', country_id='SU')
db.session.add(sovu)
# Commit
db.session.commit()
print "Countries"
def post(self, member_no):
member = self.get_member(member_no)
member.name = self.get_required('name')
member.address = self.get_required('address')
member.zipcode = self.get_required('zip')
member.city = self.get_required('city')
country = Country.get(self.get_required('country'))
email = self.get_required('email')
if email != '':
member.email = db.Email(email)
mobile = self.get_required('mobile')
if mobile != '':
member.phone = db.PhoneNumber(mobile)
home = self.request.get('fixed')
if home != '':
member.phone_home = db.PhoneNumber(home)
work = self.request.get('work')
if work != '':
member.phone_work = db.PhoneNumber(work)
member.put()
template = JINJA_ENVIRONMENT.get_template('templates/selfservice/profile_edit.html')
countries = Country.all().order('order').fetch(FETCH_LIMIT)
data = { 'message': 'Medlemsprofilen din er oppdatert.', 'member': member, 'countries': countries }
self.response.write(template.render(data))
def post(self):
if self.request.get('store') != '1':
self.redirect('/members')
return
try:
member = Member()
member.name = self.get_var('name')
member.address = self.get_var('address')
member.zipcode = self.get_var('zip')
member.city = self.get_var('city')
member.country = Country.get(self.get_var('country'))
member.email = self.get_var('email', optional=True)
member.mobile = self.get_var('mobile', optional=True)
member.home = self.get_var('home', optional=True)
member.work = self.get_var('work', optional=True)
member.membertype = MemberType.get(self.get_var('type'))
member.notes = self.get_var('comment', optional=True)
member.status = Status.get(self.get_var('status'))
member.number = dbutils.create_new_member_no()
member.member_since = datetime.date.today()
member.generate_access_code()
mcount = self.get_var('magazine_count', optional=True)
member.magazine_count = int(mcount) if mcount else 1
member.put()
self.redirect('/members/%s/edit' % member.key())
return
except MissingField:
# TODO: Redirect
template = JINJA_ENVIRONMENT.get_template(
'templates/members/new_member.html')
countries = Country.all().order('order').fetch(LIMIT)
statuses = Status.all().order('order').fetch(LIMIT)
types = MemberType.all().order('order').fetch(LIMIT)
data = {}
for name in [
'name', 'address', 'zip', 'country', 'email', 'mobile',
'home', 'work', 'type', 'comment', 'status'
]:
data[name] = self.request.get(name)
params = {
'countries': countries,
'statuses': statuses,
'types': types,
'data': data
}
self.response.write(template.render(params))
return
self.redirect('/members')
def get(self):
countryname = self.request.get("name")
if countryname == "all":
country_query = Country.query()
elif countryname == "list":
country_query = Country.query(projection=[Country.Name])
else:
country_query = Country.query(Country.Name == countryname)
self.response.headers["Content-Type"] = "application/json"
self.response.out.write(
json.dumps(
[temp.to_dict() for temp in country_query],
default=default_json_serializer,
))
def set_country_menu(bot, update, to_edit):
uid = util.uid_from_update(update)
countries = Country.select().order_by(Country.name).execute()
buttons = util.build_menu([
InlineKeyboardButton('{} {}'.format(c.emojized, c.name),
callback_data=util.callback_for_action(
CallbackActions.SET_COUNTRY, {
'cid': c.id,
'bid': to_edit.id
})) for c in countries
], 3)
buttons.insert(0, [
InlineKeyboardButton(captions.BACK,
callback_data=util.callback_for_action(
CallbackActions.EDIT_BOT,
{'id': to_edit.id})),
InlineKeyboardButton("None",
callback_data=util.callback_for_action(
CallbackActions.SET_COUNTRY, {
'cid': 'None',
'bid': to_edit.id
})),
])
return bot.formatter.send_or_edit(
uid,
util.action_hint(
"Please select a country/language for {}".format(to_edit)),
to_edit=util.mid_from_update(update),
reply_markup=InlineKeyboardMarkup(buttons))
def get(self):
template = JINJA_ENVIRONMENT.get_template(
'templates/members/member_list.html')
countries = Country.all().order('order').fetch(LIMIT)
statuses = Status.all().order('order').fetch(LIMIT)
types = MemberType.all().order('order').fetch(LIMIT)
# TODO: Make sensible
query_string = ''
current_search = self.request.get('search')
query_string += current_search
current_status = self.request.get('status')
if current_status != '':
if query_string != '':
query_string += ' AND '
query_string += 'status:' + current_status
current_type = self.request.get('type')
if current_type != '':
if query_string != '':
query_string += ' AND '
query_string += 'type:' + current_type
current_country = self.request.get('country')
if current_country and current_country != '':
if query_string != '':
query_string += ' AND '
query_string += 'country:' + current_country
index = search.Index(name='members')
result = index.search(query=search.Query(
query_string, options=search.QueryOptions(limit=LIMIT)))
members = list()
for document in result.results:
members.append(Member.search_member_from_document(document))
members = sorted(members, key=lambda x: x.number)
current_status_name = current_status
current_type_name = current_type
total = memcache.get('member_count')
if not total:
total = 0
data = {
'countries': countries,
'statuses': statuses,
'types': types,
'members': members,
'current_status': current_status,
'current_type': current_type,
'current_search': current_search,
'found': result.number_found,
'shown': len(members),
'total': total
}
self.response.write(template.render(data))
def post(self):
if self.request.get('store') != '1':
self.redirect('/members')
return
try:
member = Member()
member.name = self.get_var('name')
member.address = self.get_var('address')
member.zipcode = self.get_var('zip')
member.city = self.get_var('city')
member.country = Country.get(self.get_var('country'))
member.email = self.get_var('email', optional=True)
member.mobile = self.get_var('mobile', optional=True)
member.home = self.get_var('home', optional=True)
member.work = self.get_var('work', optional=True)
member.membertype = MemberType.get(self.get_var('type'))
member.notes = self.get_var('comment', optional=True)
member.status = Status.get(self.get_var('status'))
member.number = dbutils.create_new_member_no()
member.member_since = datetime.date.today()
member.generate_access_code()
mcount = self.get_var('magazine_count', optional=True)
member.magazine_count = int(mcount) if mcount else 1
member.put()
self.redirect('/members/%s/edit' % member.key())
return
except MissingField:
# TODO: Redirect
template = JINJA_ENVIRONMENT.get_template('templates/members/new_member.html')
countries = Country.all().order('order').fetch(LIMIT)
statuses = Status.all().order('order').fetch(LIMIT)
types = MemberType.all().order('order').fetch(LIMIT)
data = { }
for name in [ 'name', 'address', 'zip', 'country', 'email', 'mobile', 'home', 'work', 'type', 'comment', 'status']:
data[name] = self.request.get(name)
params = {
'countries': countries,
'statuses': statuses,
'types': types,
'data': data
}
self.response.write(template.render(params))
return
self.redirect('/members')
def apply(self):
try:
if self.subject is None:
self.delete_instance()
return False
except Bot.DoesNotExist:
self.delete_instance()
return False
if self.action == 'category':
from model import Category
try:
cat = Category.get(Category.id == self.value)
self.subject.category = cat
except Category.DoesNotExist:
raise AttributeError("Category to change to does not exist.")
elif self.action == 'name':
self.subject.name = self.value
elif self.action == 'username':
self.subject.username = self.value
elif self.action == 'description':
self.subject.description = self.value
elif self.action == 'extra':
self.subject.extra = self.value
elif self.action == 'country':
if self._value == 'None' or self._value is None:
self.subject.country = None
else:
from model import Country
try:
con = Country.get(id=self._value)
self.subject.country = con
except Country.DoesNotExist:
raise AttributeError(
"Country to change to does not exist.")
elif self.action == 'inlinequeries':
self.subject.inlinequeries = bool(self.value)
elif self.action == 'official':
self.subject.official = bool(self.value)
elif self.action == 'offline':
self.subject.offline = bool(self.value)
elif self.action == 'spam':
self.subject.spam = bool(self.value)
elif self.action == 'add_keyword':
kw_obj = Keyword(name=self.value, entity=self.subject)
kw_obj.save()
elif self.action == 'remove_keyword':
try:
kw_obj = Keyword.get(name=self.value, entity=self.subject)
kw_obj.delete_instance()
except Keyword.DoesNotExist:
raise AttributeError(
"Keyword to delete does not exist anymore.")
self.subject.save()
self.executed = True
self.save()
return True
def add_country(iso3, name):
"""Add a new country to db."""
country = Country(isocode3=iso3, name=name)
# db.session.add(country)
# db.session.commit()
return country
def get(self):
template = JINJA_ENVIRONMENT.get_template('templates/selfservice/signup.html')
countries = Country.all().order('order').fetch(100)
self.response.write(template.render({
'countries': countries,
'incomplete': [],
'complete': [],
'values': { } }))
def write_country_to_db(line_to_write):
if not sess.query(Country).filter_by(
country_code=line_to_write['country_code']).all():
continent = sess.query(Continent).filter_by('')
country = Country(name=line_to_write['country_full'],
country_code=line_to_write['country_code'])
sess.add(country)
sess.commit()
def get(self):
template = JINJA_ENVIRONMENT.get_template('templates/members/member_list.html')
countries = Country.all().order('order').fetch(LIMIT)
statuses = Status.all().order('order').fetch(LIMIT)
types = MemberType.all().order('order').fetch(LIMIT)
# TODO: Make sensible
query_string = ''
current_search = self.request.get('search')
query_string += current_search
current_status = self.request.get('status')
if current_status != '':
if query_string != '':
query_string += ' AND '
query_string += 'status:' + current_status
current_type = self.request.get('type')
if current_type != '':
if query_string != '':
query_string += ' AND '
query_string += 'type:'+ current_type
current_country = self.request.get('country')
if current_country and current_country != '':
if query_string != '':
query_string += ' AND '
query_string += 'country:' + current_country
index = search.Index(name='members')
result = index.search(query=search.Query(query_string, options=search.QueryOptions(limit=LIMIT)))
members = list()
for document in result.results:
members.append(Member.search_member_from_document(document))
members = sorted(members, key=lambda x: x.number)
current_status_name = current_status
current_type_name = current_type
total = memcache.get('member_count')
if not total:
total = 0
data = {
'countries': countries,
'statuses': statuses,
'types': types,
'members': members,
'current_status': current_status,
'current_type': current_type,
'current_search': current_search,
'found': result.number_found,
'shown': len(members),
'total': total
}
self.response.write(template.render(data))
def parseTable(page: str) -> List[Country]:
list = []
soup = BeautifulSoup(page, "html.parser")
codeTable = soup.find_all('table', attrs={'class':
'wikitable'})[0].find_all('tr')
for countryTable in codeTable:
country = Country()
try:
country.code = countryTable.span.text
country.name = countryTable.a.text
# country.flag_page_link = Flag(domain + countryTable.a['href']) # 需要svg格式时
country.flag_page_link = Flag(
"https:" +
countryTable.img['src'].replace("22px", "480px")) # 需要png格式
list.append(country)
except AttributeError:
pass
return list
def get(self, member_no):
member = self.get_member(member_no)
countries = Country.all().order('order').fetch(FETCH_LIMIT)
# OK - everything checks out - show edit form
template = JINJA_ENVIRONMENT.get_template('templates/selfservice/profile_edit.html')
data = { 'member': member, 'countries': countries }
self.response.write(template.render(data))
def post(self, country_key):
if (self.request.get('cancel') == '1'):
return self.redirect('/countries')
country = Country.get(country_key)
country.order = int(self.request.get('order'))
country.name = self.request.get('countryname')
country.put()
return self.redirect('/countries')
def get(self, member_no):
member = self.get_member(member_no)
countries = Country.all().order('order').fetch(FETCH_LIMIT)
# OK - everything checks out - show edit form
template = JINJA_ENVIRONMENT.get_template(
'templates/selfservice/profile_edit.html')
data = {'member': member, 'countries': countries}
self.response.write(template.render(data))
def write_countrydb(countries):
"""Write country names and codes to database using countries dictionary"""
for country in countries:
dbcountry = Country(country_code=countries[country],
country_name=country)
db.session.add(dbcountry)
db.session.commit()
def display():
print("List of countries:")
[print(
" -",
country,
) for country in Country.get_names()]
print("List of cities:")
[print(
" -",
city,
) for city in City.get_names()]
def get(self):
template = JINJA_ENVIRONMENT.get_template(
'templates/selfservice/signup.html')
countries = Country.all().order('order').fetch(100)
self.response.write(
template.render({
'countries': countries,
'incomplete': [],
'complete': [],
'values': {}
}))
def get(self):
template = JINJA_ENVIRONMENT.get_template('templates/members/new_member.html')
countries = Country.all().order('order').fetch(LIMIT)
statuses = Status.all().order('order').fetch(LIMIT)
types = MemberType.all().order('order').fetch(LIMIT)
data = {
'countries': countries,
'statuses': statuses,
'types': types,
'data': None
}
self.response.write(template.render(data))
def get(self):
template = JINJA_ENVIRONMENT.get_template(
'templates/members/new_member.html')
countries = Country.all().order('order').fetch(LIMIT)
statuses = Status.all().order('order').fetch(LIMIT)
types = MemberType.all().order('order').fetch(LIMIT)
data = {
'countries': countries,
'statuses': statuses,
'types': types,
'data': None
}
self.response.write(template.render(data))
def post(self, member_no):
member = self.get_member(member_no)
member.name = self.get_required('name')
member.address = self.get_required('address')
member.zipcode = self.get_required('zip')
member.city = self.get_required('city')
country = Country.get(self.get_required('country'))
email = self.get_required('email')
if email != '':
member.email = db.Email(email)
mobile = self.get_required('mobile')
if mobile != '':
member.phone = db.PhoneNumber(mobile)
home = self.request.get('fixed')
if home != '':
member.phone_home = db.PhoneNumber(home)
work = self.request.get('work')
if work != '':
member.phone_work = db.PhoneNumber(work)
member.put()
member.update_index()
template = JINJA_ENVIRONMENT.get_template(
'templates/selfservice/profile_edit.html')
countries = Country.all().order('order').fetch(FETCH_LIMIT)
data = {
'message': 'Medlemsprofilen din er oppdatert.',
'member': member,
'countries': countries
}
self.response.write(template.render(data))
def load_currency():
"""Load country & currency data from u.country into travelers db"""
for i, row in enumerate(open("seed_data/u.country_code")):
row = row.rstrip()
country_name, country_code, currency_name, currency_code = row.split(
",")
country = Country(country_name=country_name,
country_code=country_code,
currency_name=currency_name,
currency_code=currency_code)
db.session.add(country)
db.session.commit()
def post(self):
json_data = request.get_json(force=True)
if json_data is None:
return {'message': 'No input data provided'}, 400
data, errors = country_schema.load(json_data)
if errors:
return errors, 422
country = Country.query.filter_by(name=data['name']).first()
if country:
return {'message': 'Country already exists'}, 400
country = Country(name=json_data['name'])
db.session.add(country)
db.session.commit()
result = country_schema.dump(country).data
return {'status': 'success', 'data': result}, 200
def import_countries(self, country_csv):
countries = []
lines = country_csv.split('\n')
for line in lines:
if len(line.strip()) > 0:
fields = line.split(';')
country = Country()
country.order = int(fields[0])
country.name = fields[1].strip()
country.local_name = fields[2].strip()
country.put()
countries.append(country)
return countries
def get(self):
country_query = Country.query()
region = self.request.get("Region")
if region != "all":
country_query = country_query.filter(
Country.Region.IN(region.split("|")))
population = self.request.get("Population")
if population != "all" and country_query.fetch() != []:
listOfEle = population.split("|")
listOFKey = []
for rang in listOfEle:
if rang == "0-100":
temp = country_query.filter(
Country.Population < 100).fetch(keys_only=True)
elif rang == "100-500":
temp = country_query.filter(
Country.Population < 500,
Country.Population >= 100).fetch(keys_only=True)
else:
temp = country_query.filter(
Country.Population >= 500).fetch(keys_only=True)
listOFKey += temp
country_query = ndb.get_multi(listOFKey)
totalProduce = self.request.get("Total_Production")
if totalProduce != "all" and country_query != []:
listOfEle = totalProduce.split("|")
listOFResult = []
for rang in listOfEle:
for each in country_query:
if rang == "0-1000" and each.Total_Production < 1000:
listOFResult.append(each)
elif (rang == "1000-2000" and each.Total_Production < 2000
and each.Total_Production >= 1000):
listOFResult.append(each)
elif rang == ">2000" and each.Total_Production >= 2000:
listOFResult.append(each)
country_query = listOFResult
self.response.headers["Content-Type"] = "application/json"
self.response.out.write(
json.dumps(
[temp.to_dict() for temp in country_query],
default=default_json_serializer,
))
def _md_plaintext(self):
uname = util.escape_markdown(self.subject.username)
value = self.value
text = ''
if self.action == 'category':
from model import Category
try:
cat = Category.get(id=self.value)
text += "move {} ➜ {}".format(uname, cat.name)
except Category.DoesNotExist:
raise AttributeError("Category to change to does not exist.")
elif self.action == 'name':
text += "set name {} ➜ {}".format(uname, str(value))
elif self.action == 'username':
text += "set username {} ➜ {}".format(uname, str(value))
elif self.action == 'description':
text += "change description text of {}".format(uname)
elif self.action == 'extra':
text += "change extra text {}".format(uname)
elif self.action == 'country':
text += "change country {} ➜ ".format(uname)
if self._value == 'None' or self._value is None:
text += "None"
else:
from model import Country
try:
con = Country.get(id=self._value)
text += str(con)
except Country.DoesNotExist:
raise AttributeError(
"Country to change to does not exist.")
elif self.action == 'inlinequeries':
text += "toggle inlinequeries {} ➜ {}".format(uname, str(value))
elif self.action == 'official':
text += "toggle official {} ➜ {}".format(uname, str(value))
elif self.action == 'offline':
text += "set {} {}".format('💤' if bool(value) else 'online',
uname)
elif self.action == 'spam':
text += "mark {} as spammy".format(uname)
elif self.action == 'add_keyword':
text += "add keyword #{} to {}".format(str(value), uname)
elif self.action == 'remove_keyword':
text += "remove keyword #{} from {}".format(str(value), uname)
return text
def load_countries():
print "Countries"
url = "http://api.travelpayouts.com/data/countries.json?token={}".format(
travel_payouts_api)
r = requests.get(url)
data = r.text
results = json.loads(data)
for key in results:
country_name = key['name']
country_code = key['code']
country = Country(name=country_name, code=country_code)
db.session.add(country)
db.session.commit()
def value(self):
# cast types
from model import Category
from model import Country
if self._value == 'None':
return None
if self.action in self.BOOLEAN_ACTIONS:
return bool(self._value)
elif self.action == 'category':
return Category.get(id=self._value)
elif self.action == 'country':
if self._value is None:
return None
return Country.get(id=self._value)
else:
return str(self._value) if self._value else None
def get(self, member_id):
template = JINJA_ENVIRONMENT.get_template('templates/members/member_detail.html')
countries = Country.all().order('order').fetch(LIMIT)
statuses = Status.all().order('order').fetch(LIMIT)
types = MemberType.all().order('order').fetch(LIMIT)
member = Member.get(member_id)
dues = MembershipDues.all().ancestor(member).fetch(25)
current_year = datetime.datetime.now().year
self.add_missing_dues(dues, max(config.FIRST_YEAR_WITH_DUES, member.member_since.year), current_year + config.DUES_AHEAD)
dues = sorted(dues, key=lambda item: item.year, reverse=True)
data = {
'countries': countries,
'statuses': statuses,
'types': types,
'member': member,
'dues': dues,
'current_year': current_year
}
self.response.write(template.render(data))
def import_countries(self, country_csv):
countries = []
lines = country_csv.split('\n')
for line in lines:
if len(line.strip()) > 0:
fields = line.split(';')
country = Country()
country.order = int(fields[0])
country.name = fields[1].strip()
country.local_name = fields[2].strip()
country.put()
countries.append(country)
return countries;
def write_to_db():
"""
Writes the results from the fetch_data function to the Sqlite Database.
If the database if already populated it updates the values for each country.
"""
collect_entries = []
for idx, c in enumerate(fetch_data(URL)):
numbers = 0
if len(c[4]) > 5:
logging.info(f'len(c[4]) < 6: {numbers}')
numbers = int(c[4].replace(',', ''))
if len(c[4]) < 5 and len(c[4]) > 1:
logging.info(f'{c[4]} between 1 and 1000')
numbers = c[4]
if len(c[4]) == 1:
logging.warning(f'{c[4]} Does not exist')
numbers = 0
# Exists or not
value = db.query(Country).filter(Country.country == c[1]).first()
if value:
value.total_cases = int(c[2].replace(',', '')) or 0
value.new_cases = int(c[3][1:].replace(',', '')) if c[3] else 0
value.total_deaths = numbers
value.new_deaths = int(c[5][1:].replace(',', '')) if c[5] else 0
else:
collect_entries.append(
Country(
country=c[1],
total_cases=int(c[2].replace(',', '')) or 0,
new_cases=int(c[3][1:].replace(',', '')) if c[3] else 0,
total_deaths=numbers,
new_deaths=int(c[5][1:].replace(',', '')) if c[5] else 0,
population=int(c[13].replace(',', ''))
if ',' in c[13] else 0))
db.add_all(collect_entries)
db.commit()
db.close()
def get(self, member_id):
template = JINJA_ENVIRONMENT.get_template(
'templates/members/member_detail.html')
countries = Country.all().order('order').fetch(LIMIT)
statuses = Status.all().order('order').fetch(LIMIT)
types = MemberType.all().order('order').fetch(LIMIT)
member = Member.get(member_id)
dues = MembershipDues.all().ancestor(member).fetch(25)
current_year = datetime.datetime.now().year
self.add_missing_dues(
dues, max(config.FIRST_YEAR_WITH_DUES, member.member_since.year),
current_year + config.DUES_AHEAD)
dues = sorted(dues, key=lambda item: item.year, reverse=True)
data = {
'countries': countries,
'statuses': statuses,
'types': types,
'member': member,
'dues': dues,
'current_year': current_year
}
self.response.write(template.render(data))
def load_countries():
Country.query.delete()
for row in open("country_data_geo.csv"):
row = row.rstrip()
items = row.split(",")
country_code = items[0]
country_code = country_code.replace('"','')
country_name = items[1]
country_name = country_name.replace('"', '')
country_lat = float(items[2])
country_long = float(items[3])
country = Country(country_code=country_code,
country_name=country_name,
country_lat=country_lat,
country_long=country_long)
db.session.add(country)
db.session.commit()
print("countries loaded")
def create_missing_country_city():
to_save = []
cnt_added = 0
city_add = 0
with open('../../data/json/finale.json') as ffop:
data = json.load(ffop)
for line in data:
if 'continent_code' in line.keys():
if not sess.query(Country).filter_by(
country_code=line['country_code']).all():
continent = sess.query(Continent).filter_by(
continent_code=line['continent_code']).all()[0]
continent_id = continent.id
country = Country(name=line['country_full'],
country_code=line['country_code'],
continent_id=continent_id)
sess.add(country)
sess.commit()
print('Added a country:', line['country_full'])
cnt_added += 1
print(cnt_added)
else:
country = sess.query(Country).filter_by(
country_code=line['country_code']).all()[0]
city = City(name=line['city_name'],
city_id=line['city_id'],
country_id=country.id,
lat=line['lat'],
lon=line['lon'])
city_add += 1
to_save.append(city)
print('Added a city:', line['city_name'])
print(city_add)
sess.bulk_save_objects(to_save)
sess.commit()
def load_countries():
# open csv file (us_states)
d3worldfile = open("data/d3_world_data.csv")
#read each line
for line in d3worldfile:
# split on "," --> list
line_list = line.split("|")
# each item in list --> remove whitespace .strip()
for i in range(len(line_list)):
line_list[i] = line_list[i].strip()
country_id, country_name = line_list[0], line_list[1]
print "COUNTRY_ID: %s, COUNTRY_NAME: %s" % (country_id, country_name)
# # make State(....) object
country = Country(country_id=country_id, country_name=country_name)
# add to session
db.session.add(country)
# commit session
db.session.commit()
debug()
def post(self):
template = JINJA_ENVIRONMENT.get_template(
'templates/loader/loader.html')
content = self.request.get('type')
countries = []
if content == 'countries.csv':
countries = self.import_countries(self.request.get('data'))
statuses = []
if content == 'status.csv':
statuses = self.import_statuses(self.request.get('data'))
types = []
if content == 'types.csv':
types = self.import_types(self.request.get('data'))
if content == 'member.csv':
self.statuslist = Status.all().fetch(100)
self.typelist = MemberType.all().fetch(100)
self.countrylist = Country.all().fetch(100)
self.import_members(self.request.get('data'))
if content == 'model_ranges.csv':
self.import_model_range(self.request.get('data'))
if content == 'car_models.csv':
self.import_car_models(self.request.get('data'))
if content == 'cars.csv':
self.import_member_cars(self.request.get('data'))
if content == 'users.csv':
self.import_users(self.request.get('data'))
self.response.write(template.render())
def install():
Base.metadata.create_all(Session().bind)
data = [('Chicago', 'United States', ('60601', '60602', '60603', '60604')),
('Montreal', 'Canada', ('H2S 3K9', 'H2B 1V4', 'H7G 2T8')),
('Edmonton', 'Canada', ('T5J 1R9', 'T5J 1Z4', 'T5H 1P6')),
('New York', 'United States', ('10001', '10002', '10003', '10004',
'10005', '10006')),
('San Francisco', 'United States', ('94102', '94103', '94104',
'94105', '94107', '94108'))]
countries = {}
all_post_codes = []
for city, country, postcodes in data:
try:
country = countries[country]
except KeyError:
countries[country] = country = Country(country)
city = City(city, country)
pc = [PostalCode(code, city) for code in postcodes]
Session.add_all(pc)
all_post_codes.extend(pc)
for i in xrange(1, 51):
person = Person(
"person %.2d" % i,
Address(street="street %.2d" % i,
postal_code=all_post_codes[random.randint(
0,
len(all_post_codes) - 1)]))
Session.add(person)
Session.commit()
# start the demo fresh
Session.remove()
def post(self):
template = JINJA_ENVIRONMENT.get_template('templates/loader/loader.html')
content = self.request.get('type')
countries = []
if content == 'countries.csv':
countries = self.import_countries(self.request.get('data'))
statuses = []
if content == 'status.csv':
statuses = self.import_statuses(self.request.get('data'))
types = []
if content == 'types.csv':
types = self.import_types(self.request.get('data'))
if content == 'member.csv':
self.statuslist = Status.all().fetch(100)
self.typelist = MemberType.all().fetch(100)
self.countrylist = Country.all().fetch(100)
self.import_members(self.request.get('data'))
if content == 'model_ranges.csv':
self.import_model_range(self.request.get('data'))
if content == 'car_models.csv':
self.import_car_models(self.request.get('data'))
if content == 'cars.csv':
self.import_member_cars(self.request.get('data'))
if content == 'users.csv':
self.import_users(self.request.get('data'))
self.response.write(template.render())
def get(self, country_key):
template = JINJA_ENVIRONMENT.get_template('templates/countries/detail.html')
country = Country.get(country_key)
data = { 'country_key': country_key, 'country': country }
self.response.write(template.render(data))
def get(self):
template = JINJA_ENVIRONMENT.get_template('templates/countries/list.html')
countries = Country.all().order('order').fetch(500)
data = { 'countries' : countries, 'counter': DataStoreCounter() }
self.response.write(template.render(data))
def task_country_restore(items):
for item in items:
country = Country(key_name=item['countryId'])
country.order = item['order']
country.name = item['name']
country.put()
def post(self, member_id):
if self.request.get('cancel') == '1':
return self.redirect('/members')
if self.request.get('operation') == 'delete_car':
car = Car.get(self.request.get('car_key'))
if car:
car.delete()
return self.redirect('/members/' + member_id + '/edit')
member = Member.get(member_id)
if self.request.get('operation') == 'new_car':
car = Car()
car.member = member
car.model = dbutils.get_default_model()
car.registration = ''
car.year = 0
car.notes = ''
car.serial_no = ''
car.put()
return self.redirect('/members/' + member_id + '/car/' + str(car.key()) + '/edit' )
member.name = self.request.get('name')
member.address = self.request.get('address')
member.zipcode = self.request.get('zip')
member.city = self.request.get('city')
member.country = Country.get(self.request.get('country'))
phone = self.request.get('mobile').strip()
if phone != '':
member.phone = db.PhoneNumber(phone)
else:
member.phone = None
email = self.request.get('email').strip()
if email != '':
member.email = db.Email(email)
else:
member.email = None
home = self.request.get('fixed').strip()
if home != '':
member.phone_home = db.PhoneNumber(home)
else:
member.phone_home = None
work = self.request.get('work').strip()
if work != '':
member.phone_work = db.PhoneNumber(work)
else:
member.phone_work = None
member.membertype = MemberType.get(self.request.get('type'))
member.status = Status.get(self.request.get('status'))
member.notes = self.request.get('note')
if self.request.get('access_code') == '':
member.generate_access_code()
if self.request.get('magazine_count') != '':
try:
member.magazine_count = int(self.request.get('magazine_count'))
except ValueError:
pass
member.put()
member.update_index()
# save membership dues
self.save_dues(member)
return self.redirect('/members')
def post(self):
complete = []
incomplete = []
values = {}
# Holy crap this is ugly. There has to be a better way.
name = self.request.get('name')
if not name or name.strip() == '':
incomplete.append('name')
else:
values['name'] = name
complete.append('name')
address = self.request.get('address')
if not address or address.strip() == '':
incomplete.append('address')
else:
values['address'] = address
complete.append('address')
zipcode = self.request.get('zip')
if (not zipcode or zipcode.strip() == '') or len(zipcode.strip()) < 4:
incomplete.append('zip')
else:
values['zip'] = zipcode
complete.append('zip')
city = self.request.get('city')
if not city or city.strip() == '':
incomplete.append('city')
else:
values['city'] = city
complete.append('city')
if 'zip' in incomplete or 'city' in incomplete:
incomplete.append('zipcity')
country_key = self.request.get('country').strip()
country = Country.get(country_key)
countries = Country.all().order('order').fetch(100)
if not country or not country_key or country_key.strip() == '':
incomplete.append('country')
# retrieve countries since we're going to need them
else:
values['country'] = country.name
complete.append('country')
email = self.request.get('email')
if not email or email.strip() == '' or not mail.is_email_valid(email):
incomplete.append('email')
else:
values['email'] = email
complete.append('email')
mobile = self.request.get('mobile')
if mobile and mobile.strip() == '':
mobile = None
values['mobile'] = mobile
home = self.request.get('home')
if home and home.strip() == '':
home = None
values['home'] = home
work = self.request.get('work')
if work and work.strip() == '':
work = None
values['work'] = work
member_type = self.request.get('type')
if not member_type or member_type.strip() == '':
member_type = '1'
types = MemberType.all().fetch(100)
mtype = None
# TODO: Custom settings? Constants at least.
if member_type == '1':
mtype = next(t for t in types if t.name == DEFAULT_MEMBER_NAME)
else:
mtype = next(t for t in types if t.name == DEFAULT_SUPPORT_MEMBER_NAME)
values['type'] = mtype.name
comment = self.request.get('comment')
complete.append('comment')
values['comment'] = comment
error_message = ''
# Check if member exists;
existing = Member.all().filter('email', email).fetch(1)
if len(existing) > 0:
incomplete.append('email')
error_message = 'Det er allerede registrert noen i medlemsregisteret med denne epostadressen!'
# TODO: Error message
if len(incomplete) > 0:
# missing field, redirect to signup page again
template = JINJA_ENVIRONMENT.get_template('templates/selfservice/signup.html')
return self.response.write(template.render({
'countries': countries,
'incomplete': incomplete,
'complete': complete,
'error_message': error_message,
'values': values }))
# invariant: fields are OK, create new member, send mail,
# create payment history on member.
template = JINJA_ENVIRONMENT.get_template('templates/selfservice/signup_receipt.html')
data = {
'values': values,
'profile_url': PROFILE_URL
}
statuses = Status.all().fetch(100)
# TODO: Handle existing members signing up again
new_member = Member()
new_member.name = name
new_member.address = address
new_member.zipcode = zipcode
new_member.city = city
new_member.notes = comment
new_member.country = country
new_member.membertype = mtype
status = next(s for s in statuses if s.name == SIGNUP_STATUS_NAME)
new_member.status = status
new_member.number = dbutils.create_new_member_no()
new_member.email = email
new_member.member_since = datetime.date.today()
if mobile:
new_member.phone = mobile
if work:
new_member.phone_work = work
if home:
new_member.phone_home = home
new_member.generate_access_code()
new_member.member_since = datetime.date.today()
new_member.member_type = mtype
new_member.put()
self.send_welcome_mail(new_member)
self.send_notification_mails(new_member)
# TODO: Invalidate counts for categories
# Handle mutations on members gracefully
return self.response.write(template.render(data))
