function isAuthentificated(handleResult)
{
	$.ajax({
	   url: ajax_url,
	   data: 
	   {
	       action: 'authentificated',
		   component: 'giglocker' 
	   },
	   success: function (result) 
	   {
			console.log("isAuthentificated: " + result);
		   	handleResult(result);
	   },
	   error: function(request,error) 
	   {
			return 'noooo';
    	   $("#error").append(error);
	   }
	});	
}

function setDefaultPrivacySetting(handleResult, privacy_level)
{
	$.ajax({
	   url: ajax_url,
	   async: false,
	   data: 
	   {
	       action: 'setDefaultPrivacySetting',
		   component: 'giglocker', 
		   apikey: apikey, 
		   privacy_level: privacy_level
	   },
	   success: function (result) 
	   {
			console.log("setDefaultPrivacySetting: " + result);
			var response = jQuery.parseJSON(result);
		   	handleResult(response);
	   },
	   error: function(request,error) 
	   {
    	   $("#error").append(error);
	   }
	});
}

function getDefaultPrivacySetting(handleResult)
{
	$.ajax({
	   url: ajax_url,
	   async: false,
	   data: 
	   {
	       action: 'getDefaultPrivacySetting',
		   component: 'giglocker', 
		   apikey: apikey, 
	   },
	   success: function (result) 
	   {
			console.log("getDefaultPrivacySetting: " + result);
			var setting = jQuery.parseJSON(result);
		   	handleResult(setting);
	   },
	   error: function(request,error) 
	   {
    	   $("#error").append(error);
	   }
	});
}

function getAudience(handleData, apikey, audience_id, gig_id)
{
	$.ajax({
		url: ajax_url,
		async: false,
	   	data: 
	   	{   action: 'getAudience',
		   	component: 'giglocker',
			apikey: apikey,
			audience_id: audience_id,
			gig_id: gig_id
	   	},
	   	success: function (result) 
   		{
			console.log("getAudience: " + result);
			handleData(jQuery.parseJSON(result));
	   },
	   error: function(request,error) { $("#error").append(error); }
	});
}


function locationUpdates()
{
	
}

function approveRequest(handleResult, apikey, user_id, approval)
{
	console.log("approveRequest call for user_id " + user_id + " and approval " + approval);
	$.ajax({
	   url: ajax_url,
	   data: 
	   {
	       action: 'approveRequest',
		   component: 'giglocker', 
		   apikey: apikey, 
		   user_id: user_id,
		   approval: approval
	   },
	   success: function (result) 
	   {
			console.log("approveRequest: " + result);
			var approval = jQuery.parseJSON(result);
		   	handleResult(approval);
	   },
	   error: function(request,error) 
	   {
    	   $("#error").append(error);
	   }
	});	
}


function approveRequests(handleResult, apikey, requests)
{
	$.ajax({
	   url: ajax_url,
	   data: 
	   {
	       action: 'approveRequests',
		   component: 'giglocker', 
		   apikey: apikey, 
		   requests: requests
	   },
	   success: function (result) 
	   {
			console.log("approveRequests: " + result);
			var approvals = jQuery.parseJSON(result);
		   	handleResult(approvals);
	   },
	   error: function(request,error) 
	   {
    	   $("#error").append(error);
	   }
	});	
}

function sendFriendRequest(handleResult, apikey, user_id)
{
	$.ajax({
	   url: ajax_url,
	   data: 
	   {
	       action: 'sendFriendRequest',
		   component: 'giglocker', 
		   apikey: apikey, 
		   user_id: user_id
	   },
	   success: function (result) 
	   {
			console.log("sendFriendRequest: " + result);
			var friends = jQuery.parseJSON(result);
		   	handleResult(friends);
	   },
	   error: function(request,error) 
	   {
    	   $("#error").append(error);
	   }
	});	
}

function sendFriendRequests(handleResult, apikey, requests)
{
	$.ajax({
	   url: ajax_url,
	   data: 
	   {
	       action: 'sendFriendRequests',
		   component: 'giglocker', 
		   apikey: apikey, 
		   requests: requests
	   },
	   success: function (result) 
	   {
			console.log("sendFriendRequests: " + result);
			var friends = jQuery.parseJSON(result);
		   	handleResult(friends);
	   },
	   error: function(request,error) 
	   {
    	   $("#error").append(error);
	   }
	});	
}

function friendRequests(handleResult)
{
	$.ajax({
	   url: ajax_url,
	   data: 
	   {
	       action: 'friendRequests',
		   component: 'giglocker', 
		   apikey: apikey, 
	   },
	   success: function (result) 
	   {
			console.log("friendRequests: " + result);
			var requests = jQuery.parseJSON(result);
		   	handleResult(requests);
	   },
	   error: function(request,error) 
	   {
    	   $("#error").append(error);
	   }
	});	
}

