def test_create_users_table():
    """Assert the correct contents of the users table table."""
    # Create database.
    db_filename = 'test_create_users_table.sqlite'
    test_database = sqlite3.connect(db_filename)
    cursor = test_database.cursor()

    users_filename = 'test_user_data.txt'
    user_data_packages = read_file.get_data(users_filename, package_size=3)
    user_data_rows = [create_database.unpack_user_data(user_data_package)
                      for user_data_package in user_data_packages]
    create_database.create_users_table(cursor, user_data_rows)

    # Check users table.
    statement = """SELECT *
                       FROM users
                       WHERE username =?"""
    assert database.query(statement, 'coit125', cursor) == (u'coit125',
                                                            u'american',
                                                            u'01/25/1984')
    assert database.query(statement, 'bcummberbatch', cursor) == (u'bcummberbatch',
                                                                  u'british',
                                                                  u'04/21/1978')
    assert database.query(statement, 'orangelover1107', cursor) == (u'orangelover1107',
                                                                    u'south korean',
                                                                    u'11/07/1983')

    test_database.close()
Esempio n. 2
0
def main(cursor):
	team			= int(common.get_val("team", 0))
	name			= common.get_val("name", 0)
	city_location	= common.get_val("city_location", 0)
	text_location	= common.get_val("text_location", "")
	army_type		= int(common.get_val("type", 0))
	
	actual_x = 0
	actual_y = 0
	
	if text_location != "":
		actual_x = re.search(r"(-?[0-9]+)[,:] ?(-?[0-9]+)", text_location).groups()[0]
		actual_y = re.search(r"(-?[0-9]+)[,:] ?(-?[0-9]+)", text_location).groups()[1]
	else:
		the_city = city_q.get_one_city(city_location)
		
		actual_x = the_city['x']
		actual_y = the_city['y']
	
	database.query(cursor,
		army_f.new_army(name, team, actual_x, actual_y, army_type=army_type))
	
	# Redirect
	page_data['Redirect'] = 'list_armies&team={0:d}'.format(team)
	return ""
Esempio n. 3
0
def main(cursor):
	city_id = int(common.get_val('city', -1))
	the_city = city_q.get_one_city(cursor, city_id)
	database.query(cursor, city_f.delete_city(city_id))
	
	# Redirect
	page_data['Redirect'] = 'list_cities&team={0:d}'.format(the_city.team)
Esempio n. 4
0
def main(cursor):
	unit_id = int(common.get_val('unit', -1))
	the_unit = unit_q.get_one_unit(cursor, unit_id)
	database.query(cursor, unit_f.delete_unit(unit_id))
	
	# Redirect
	page_data['Redirect'] = 'list_units&team={0:d}'.format(the_unit.team)
Esempio n. 5
0
    def LoadFoldersAndFeeds(self):
        try:
            database.lock()

            folders = database.query("select id, parent, name from folders order by ordering")
            self.folder_mapping = mapping = { }
            noparent = [ ]
            for folder in folders:
                if folder[2] == None:
                    mapping[folder[0]] = self.feed_root
                else:
                    noparent.append(folder)
            while len(noparent) > 0:
                stillnoparent = [ ]
                for folder in noparent:
                    if mapping.has_key(folder[1]):
                        self.AddFolderToTree(*folder)
                    else:
                        stillnoparent.append(folder)
                noparent = stillnoparent

            feeds = database.query("select id, folder, name, url from feeds order by ordering")
            for feedinfo in feeds:
                self.AddFeedToTree(*feedinfo)
        finally:
            database.unlock()
Esempio n. 6
0
def main(cursor):
    army_id = int(common.get_val("army", -1))
    the_army = army_q.get_one_army(cursor, army_id)
    database.query(cursor, army_f.make_delete_query(army_id))

    # Redirect
    page_data["Redirect"] = "list_armies&team={0:d}".format(the_army.team)