function findFriends(handleResult, apikey, authtype, query)
{
	$.ajax({
	   url: ajax_url,
	   data: 
	   {
	       action: 'findFriends',
		   component: 'giglocker', 
		   apikey: apikey,
		   authtype: authtype,
		   query: query
	   },
	   success: function (result) 
	   {
			console.log("findFriends: " + result);
			var friends = jQuery.parseJSON(result);
		   	handleResult(friends);
	   },
	   error: function(request,error) 
	   {
    	   $("#error").append(error);
	   }
	});	
}

function lockGig(handleResult, apikey, gig_id)
{
	$.ajax({
	   url: ajax_url,
	   data: 
	   {
	       action: 'lockGig',
		   component: 'giglocker', 
		   apikey: apikey, 
		   gig_id: gig_id
	   },
	   success: function (result) 
	   {
			var lock = jQuery.parseJSON(result);
		   	handleResult(lock);
	   },
	   error: function(request,error) 
	   {
    	   $("#error").append(error);
	   }
	});	
}

function rateGig(handleResult, apikey, gig_id, rating)
{
	$.ajax({
	   url: ajax_url,
	   async: false,
	   data: 
	   {
	       action: 'rateGig',
		   component: 'giglocker', 
		   apikey: apikey,
		   gig_id: gig_id, 
		   rating: rating
	   },
	   success: function (result) 
	   {
			var rated = jQuery.parseJSON(result);
		   	handleResult(rated);
	   },
	   error: function(request,error) 
	   {
    	   $("#error").append(error);
	   }
	});	
	
}

function postGigReview(handleResult, apikey, gig_id, review)
{
	$.ajax({
	   url: ajax_url,
	   async: false,
	   data: 
	   {
	       action: 'postGigReview',
		   component: 'giglocker', 
		   apikey: apikey,
		   gig_id: gig_id,
		   review: review
	   },
	   success: function (result) 
	   {
			var reviewed = jQuery.parseJSON(result);
		   	handleResult(reviewed);
	   },
	   error: function(request,error) 
	   {
    	   $("#error").append(error);
	   }
	});	
}

function deleteGig(handleResult, apikey, gig_id)
{
	$.ajax({
	   url: ajax_url,
	   data: 
	   {
	       action: 'deleteGig',
		   component: 'giglocker', 
		   apikey: apikey,
		   gig_id: gig_id
	   },
	   success: function (result) 
	   {
			var deletion = jQuery.parseJSON(result);
		   	handleResult(deletion);
	   },
	   error: function(request,error) 
	   {
    	   $("#error").append(error);
	   }
	});	
}

function deleteGigs(handleResult, apikey, requests)
{
	$.ajax({
	   url: ajax_url,
	   data: 
	   {
	       action: 'deleteGigs',
		   component: 'giglocker', 
		   apikey: apikey,
		   requests: requests
	   },
	   success: function (result) 
	   {
			var deletion = jQuery.parseJSON(result);
		   	handleResult(deletion);
	   },
	   error: function(request,error) 
	   {
    	   $("#error").append(error);
	   }
	});	
}

function getLibrary(handleResult, apikey, user_id, filter)
{
	var start_date = '';
	var end_date = '';
	var limit = '';
	var exclude = '';
	
	if(filter != undefined)
	{
		if(filter.start_date != undefined) { start_date = filter.start_date; }
		if(filter.end_date != undefined) { end_date = filter.end_date; }
		if(filter.limit != undefined) { limit = filter.limit; }
		if(filter.exclude != undefined) { exclude = filter.exclude; }
		
	}
	$.ajax({
	   url: ajax_url,
	   async: false,
	   data: 
	   {   
		   action: 'getLibrary', 
		   component: 'giglocker',
		   apikey: apikey,
		   user_id: user_id,
		   start_date: start_date,
		   end_date: end_date,
		   limit: limit,
		   exclude: exclude
	   },
	   success: function (result) 
	   {
			console.log("getLibrary: " + result);
			var gigs = jQuery.parseJSON(result);
			handleResult(gigs);
	   },
	   error: function(request,error) { $("#error").append(error); } 
	});
}

function getRecentlyLockedGigs(handleResult, apikey, filter)
{
	var limit = '';
	if(filter != undefined)
	{
		if(filter.limit != undefined) { limit = filter.limit; }
	}
	$.ajax({
	   url: ajax_url,
	   async: false,
	   data: 
	   {   
		   action: 'getRecentlyLockedGigs', 
		   component: 'giglocker',
		   apikey: apikey,
		   limit: limit
	   },
	   success: function (result) 
	   {
			console.log("getRecentlyLockedGigs: " + result);
			handleResult(jQuery.parseJSON(result));
	   },
	   error: function(request,error) { $("#error").append(error); } 
	});
}


function getNumberOfLockedGigs(handleResult, apikey, user_id)
{
	$.ajax({
	   url: ajax_url,
	   async: false,
	   data: 
	   {   
		   action: 'getNumberOfLockedGigs', 
		   component: 'giglocker',
		   apikey: apikey,
		   user_id: user_id,
	   },
	   success: function (result) 
	   {
			console.log("getNumberOfLockedGigs: " + result);
			handleResult(jQuery.parseJSON(result));
	   },
	   error: function(request,error) { $("#error").append(error); } 
	});
}

function userAuthentificate(handleResult, username, email, fullname, deviceid, displaypic, authtype)
{
	console.log("userAuthentificate");
	$.ajax({
	   url: ajax_url,
	   data: 
	   {
	       action: 'authUser',
		   component: 'giglocker', 
		   user_name: username,
		   email: email,
		   full_name: fullname,
		   deviceid: deviceid, 
		   displaypic: displaypic,
		   authtype: authtype
	   },
	   success: function (result) 
	   {
			var auth = jQuery.parseJSON(result);
		   	handleResult(auth);
	   },
	   error: function(request,error) 
	   {
    	   $("#error").append(error);
	   }
	});
}

function getUsers(handleResult, apikey)
{
	console.log("getUsers");
	$.ajax({
	   url: ajax_url,
	   data: 
	   {
	       action: 'getUsers',
		   component: 'giglocker', 
		   apikey:apikey
	   },
	   success: function (result) 
	   {
			console.log("getUsers: " + result);
			var users = jQuery.parseJSON(result);
		   	handleResult(users);
	   },
	   error: function(request,error) 
	   {
    	   $("#error").append(error);
	   }
	});
}	


function getUserInfo(handleResult, apikey)
{
	
	$.ajax({
	   url: ajax_url,
	   data: 
	   {
	       action: 'getUserInfo',
		   component: 'giglocker', 
		   apikey:apikey
	   },
	   success: function (result) 
	   {
			console.log("getUserInfo: " + result);
			var info = jQuery.parseJSON(result);
		   	handleResult(info);
	   },
	   error: function(request,error) 
	   {
    	   $("#error").append(error);
	   }
	});
}	

function autocomplete(handleResult, search_for, search_string)
{
	$.ajax({
		url: ajax_url,
    	async: false,
	   	data: 
	   	{   action: 'autocomplete',
		    component: 'giglocker',
		    search_for: search_for,
			search_string: search_string,
			test: test
	   	},
	   success: function (result) 
	   {
			//alert(result);
		    var artists = jQuery.parseJSON(result);
		    handleResult(artists);
	   },
	   error: function(request,error) 
	   {
    	   $("#error").append(error);
	   }
	});
}

function getGigDetails(handleResult, apikey, gig_id, audience_id)
{
	console.log("fetching gigDetails for gig " + gig_id + " and audience_id" + audience_id);
	
	$.ajax({
	   	url: ajax_url,
	   	async: false,
	   	data: 
	   	{   
		   action: 'getGigDetails', 
		   component: 'giglocker',
		   apikey: apikey,
		   gig_id : gig_id,
		   audience_id : audience_id,
		},
		success: function (result) 
		{
			console.log("getGigDetails " + result);
			var gig = jQuery.parseJSON(result);
			handleResult(gig);
		},
		error: function(request,error) { $("#error").append(error); console.log("error fetching gigDetails for gig " + gig_id);}
	});	
}

function addGig(handleResult, apikey, artist_id, venue_id, stage_id, date, time, lock, festival_id)
{
	$.ajax({
	   url: ajax_url,
	   data: 
	   {
	       action: 'addGig',
		   component: 'giglocker',
		   apikey:apikey,
		   artist_id: artist_id,
		   venue_id: venue_id,
		   stage_id: stage_id,
		   date: date, 
		   time: time, 
		   lock: lock,
		   festival_id: festival_id
	   },
	   success: function (result) 
	   {
			var gig = jQuery.parseJSON(result);
		   	handleResult(gig);
	   },
	   error: function(request,error) 
	   {
    	   $("#error").append(error);
	   }
	});
}