def test_create_date_formats_table():
    """Assert the correct contents of the users table table."""
    # Create database.
    db_filename = 'test_create_date_formats_table.sqlite'
    test_database = sqlite3.connect(db_filename)
    cursor = test_database.cursor()

    date_formats_filename = 'test_date_formats.txt'
    date_format_data_packages = read_file.get_data(date_formats_filename, package_size=1)
    date_format_data_rows = [create_database.unpack_date_format_data(date_format_data_package)
                             for date_format_data_package in date_format_data_packages]
    create_database.create_date_formats_table(cursor, date_format_data_rows)

    # Check date_formats table.
    statement = """SELECT *
                       FROM date_formats
                       WHERE nationality =?"""
    assert database.query(statement, 'american', cursor) == (u"american",
                                                             u"{month}/{day}/{year}")
    assert database.query(statement, 'british', cursor) == (u"british",
                                                            u"{day}/{month}/{year}")
    assert database.query(statement, 'south korean', cursor) == (u"south korean",
                                                                 u"{year}/{month}/{day}")

    test_database.close()
Esempio n. 8
0
def main(cursor):
	campaign	= int(common.get_val("campaign", 0))
	location	= common.get_val("location", "")
	team		= int(common.get_val("team", 0))
	
	# Get location
	result = battle.battle_coords.search(location)
	if result != None:
		x = int(result.groups()[0])
		y = int(result.groups()[1])
	else:
		# Get it from the last battle
		last_battle = battle_q.get_last_battle_from_campaign(cursor, campaign)
		if last_battle == None: return ""
		
		x = last_battle.x
		y = last_battle.y
	
	# Get armies
	armies = campaign_q.get_armies_from_campaign_from_team(cursor, campaign, team)	
	
	# Move them
	database.query(cursor,
		army_f.move_armies(armies, (x, y)))
	
	page_data['Redirect'] = "list_battles&campaign={0}".format(campaign)
	return ""
Esempio n. 9
0
def add_file_cert_mapping(filename, certname):
    query(
        '''
        insert into {}
        values ("{}", "{}")
        '''.format(DB_TABLENAME_FILES, filename, certname)
    )
Esempio n. 10
0
def main(cursor):
	team_id = int(common.get_val("team", 0))
	default_border = int(common.get_val("default_border_state", 0))
	
	team_dict = team_q.get_real_active_teams(cursor, skip_irs=False)
	the_team = team_dict[team_id]
	
	queries = [
		"DELETE FROM team_borders WHERE host = %d" % team_id,
		"UPDATE teams SET default_borders = %d WHERE id = %d;" % (default_border, team_id),
	]
	insertions = []
	
	# Get a list of states
	for t, other_team in team_dict.items():
		if t == the_team.id: continue
		
		state = int(common.get_val("border_state_%d" % t, -1))
		if state >= 0:
			insertions.append("(%d, %d, %d)" % (team_id, t, state))
	
	# Add insertions to list
	if len(insertions) > 0:
		queries.append("INSERT INTO team_borders (host, visitor, state) values %s;" % ",".join(insertions))
		
	# print("")
	# print(common.print_post_data())
	# print("<br /><br />")
	# print("<br />".join(queries))
	# exit()
	
	database.query(cursor, queries)
	
	page_data['Redirect'] = 'view_borders&team={0:d}'.format(team_id)
	return ""
Esempio n. 11
0
def main(cursor):
	op_id = int(common.get_val('operative', -1))
	the_op = operative_q.get_one_operative(cursor, op_id)
	database.query(cursor, operative_f.kill_operative(op_id))
	
	# Redirect
	page_data['Redirect'] = 'list_operatives&team={0:d}'.format(the_op.team)
Esempio n. 12
0
def record_resources(the_world, the_team):
	"""Records the end of turn resources for the team"""
	the_team.get_resources(the_world.cursor, force_requery=True)
	
	strings = []
	
	for res_id, r in enumerate(resource_list.data_list):
		if res_id not in the_team.resources.value: continue
		if the_team.resources.value[res_id] == 0: continue
		if r.reset: continue
		
		res_value = the_team.resources.value[res_id]
		
		# Typecast if we can
		if res_value == int(res_value):
			res_value = int(res_value)
		
		strings.append("%s:%s" % (r.name, res_value))
	
	# Log previous resources
	database.query(the_world.cursor, 
		log_f.new_log("team_f.record_resources", ",".join(strings), "", team = the_team.id)
	)
	
	query = """UPDATE teams SET previous_resources = '%s' WHERE id = %d;""" % (database.escape(",".join(strings)), the_team.id)
	try: the_world.cursor.execute(query)
	except Exception as e:
		raise Exception("Database error: %s\nQuery: %s" % (str(e.args[0]).replace("\n",""), query))