function getVenues(handleData, startsWith, city_id)
{
	$.ajax({
		url: ajax_url,
    	async: true,
	   	data: 
	   	{   action: 'getVenues',
		    component: 'giglocker',
			startsWith: startsWith,
			city_id: city_id,
			test: test
	   	},
	   success: function (result) 
	   {
			console.log("getVenues :" + result);
		    var venues = jQuery.parseJSON(result);
		    handleData(venues);
	   },
	   error: function(request,error) 
	   {
    	   $("#error").append(error);
	   }
	});
}

function getVenue(handleData, venue_id)
{
	console.log("getVenue(" + venue_id + ")");
	$.ajax({
	   	url: ajax_url,
	   	async: false,
	   	data: 
	   	{   
		   action: 'getVenueDetails', 
		   component: 'giglocker',
		   venue_id : venue_id,
		   test: test
		},
		success: function (result) 
		{
			console.log("getVenue(" + venue_id + ") returned successfully");
			console.log(result);
			var venue = jQuery.parseJSON(result);
			handleData(venue);
		},
		error: function(request,error) { $("#error").append(error); }
	});
}

function addVenue(handleResult, apikey, image_1, image_2, name, address, ZIP, city_id, website, phone, latitude, longitude)
{	
	console.log("addVenue " + image_1 + " " + image_2 + " " + name + " " + address + " " + ZIP + " " + city_id + " " + latitude + " " + longitude);
	$.ajax({
	   url: ajax_url,
	   data: 
	   {   action: 'addOrUpdateVenue',
		   component: 'giglocker',
		   apikey: apikey,
		   name: name,
		   image_1: image_1,
		   image_2: image_2,
		   address: address,
		   ZIP: ZIP,
		   city_id: city_id,
		   website: website,
		   phone: phone,
		   latitude: latitude,
		   longitude: longitude,
		   test: test
	   },
	   success: function(result) 
	   {
			var venue = jQuery.parseJSON(result);
		   	handleResult(venue);
	   },
	   error: function(request,error) 
	   {
    	   $("#error").append(error);
	   }
	});
}

function updateVenue(handleResult, apikey, id, image_1, image_2, name, address, ZIP, city_id, website, phone, latitude, longitude)
{	
	console.log("updateVenue " + image_1 + " " + image_2 + " " + name + " " + address + " " + ZIP + " " + city_id + " " + latitude + " " + longitude);
	$.ajax({
	   url: ajax_url,
	   data: 
	   {   action: 'addOrUpdateVenue',
		   component: 'giglocker',
		   apikey: apikey,
		   venue_id: id,
		   name: name,
		   image_1: image_1,
		   image_2: image_2,
		   address: address,
		   ZIP: ZIP,
		   city_id: city_id,
		   website: website,
		   phone: phone,		
		   latitude: latitude,
		   longitude: longitude,
		   test: test
	   },
	   success: function(result) 
	   {
			var venue = jQuery.parseJSON(result);
		   	handleResult(venue);
	   },
	   error: function(request,error) 
	   {
    	   $("#error").append(error);
	   }
	});
}

function getFestival(handleData, festival_id)
{
	console.log("getFestival(" + festival_id + ")");
	$.ajax({
	   	url: ajax_url,
	   	async: false,
	   	data: 
	   	{   
		   action: 'getFestival', 
		   component: 'giglocker',
		   festival_id : festival_id
		},
		success: function (result) 
		{
			console.log("getFestival:" + result);
			var festival = jQuery.parseJSON(result);
			handleData(festival);
		},
		error: function(request,error) { $("#error").append(error); }
	});
}

function getFestivals(handleData, startsWith, city_id)
{
	$.ajax({
		url: ajax_url,
    	async: true,
	   	data: 
	   	{   action: 'getFestivals',
		    component: 'giglocker',
			startsWith: startsWith,
			city_id: city_id
	   	},
	   success: function (result) 
	   {
			console.log("getFestivals :" + result);
		    handleData(jQuery.parseJSON(result));
	   },
	   error: function(request,error) 
	   {
    	   $("#error").append(error);
	   }
	});
}

function addFestival(handleResult, apikey, image_1, image_2, name, address, ZIP, city_id, website, phone, latitude, longitude)
{	
	console.log("addFestival " + image_1 + " " + image_2 + " " + name + " " + address + " " + ZIP + " " + city_id + " " + latitude + " " + longitude);
	$.ajax({
	   url: ajax_url,
	   data: 
	   {   action: 'addOrUpdateFestival',
		   component: 'giglocker',
		   apikey: apikey,
		   name: name,
		   image_1: image_1,
		   image_2: image_2,
		   address: address,
		   ZIP: ZIP,
		   city_id: city_id,
		   website: website,
		   phone: phone,
		   latitude: latitude,
		   longitude: longitude
	   },
	   success: function(result) 
	   {
			console.log("addFestival :" + result);
			var festival = jQuery.parseJSON(result);
		   	handleResult(festival);
	   },
	   error: function(request,error) 
	   {
    	   $("#error").append(error);
	   }
	});
}

function updateFestival(handleResult, apikey, festival_id, image_1, image_2, name, address, ZIP, city_id, website, phone, latitude, longitude)
{	
	console.log("updateFestival " + image_1 + " " + image_2 + " " + name + " " + address + " " + ZIP + " " + city_id + " " + latitude + " " + longitude);
	$.ajax({
	   url: ajax_url,
	   data: 
	   {   action: 'addOrUpdateFestival',
		   component: 'giglocker',
		   apikey: apikey,
		   festival_id: festival_id,
		   name: name,
		   image_1: image_1,
		   image_2: image_2,
		   address: address,
		   ZIP: ZIP,
		   city_id: city_id,
		   website: website,
		   phone: phone,		
		   latitude: latitude,
		   longitude: longitude
	   },
	   success: function(result) 
	   {
			console.log("updateFestival: " + result); 
		   	handleResult(jQuery.parseJSON(result));
	   },
	   error: function(request,error) 
	   {
    	   $("#error").append(error);
	   }
	});
}

function getVisitedVenues(handleData, apikey, user_id, audience_id)
{
	$.ajax({
		url: ajax_url,
    	async: true,
	   	data: 
	   	{   action: 'getVisitedVenues',
		    component: 'giglocker',
			user_id: user_id,
			audience_id: audience_id,
	   	},
	   success: function (result) 
	   {
			console.log("getVisitedVenues :" + result);
		    var venues = jQuery.parseJSON(result);
		    handleData(venues);
	   },
	   error: function(request,error) 
	   {
    	   $("#error").append(error);
	   }
	});
}

function addStage(handleResult, apikey, venue_id, name, latitude, longitude)
{
	$.ajax({
	   url: ajax_url,
	   data: 
	   {   action: 'addOrUpdateStage',
		   component: 'giglocker', 
		   apikey: apikey,
		   name: name,
		   venue_id: venue_id, 
		   latitude: latitude,
		   longitude: longitude
	   },
	   success: function (result) 
	   {
			var stage = jQuery.parseJSON(result);
		   	handleResult(stage);
	   },
	   error: function(request,error) 
	   {
    	   $("#error").append(error);
	   }
	});
}

function getStage(handleResult, stage_id)
{
	console.log("getStage(" + stage_id + ")");
	$.ajax({
	   	url: ajax_url,
	   	async: false,
	   	data: 
	   	{   
		   action: 'getStage', 
		   component: 'giglocker',
		   stage_id : stage_id,
		   test: test
		},
		success: function (result) 
		{
			console.log("getStage " + result);
			var stage = jQuery.parseJSON(result);
			handleResult(stage);
		},
		error: function(request,error) { $("#error").append(error); }
	});	
}

function getStages(handleResult, venue_id)
{
	console.log("getStages(" + venue_id + ")");
	$.ajax({
	   	url: ajax_url,
	   	async: false,
	   	data: 
	   	{   
		   action: 'getStages', 
		   component: 'giglocker',
		   venue_id : venue_id,
		   test: test
		},
		success: function (result) 
		{
			console.log("getStages " + result);
			handleResult(jQuery.parseJSON(result));
		},
		error: function(request,error) { $("#error").append(error); }
	});	
}

function updateStage(handleResult, apikey, stage_id, venue_id, name, latitude, longitude)
{
	$.ajax({
	   url: ajax_url,
	   data: 
	   {   action: 'addOrUpdateStage',
		   component: 'giglocker',
		   apikey: apikey, 
		   stage_id: stage_id, 
		   venue_id: venue_id, 
		   name: name,
		   latitude: latitude,
		   longitude: longitude
	   },
	   success: function (result) 
	   {
			var stage = jQuery.parseJSON(result);
		   	handleResult(stage);
	   },
	   error: function(request,error) 
	   {
    	   $("#error").append(error);
	   }
	});
}

function getCity(handleData, city_id)
{
	console.log("getCity(" + city_id + ")");
	$.ajax({
	   	url: ajax_url,
	   	async: false,
	   	data: 
	   	{   
		   action: 'getCity', 
		   component: 'giglocker',
		   city_id : city_id,
		   test: test
		},
		success: function (result) 
		{
			console.log("getCity(" + city_id + ") returned successfully");
			console.log(result);
			var city = jQuery.parseJSON(result);
			handleData(city);
		},
		error: function(request,error) { $("#error").append(error); }
	});
}