Esempio n. 13
0
def next_func(args,u413):
	context=u413.user.context.split(' ')
	if context[0]=='BOARD':
		if context[1]=='ALL':
			context[1]=0
			pages=int(db.query("SELECT COUNT(*) FROM posts WHERE topic=TRUE AND parent IN (SELECT id FROM boards WHERE onall=TRUE);")[0]["COUNT(*)"])
			if pages==0:
				pages=1
			else:
				pages=math.ceil(pages/10.0)
			page=1
			if len(context)>2:
				page=int(context[2])
			if page<pages:
				page+=1
			command.respond(context[0]+' '+str(context[1])+' '+str(page),u413)
			return
	if context[0] in ['BOARD','TOPIC']:
		pages=int(db.query("SELECT COUNT(*) FROM posts WHERE parent=%i;"%int(context[1]))[0]["COUNT(*)"])
		if pages==0:
			pages=1
		else:
			pages=math.ceil(pages/10.0)
		page=1
		if len(context)>2:
			page=int(context[2])
		if page<pages:
			page+=1
		command.respond(context[0]+' '+str(context[1])+' '+str(page),u413)
	else:
		u413.type('"NEXT" is not a valid command or is not available in the current context.')
Esempio n. 14
0
def add_file_key_mapping(filename, key_hash):
    query(
        '''
        insert into {}
        values ("{}", "{}")
        '''.format(DB_TABLENAME_KEYS, filename, key_hash)
    )
Esempio n. 15
0
def produce_resources(the_world, the_team):
	"""Produces resources for the coming turn"""
	# Get production
	upkeep_cost = get_upkeep(the_team, the_world)
	database.query(the_world.cursor, 
		log_f.new_log("team_f.get_upkeep", "Upkeep: %s" % upkeep_cost, "", team = the_team.id)
	)
	
	produced_resources, new_resources = rules.team_rules.produce_resources(
		the_world.cursor, the_team, the_world=the_world
	)
	
	# Log production
	database.query(the_world.cursor, 
		log_f.new_log("team_f.produce_resources", "Produced: %s\nNew: %s" % (str(produced_resources), str(new_resources)), "", team = the_team.id)
	)
	
	# Apply upkeep
	new_resources -= "Materials:%s" % upkeep_cost
	
	queries = new_resources.make_set_queries(the_team.id)
	
	from functions import queries_f
	
	for q in queries:
		try:
			queries_f.log_query(the_world.cursor, q, subject="Pre orders resources")
			the_world.cursor.execute(q)
		except Exception as e:
			print("Query: %s\n" % q)
			raise e
	
	return queries
Esempio n. 16
0
def add_filesize(filename, filesize):
    query(
        '''
        insert into {}
        values ("{}", "{}")
        '''.format(DB_TABLENAME_SIZES, filename, filesize)
    )
Esempio n. 17
0
def main(cursor):
	squad_id = int(common.get_val('squad', -1))
	the_squad = squad_q.get_one_squad(cursor, squad_id)
	database.query(cursor, squad_f.make_delete_query(squad_id))
	
	# Redirect
	page_data['Redirect'] = 'edit_army&army={0:d}'.format(the_squad.army)
Esempio n. 18
0
def topic_func(args,u413):
	params=args.split(' ',2)
	if len(params)==0 or not util.isint(params[0]):
		u413.type("Invalid topic ID.")
		return
	topic=int(params[0])
	if len(params)==1:
		page=1
		output_page(topic,1,u413)
	elif len(params)==2:
		if params[1].upper()=="REPLY":
			u413.j["Command"]="REPLY"
			u413.cmddata["topic"]=topic
			u413.continue_cmd()
		else:
			page=1
			if util.isint(params[1]):
				page=int(params[1])
			elif params[1].upper()=='LAST':
				page=db.count_posts(topic)
				if page==0:
					page=1
				else:
					page=math.ceil(page/10.0)
			output_page(topic,page,u413)
	elif params[1].upper()=="REPLY":
		db.query("INSERT INTO posts (topic,title,parent,owner,editor,post,locked,edited,posted) VALUES(FALSE,'',%i,%i,0,'%s',FALSE,NULL,NOW());"%(topic,u413.user.userid,db.escape(util.htmlify(params[3]))))
		u413.type("Reply made successfully.")