function addCity(handleResult, country, city, accentcity, region, latitude, longitude)
{	
	console.log("addCity " + country + " " + city + " "  +  region);
	$.ajax({
	   url: ajax_url,
	   data: 
	   {   action: 'addOrUpdateCity',
		   component: 'giglocker',
		   country: country,
		   city: city,
		   accentcity: accentcity,
		   region: region,
		   latitude: latitude,
		   longitude: longitude,
		   test: test
	   },
	   success: function(result) 
	   {
			var city = jQuery.parseJSON(result);
		   	handleResult(city);
	   },
	   error: function(request,error) 
	   {
    	   $("#error").append(error);
	   }
	});
}

function updateCity(handleResult, id, country, city, accentcity, region, latitude, longitude)
{	
	$.ajax({
	   url: ajax_url,
	   data: 
	   {   action: 'addOrUpdateCity',
		   component: 'giglocker',
		   id: id,
		   country: country,
		   city: city,
		   accentcity: accentcity,
		   region: region,
		   latitude: latitude,
		   longitude: longitude,
		   test: test
	   },
	   success: function(result) 
	   {
			console.log("updateCity returned succesfully " + result);
			var city = jQuery.parseJSON(result);
		   	handleResult(city);
	   },
	   error: function(request,error) 
	   {
    	   $("#error").append(error);
	   }
	});
}

function getCities(handleData, startsWith, country)
{
	//alert(startsWith);
	$.ajax({
		url: ajax_url,
    	async: true,
	   	data: 
	   	{   action: 'getCities',
		    component: 'giglocker',
			startsWith: startsWith,
			country: country,
			test: test
	   	},
	   success: function (result) 
	   {
			console.log("getCities " + result);
		    var cities = jQuery.parseJSON(result);
		    handleData(cities);
	   },
	   error: function(request,error) 
	   {
    	   $("#error").append(error);
	   }
	});
}

function deleteCity(handleResult, id)
{	
	$.ajax({
	   url: ajax_url,
	   data: 
	   {   action: 'deleteCity',
		   component: 'giglocker',
		   id: id,
		   test: test
	   },
	   success: function(result) 
	   {
			console.log("deleteCity " + result);
			var deletion = jQuery.parseJSON(result);
		   	handleResult(deletion);
	   },
	   error: function(request,error) 
	   {
    	   $("#error").append(error);
	   }
	});
}

function addArtist(handleResult, apikey, name, image_1, image_2, website, country, city, description)
{	
	$.ajax({
	   url: ajax_url,
	   data: 
	   {   action: 'addOrUpdateArtist',
		   component: 'giglocker',
		   apikey: apikey,
		   name: name,
		   image_1: image_1,
		   image_2: image_2,
		   website: website,
		   country: country,
		   city: city,
		   description: description,
		   test: test
	   },
	   success: function(result) 
	   {
			var artist = jQuery.parseJSON(result);
		   	handleResult(artist);
	   },
	   error: function(request,error) 
	   {
    	   $("#error").append(error);
	   }
	});
}

function deleteArtist(handleResult, apikey, artist_id)
{	
	$.ajax({
	   url: ajax_url,
	   data: 
	   {   action: 'deleteArtist',
		   component: 'giglocker',
		   apikey: apikey,
		   artist_id: artist_id,
		   test: test
	   },
	   success: function(result) 
	   {
			console.log("deleteArtist " + result);
			var deletion = jQuery.parseJSON(result);
		   	handleResult(deletion);
	   },
	   error: function(request,error) 
	   {
    	   $("#error").append(error);
	   }
	});
}

function updateArtist(handleResult, apikey, artist_id, name, image_1, image_2, website, country, city, description)
{	
	$.ajax({
	   url: ajax_url,
	   data: 
	   {   action: 'addOrUpdateArtist',
		   component: 'giglocker',
		   apikey: apikey, 
		   artist_id: artist_id,
		   name: name,
		   image_1: image_1,
		   image_2: image_2,
		   website: website,
		   country: country,
		   city: city,
		   description: description,
		   test: test
	   },
	   success: function(result) 
	   {
			var artist = jQuery.parseJSON(result);
		   	handleResult(artist);
	   },
	   error: function(request,error) 
	   {
    	   $("#error").append(error);
	   }
	});
}

function getArtists(handleData, startsWith)
{
	$.ajax({
		url: ajax_url,
    	async: false,
	   	data: 
	   	{   action: 'getArtists',
		    component: 'giglocker',
			startsWith: startsWith,
			test: test
	   	},
	   success: function (result) 
	   {
			console.log("getArtists: " + result);
		    var artists = jQuery.parseJSON(result);
		    handleData(artists);
	   },
	   error: function(request,error) 
	   {
    	   $("#error").append(error);
	   }
	});
}