Esempio n. 19
0
def main(cursor):
	battle_id = int(common.get_val('battle', -1))
	the_battle = battle_q.get_one_battle(cursor, battle_id)
	database.query(cursor, battle_f.make_delete_query(battle_id))
	
	# Redirect
	page_data['Redirect'] = 'list_battles&campaign={0:d}'.format(the_battle.campaign)
Esempio n. 20
0
	def handle_change(self, thread_name, check_id, check_name, lock_uid, status, check_result):
		if status == 'offline':
			updown = 'down'
		elif status == 'online':
			updown = 'up'

		safe_print("[%s] ... confirmed, target is %s state now", (thread_name, status))
		update_result = database.query("UPDATE checks SET status = %s, confirmations = 0, `lock` = '', last_checked = NOW() WHERE id = %s AND `lock` = %s", (status, check_id, lock_uid))

		if update_result.rowcount == 1:
			# we still had the lock at the point where status was toggled
			# then, send the alert
			alert_result = database.query("SELECT contacts.id, contacts.type, contacts.data FROM contacts, alerts WHERE contacts.id = alerts.contact_id AND alerts.check_id = %s AND alerts.type IN ('both', %s)", (check_id, updown))

			for alert_row in alert_result.fetchall():
				safe_print("[%s] ... alerting contact %d", (thread_name, alert_row['id']))
				alert_func = getattr(alerts, alert_row['type'], None)

				if not alert_func:
					util.die("Invalid alert handler [%s]!" % (alert_row['type']))

				# build context
				context = {}
				context['check_id'] = check_id
				context['check_name'] = check_name
				context['contact_id'] = alert_row['id']
				context['title'] = "Check %s: %s" % (status, check_name)
				context['status'] = status
				context['updown'] = updown
				context['message'] = check_result['message']

				alert_func(util.decode(alert_row['data']), context)

			# also add an event
			database.query("INSERT INTO check_events (check_id, type) VALUES (%s, %s)", (check_id, updown))
Esempio n. 21
0
def update_file_cert_mapping(filename, new_certname):
    query(
        '''
        update {}
        set attr = "{}"
        where filename = "{}"
        '''.format(DB_TABLENAME_FILES, new_certname, filename)
    )
Esempio n. 22
0
 def getAll(lector = None):
     if lector:
         c = query('SELECT * FROM lectures WHERE lector = ?', (lector,) )
     else:
         c = query('SELECT * FROM lectures WHERE 1' )            
     
     for row in c.fetchall():
         yield Model(row) 
Esempio n. 23
0
def mute_func(args,u413):
	muted=bool(ord(db.query("SELECT muted FROM users WHERE id=%s;"%u413.user.userid)[0]["muted"]))
	db.query("UPDATE users SET muted=%s;"%str(not muted).upper())
	u413.mute=not muted
	if muted:
		u413.type("Terminal unmuted.")
	else:
		u413.type("Terminal muted.")
Esempio n. 24
0
def list_(refresh = False, bootstrap = True, sort = False, \
    fixed_list = None):
  """
   Collect a list of all loaded plugins. During the bootstrap, return only
   vital plugins. See bootstrap.inc
  
   @param refresh
     Whether to force the plugin list to be regenerated (such as after the
     administrator has changed the system settings).
   @param bootstrap
     Whether to return the reduced set of plugins loaded in "bootstrap mode"
     for cached pages. See bootstrap.inc.
   @param sort
     By default, plugins are ordered by weight and filename,
     settings this option
     to True, plugin list will be ordered by plugin name.
   @param fixed_list
     (Optional) Override the plugin list with the given plugins.
     Stays until the
     next call with refresh = True.
   @return
     An associative array whose keys and values are the names of all loaded
     plugins.
  """
  php.static(list_, 'list_', {})
  php.static(list_, 'sorted_list')
  if (refresh or fixed_list):
    list_.sorted_list = None
    list_.list_ = {}
    if (fixed_list):
      for name,plugin in fixed_list.items():
        lib_bootstrap.drupal_get_filename('plugin', name, plugin['filename'])
        list_.list_[name] = name
    else:
      if (bootstrap):
        result = lib_database.query(\
          "SELECT name, filename FROM {system} " + \
          "WHERE type = 'plugin' AND status = 1 AND " + \
          "bootstrap = 1 ORDER BY weight ASC, filename ASC")
      else:
        result = lib_database.query(\
          "SELECT name, filename FROM {system} " + \
          "WHERE type = 'plugin' AND status = 1 " + \
          "ORDER BY weight ASC, filename ASC")
      while True:
        plugin_ = lib_database.fetch_object(result)
        if (plugin_ == None or plugin_ == False):
          break
        if (DrupyImport.exists(plugin_.filename)):
          lib_bootstrap.drupal_get_filename('plugin', \
            plugin_.name, plugin_.filename)
          list_.list_[plugin_.name] = plugin_.name
  if (sort):
    if (list_.sorted_list == None):
      list_.sorted_list = plugin_list.list_
      p.ksort(list_.sorted_list)
    return list_.sorted_list
  return list_.list_