function getArtistDetails(handleData, apikey, artist_id)
{
	$.ajax({
	   	url: ajax_url,
	   	async: false,
	   	data: 
	   	{   
		   action: 'getArtistDetails', 
		   component: 'giglocker',
		   apikey: apikey,
		   artist_id : artist_id,
		   test: test
		},
		success: function (result) 
		{
			var artist = jQuery.parseJSON(result);
			handleData(artist);
		},
		error: function(request,error) { $("#error").append(error); }
	});
}

function getUserGigs(handleData, filter, user_id)
{
	if(user_id == undefined) {user_id = '';}
	
	$.ajax({
	   url: ajax_url,
	   async: false,
	   data: 
	   { 	action: 'getUserGigs', 
		   	component: 'giglocker',
		   	user_id: user_id,
	   },
	   success: function (result) 
	   {	
			var gigs = jQuery.parseJSON(result);
			handleData(gigs)
	   },
	   error: function(request,error) { 
	    	$("#error").append(error);
	   }
	});
}

function getNearbyGigs(handleData, apikey, latitude, longitude, radius)
{
	console.log("getNearbyGigs " + latitude + ", " + longitude + " " + radius);
	$.ajax({
	   	url: ajax_url,
		async: false,
		data: 
		{	action: 'nearbyGigs', 
		    component: 'giglocker',
			apikey: apikey,
			latitude: latitude, 
			longitude: longitude,
			radius: radius,
		}, 
		success: function(result) 
	  	{	
			console.log(result);
			var gigs = jQuery.parseJSON(result);
			handleData(gigs);
		},
		error: function(request,error) 
		{  $("#error").append(error); }
	});
	return null;
}

// TODO tmp
function getNearbyFMGigs(handleData, apikey, latitude, longitude, radius)
{
	console.log("getNearbyFMGigs " + latitude + ", " + longitude + " " + radius);
	$.ajax({
	   	url: ajax_url,
		async: false,
		data: 
		{	action: 'nearbyLastFMgigs', 
		    component: 'giglocker',
			apikey: apikey,
			latitude: latitude, 
			longitude: longitude,
			radius: radius,
		}, 
		success: function(result) 
	  	{	
			console.log(result);
			var gigs = jQuery.parseJSON(result);
			handleData(gigs);
		},
		error: function(request,error) 
		{  $("#error").append(error); }
	});
	return null;
}

function getGigs(handleData, apikey, filter)
{
	var venue = '';
	var city_id = '';
	var artist = '';
	
	if(filter != undefined)
	{
		if(filter.venue != undefined) { venue = filter.venue; }
		if(filter.city_id != undefined) { city_id = filter.city_id; }
		if(filter.artist != undefined) { artist = filter.artist; }
	}
	$.ajax({
	   url: ajax_url,
	   async: false,
	   data: 
	   {   
		   action: 'getGigs', 
		   component: 'giglocker',
    	   apikey: apikey,
		   venue: venue,
		   artist: artist,
		   city_id: city_id,
	   },
	   success: function (result) 
	   {
			console.log("gigs: " + result);
			var gigs = jQuery.parseJSON(result);
			handleData(gigs);
	   },
	   error: function(request,error) { $("#error").append(error); } 
	});
}

function getPersonalGigDetails(handleData, gig_id, user_id)
{
	$.ajax({
	   	url: ajax_url,
	   	async: false,
	   	data: 
	   	{   
		   action: 'getPersonalGigDetails', 
		   component: 'giglocker',
		   gig_id : gig_id,
		   user_id: user_id,
		},
		success: function (result) 
		{
			var personalDetails = jQuery.parseJSON(result);
			handleData(personalDetails);
		}
	});
}

/*
function ](handleData, gig_id, user_id)
{
	$.ajax({
	   	url: ajax_url,
	   	async: false,
	   	data: 
	   	{   
		   action: 'getGigDetails', 
		   component: 'giglocker',
		   gig_id : gig_id,
		   user_id : user_id,
		},
		success: function (result) 
		{
			var gig = jQuery.parseJSON(result);
			handleData(gig);
		},
		error: function(request,error) { $("#error").append(error); }
	});
}
*/
function setPersonalGigDetails(form)
{
	$.ajax({
	   	url: ajax_url,
    	async: false,
	   data: 
	   {   action: 'setPersonalGigDetails',
		   component: 'giglocker', 
		   gig_id: form.gig_id.value, 
		   description: form.description.value, 
		   score: form.score.value,
	   },
	   success: function (result) 
	   {
		   form.reset();
	   },
	   error: function(request,error) 
	   { $("#error").append(error); }
	});
	showGigDetails(form.gig_id.value);
}