Esempio n. 25
0
def refund_losses(cursor, battle_id):
    losses = get_all_battle_losses_by_squad(cursor, battle_id)

    queries = []
    for s, a in losses.items():
        queries.append("UPDATE squads SET amount = amount + %d WHERE id = %d" % (a, s))
        queries.append("DELETE FROM squad_battle_history WHERE squad = %d AND battle = %d" % (s, battle_id))

    database.query(cursor, *queries)
Esempio n. 26
0
def main(cursor):
	campaign	= int(common.get_val("campaign"))
	team		= int(common.get_val("team"))
	side		= int(common.get_val("side"))
	
	database.query(cursor,
		campaign_f.remove_team_from_campaign(campaign, side, team))
	
	return ""
Esempio n. 27
0
def saveSettings(timezone, theme):
	database.query(sql="""
		UPDATE settings SET
			  timezone=%s
			, themeName=%s
	""", parameters=(
		timezone,
		theme,
	))
Esempio n. 28
0
def main(cursor):
	monster_id	= int(common.get_val('monster', 0))
	army_id 	= int(common.get_val('army', 0))
	amount  	= int(common.get_val('amount', 0))
	
	database.query(cursor, monster_f.alter_army_monster_size(army_id, monster_id, amount))
	
	page_data['Redirect'] = "list_squads&army={0}".format(army_id)
	return ""
Esempio n. 29
0
def main(cursor):
	name			= common.get_val("name", "")
	city			= int(common.get_val("city", 0))
	point_cost		= int(common.get_val("point_cost", 0))
	material_cost	= int(common.get_val("material_cost", 0))
	description		= common.get_val("description", "")
	
	database.query(cursor,
		wonder_f.new_wonder(name, city, point_cost, material_cost, description))
Esempio n. 30
0
def main(cursor):
	unit	= int(common.get_val("unit", 0))
	item	= int(common.get_val("item", 0))
	
	database.query(cursor,
		unit_f.add_equipment(unit=unit, item=item))
	
	# Redirect
	page_data['Redirect'] = 'edit_unit&unit={0:d}'.format(unit)
	return ""
Esempio n. 31
0
qc = QueryConstructor()
qc.setGroupOrderSelectBy("device","androidversion")
qc.addSelectMedian("ping","avg")
qc.addSelectPercentile("ping","avg",25)
qc.addSelectPercentile("ping","avg",75)
qc.addSelectField("count(*)")
qc.addWhereEqualsString("device","networkcountry",networkcountry)
qc.addWhereNotEqualsString("network","networktype","")
qc.addWhereEqualsString("network","networktype","UMTS")
qc.addWhereEqualsString("device","networkname","AT&T")
qc.applyMobileClauses()
qc.applyLatencyClauses("www.google.com")
#qc.addWhereEqualsString("device","networkname",'AT&T')

result = database.query(qc.toString())

pprint.pprint(result)

plot = SimpleBarPlot()
plot.addMapping(MappingWithBounds(result,0,1,2,3,"Type"))
plot.setYLabel("ms")
plot.setXLabel("Android Version")
plot.setTitle("3G RTT latency for different Android Versions in US for AT&T with UMTS") 
#plot.setLegend("ms")

plot.construct()

plot.save(filename)
plot.show()