function getGigMedia(handleData, apikey, audience_id, type, user_id)
{
	$.ajax({
	   url: ajax_url,
	   async: false,
	   data: 
	   {   
		   action: 'getGigMedia', 
		   component: 'giglocker',
		   apikey: apikey,
		   audience_id: audience_id,
		   type: type,
		   user_id: user_id
	   },
	   success: function (result) 
	   {
			console.log("getGigMedia: " + result);
			var media = jQuery.parseJSON(result);
			handleData(media);
	   },
	   error: function(request,error) { $("#error").append(error); }
	});
}

function deleteGigMedia(handleData, apikey, requests)
{
	$.ajax({
	   url: ajax_url,
	   async: false,
	   data: 
	   {   
		   action: 'deleteGigMedia', 
		   component: 'giglocker',
		   apikey: apikey,
		   requests: requests
	   },
	   success: function (result) 
	   {
			console.log("deleteGigMedia: " + result);
			var deletion = jQuery.parseJSON(result);
			handleData(deletion);
	   },
	   error: function(request,error) { $("#error").append(error); }
	});
}
function attendGig(handleData, gig_id)
{
	$.ajax({
	   url: ajax_url,
	   data: 
	   {   action: 'attendGig',
		   component: 'giglocker', 
		   gig_id: gig_id
	   },
	   success: function (result) 
	   {
		   var gig = jQuery.parseJSON(result);
			handleData(gig);
	   },
	   error: function(request,error) { $("#error").append(error); }
	});	
}

function getFriends(handleData, apikey, gig_id)
{
	$.ajax({
		url: ajax_url,
	   	data: 
	   	{   action: 'getFriends',
		   	component: 'giglocker',
			apikey: apikey,
			gig_id: gig_id
	   	},
	   	success: function (result) 
   		{
			console.log("getFriends: " + result);
			var friends = jQuery.parseJSON(result);
			handleData(friends);
	   },
	   error: function(request,error) { $("#error").append(error); }
	});
}

function getFriendDetails(handleData, friend_id)
{
	$.ajax({
		url: ajax_url,
		async: false,
	   	data: 
	   	{   action: 'getFriendDetails',
		   	component: 'giglocker',
			friend_id: friend_id,
	   	},
	   	success: function (result) 
   		{
			var friend = jQuery.parseJSON(result);
			handleData(friend);
	   },	
	   error: function(request,error) { $("#error").append(error); }
	});
}

function addFriend(handleData, apikey, user_id)
{
	$.ajax({
		url: ajax_url,
		async: true,
	   	data: 
	   	{   action: 'addFriend',
		   	component: 'giglocker',
		    apikey: apikey,
			user_id: user_id
	   	},
	   	success: function (result) 
   		{
			console.log("addFriend result: " + result);
			var response = jQuery.parseJSON(result);
			handleData(response);
	   },
	   error: function(request,error) { $("#error").append(error); }
	});
	
}

function removeFriends(handleData, apikey, requests)
{
	$.ajax({
		url: ajax_url,
		async: false,
	   	data: 
	   	{   action: 'removeFriends',
		   	component: 'giglocker',
		    apikey: apikey,
			requests: requests
	   	},
	   	success: function (result) 
   		{
			console.log("removeFriends result: " + result);
			var response = jQuery.parseJSON(result);
			handleData(response);
	   },
	   error: function(request,error) { $("#error").append(error); }
	});
	
}



function getNearbyStages(latitude, longitude, radius)
{
	$.getJSON(ajax_url, 
		{
			'action' 	: 'nearbyStages',
		 	'component' : 'giglocker',
			'latitude'	: latitude, 
			'longitude'	: longitude,
			'radius'	: radius
		}, 
		function(stages)
		{
			var nearbyStages = new Array();
			for(var j = 0; j < stages.length; j++)
			{
				var StageObject = new Stage(stages[j].id, stages[j].stage_name, stages[j].latitude, stages[j].longitude);
				nearbyStages.push(StageObject);
			}
			nearbyStages.sort(distanceSort);
			list = '<ul>'
				+ '<li class="stageHeader">Nearby Stages</li>';

			for(var j = 0; j < nearbyStages.length; j++)
			{	
				var stage = nearbyStages[j];
				var stage_distance = distance(stage.latitude, stage.longitude, latitude, longitude);
				list += '<li>'
					+ ' [' 
					+ Math.round(1000*stage_distance)/1000
					+ 'km] '
				    + '<a href="#" class="venueDetails" onClick="getVenueDetails(' + stage.id + ')">' + stage.name + '</a></li>';
			    //  alert(venue.name);
			}
			list += '</ul>';
			$('#nearbyStages').html(list);
		}
	);
}