private static IReadOnlyList <IPlaceInfo> GetPlaces(Stream input, IReadOnlyDictionary <string, ICountryInfo> countryInfos)
{
var places = new List <IPlaceInfo>();
using (var db = new StreamReader(input))
{
string line;
while (!db.EndOfStream && (line = db.ReadLine()) != null)
{
if (line.StartsWith(commentMark))
{
continue;
}
var place = new PlaceInfo(line);
if (countryInfos != null && !string.IsNullOrWhiteSpace(place.CountryCode) && countryInfos.ContainsKey(place.CountryCode))
{
place.CountryInfo = countryInfos[place.CountryCode];
}
places.Add(place);
}
}
return(places);
}
/// <summary>
/// Add rooms to storage.
/// </summary>
/// <param name="building">Building information.</param>
/// <param name="rooms">List of rooms.</param>
/// <returns>A task that represents the work queued to execute.</returns>
private async Task <List <MeetingRoomEntity> > AddOrReplaceRoomsAsync(PlaceInfo building, List <PlaceInfo> rooms)
{
var meetingRooms = new List <MeetingRoomEntity>();
if (rooms != null)
{
meetingRooms = rooms.Select(room => new MeetingRoomEntity
{
BuildingName = building.DisplayName,
Key = room.Id,
BuildingEmail = building.EmailAddress,
RoomName = room.DisplayName,
RoomEmail = room.EmailAddress,
Capacity = room.Capacity ?? string.Empty,
FloorNumber = room.FloorNumber != null ? Convert.ToString(room.FloorNumber) : string.Empty,
DisplayDevice = room.DisplayDevice ?? string.Empty,
IsDeleted = false,
}).ToList();
if (await this.roomCollectionStorageProvider.AddOrReplaceAsync(meetingRooms).ConfigureAwait(false))
{
return(meetingRooms);
}
}
return(meetingRooms);
}
private async void DetectLocation_Click(object sender, RoutedEventArgs e)
{
LocationInfoStack.Visibility = Visibility.Visible;
LocatingYou.Visibility = Visibility.Visible;
LocationProgress.Visibility = Visibility.Visible;
var coords = await Geolocation.GetLocationInfo();
if (coords.Latitude == 0 && coords.Longitude == 0)
{
LocationProgress.Visibility = Visibility.Collapsed;
LocatingYou.Visibility = Visibility.Collapsed;
CantLocateYou.Visibility = Visibility.Visible;
}
else
{
var plid = await PlacesSearch.GetCityNameByCoordinate(coords.Latitude, coords.Longitude);
if (plid != null)
{
ChoosenPlace = new PlaceInfo()
{
Latitude = plid.Latitude, Longitude = plid.Longitude, DisplayName = plid.DisplayName, PlaceId = plid.PlaceId
};
DefaultLocation.Text = plid.DisplayName;
LocationInfoStack.Visibility = Visibility.Collapsed;
}
else
{
CantLocateYou.Visibility = Visibility.Visible;
}
}
}
/// <summary>
/// Convert Place to PlaceInfo.
/// </summary>
/// <param name="place">Place</param>
/// <param name="includeModules">Convert the module list</param>
/// <returns></returns>
public static PlaceInfo ToPlaceInfo(this Place place, bool includeModules = false)
{
if (place is null)
{
return(null);
}
var placeInfo = new PlaceInfo()
{
PlaceId = place.PlaceId,
KeyName = place.KeyName,
PageTemplateId = place.PageTemplateId,
ModuleId = place.ModuleId,
Template = place.PageTemplate.ToTemplateInfo()
};
if (includeModules)
{
placeInfo.Modules = place.KastraModules
.Select(m => m.ToModuleInfo(true))
.ToList();
}
return(placeInfo);
}
public static async Task <bool> RemoveFromFavorites(string filename, PlaceInfo _PlaceInfo)
{
try
{
var favorites = await GetFavorites(filename);
foreach (var item in favorites.ToArray())
{
if (item.PlaceId == _PlaceInfo.PlaceId)
{
favorites.Remove(item);
}
}
StorageFile file = await ApplicationData.Current.RoamingFolder.CreateFileAsync(filename, CreationCollisionOption.ReplaceExisting);
string data = JsonConvert.SerializeObject(favorites);
await FileIO.WriteTextAsync(file, data);
return(true);
}
catch (Exception)
{
return(false);
}
}
//places(placeId INTEGER PRIMARY KEY, planId INTEGER, studentId INTEGER, row INTEGER, column INTEGER);
public static List <PlaceInfo> AllFromPlanId(int planId)
{
List <PlaceInfo> placeList = new List <PlaceInfo>();
using SQLiteCommand cmd = GlobalFunction.OpenDbConnection();
cmd.CommandText = "SELECT * FROM places WHERE planId = @planId";
cmd.Parameters.AddWithValue("planId", planId);
cmd.Prepare();
using SQLiteDataReader rdr = cmd.ExecuteReader();
while (rdr.Read())
{
PlaceInfo place = new PlaceInfo()
{
PlaceId = rdr.GetInt32(0),
PlanId = rdr.GetInt32(1),
StudentId = rdr.GetInt32(2),
Row = rdr.GetInt32(3),
Column = rdr.GetInt32(4)
};
placeList.Add(place);
}
return(placeList);
}
private LocationResponse GetLocationForPlace(PlaceInfo place)
{
var link = string.Format(_locationApiLink, place.location_id, _accessKey);
var placeLocation = FetcherAndDeserializer.FetchAndDeserialize <LocationResponse>(link, _fetcher);
return(placeLocation);
}
private static CategoryTypes CollectCategories(PlaceInfo place)
{
var placeCategories = CategoryTypes.None;
if (IsAValidAttraction(place))
{
var placeCategoryList = place.locationResponse.groups.SelectMany(group => group.categories);
var listOfCategories = _applicableGroupCategories.Split(',').Select
(category => category.Split('|')).Select
(splitCategory => new CategoryUnconverted {
NameFromProvider = splitCategory[0], NameNormalized = splitCategory[1]
})
.ToList();
foreach (var category in placeCategoryList)
{
var foundCategory = listOfCategories.FirstOrDefault(x => x.NameFromProvider == category.name);
if (foundCategory != null && Enum.TryParse(foundCategory.NameNormalized, true, out CategoryTypes foundCategoryEnum))
{
placeCategories |= foundCategoryEnum;
}
}
}
else if (IsAValidRestaurant(place))
{
placeCategories |= CategoryTypes.Restaurant;
}
return(placeCategories);
}
public IActionResult Update([FromBody] ModuleModel model)
{
// Save module
ModuleInfo module = new ModuleInfo();
module.ModuleId = model.Id;
module.ModuleDefId = model.DefinitionId;
module.PageId = model.PageId;
module.PlaceId = model.PlaceId;
module.Name = model.Name;
module.IsDisabled = model.IsDisabled;
_viewManager.SaveModule(module);
// Handle static module
if (model.IsStatic)
{
PlaceInfo place = _viewManager.GetPlace(model.PlaceId);
place.ModuleId = module.ModuleId;
_viewManager.SavePlace(place);
}
else if (model.Id > 0)
{
PlaceInfo place = _viewManager.GetPlace(model.PlaceId);
if (place.ModuleId == module.ModuleId)
{
place.ModuleId = null;
_viewManager.SavePlace(place);
}
}
#region Permissions
ModulePermissionInfo modulePermission = null;
IList <ModulePermissionInfo> modulePermissions = _securityManager.GetModulePermissionsByModuleId(module.ModuleId);
IList <PermissionInfo> permissions = _securityManager.GetPermissionsList();
foreach (var permission in permissions)
{
if (model.Permissions.Contains(permission.PermissionId) &&
!modulePermissions.Any(mp => mp.PermissionId == permission.PermissionId))
{
modulePermission = new ModulePermissionInfo();
modulePermission.ModuleId = module.ModuleId;
modulePermission.PermissionId = permission.PermissionId;
_securityManager.SaveModulePermission(modulePermission);
}
else if (!model.Permissions.Contains(permission.PermissionId) &&
modulePermissions.Any(mp => mp.PermissionId == permission.PermissionId))
{
_securityManager.DeleteModulePermission(module.ModuleId, permission.PermissionId);
}
}
#endregion
return(Ok(new { module.ModuleId }));
}
public int Update(PlaceInfo placeInfo)
{
string sQry = "UPDATE [BillGatesPlaceInfo] SET [Place]='" + placeInfo.Place + "',[About]='" + placeInfo.About + "',[City]='" + placeInfo.City + "',[State]='" + placeInfo.State + "',[Country]='" + placeInfo.Country + "' WHERE [Id]=" + placeInfo.Id;
int retVal = ExecuteCRUDByQuery(sQry);
return(retVal);
}
public async Task <IActionResult> PutPlaceInfo(int id, PlaceInfo placeInfo)
{
if (id != placeInfo.Id)
{
return(BadRequest());
}
context.Entry(placeInfo).State = EntityState.Modified;
try
{
await context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!PlaceInfoExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
private async void CloseSettings_Click(object sender, RoutedEventArgs e)
{
SettingsPageGrid.Visibility = Visibility.Collapsed;
SettingsPage.Content = "";
if (IsFavoritesChanged == true)
{
IsFavoritesChanged = false;
var favorites = (await UserDataHelper.GetFavorites("Favorites.json"));
var _CurrentPlace = favorites.Where(x => x.PlaceId == _CityData.PlaceInfo.PlaceId).ToList();
if (_CurrentPlace.Count == 0)
{
SaveToFavorites.Visibility = Visibility.Visible;
RemoveFromFavorites.Visibility = Visibility.Collapsed;
}
}
if (IsSettingsChanged == true)
{
IsSettingsChanged = false;
PlaceInfo _argument = null;
var rootFrame = Window.Current.Content as Frame;
if (rootFrame == null)
{
rootFrame = new Frame();
}
if (_CityData.PlaceInfo.PlaceId != _Settings.DefaultLocation.PlaceId)
{
_argument = _CityData.PlaceInfo;
}
rootFrame.Navigate(typeof(ShellPage), _argument);
}
}
private void Fürth_Click(object sender, RoutedEventArgs e)
{
MapService.ServiceToken = "abcdef-abcdefghijklmno";
Bestellung4.Text = "- Fürth \r\n";
Geopoint seattlePoint = new Geopoint
(new BasicGeoposition
{
Latitude = 49.4954,
Longitude = 10.9444
});
PlaceInfo spaceNeedlePlace = PlaceInfo.Create(seattlePoint);
FrameworkElement targetElement = (FrameworkElement)sender;
GeneralTransform generalTransform =
targetElement.TransformToVisual((FrameworkElement)targetElement.Parent);
Rect rectangle = generalTransform.TransformBounds(new Rect(new Point
(targetElement.Margin.Bottom, targetElement.Margin.Bottom), targetElement.RenderSize));
spaceNeedlePlace.Show(rectangle, Windows.UI.Popups.Placement.Below);
}
public void PlacesGetInfoBasicTest()
{
var f = Instance;
var placeId = "X9sTR3BSUrqorQ";
PlaceInfo p = f.PlacesGetInfo(placeId, null);
Console.WriteLine(f.LastResponse);
Assert.IsNotNull(p);
Assert.AreEqual(placeId, p.PlaceId);
Assert.AreEqual("30079", p.WoeId);
Assert.AreEqual(PlaceType.Locality, p.PlaceType);
Assert.AreEqual("Newcastle upon Tyne, England, United Kingdom", p.Description);
Assert.AreEqual("X9sTR3BSUrqorQ", p.Locality.PlaceId);
Assert.AreEqual("myqh27pQULzLWcg7Kg", p.County.PlaceId);
Assert.AreEqual("2eIY2QFTVr_DwWZNLg", p.Region.PlaceId);
Assert.AreEqual("cnffEpdTUb5v258BBA", p.Country.PlaceId);
Assert.IsTrue(p.HasShapeData);
Assert.IsNotNull(p.ShapeData);
Assert.AreEqual(0.00015, p.ShapeData.Alpha);
Assert.AreEqual(1, p.ShapeData.PolyLines.Count);
Assert.AreEqual(89, p.ShapeData.PolyLines[0].Count);
Assert.AreEqual(55.030498504639, p.ShapeData.PolyLines[0][88].X);
Assert.AreEqual(-1.6404060125351, p.ShapeData.PolyLines[0][88].Y);
}
/// <inheritdoc cref="IViewManager.SavePlaceAsync(PlaceInfo)" />
public async Task <bool> SavePlaceAsync(PlaceInfo place)
{
if (place is null)
{
return(false);
}
Place currentPlace = await _dbContext.KastraPlaces
.SingleOrDefaultAsync(p => p.PlaceId == place.PlaceId);
if (currentPlace != null)
{
currentPlace.KeyName = place.KeyName;
currentPlace.PageTemplateId = place.PageTemplateId;
currentPlace.PlaceId = place.PlaceId;
currentPlace.ModuleId = place.ModuleId;
_dbContext.KastraPlaces.Update(currentPlace);
}
else
{
_dbContext.KastraPlaces.Add(place.ToPlace());
}
await _dbContext.SaveChangesAsync();
// Clear cache
_cacheEngine.ClearCacheContains("Place");
return(true);
}
//pops from stack information
public void popFromStack()
{
PlaceInfo ti = placeStack.Pop();
transform.position = ti.position;
transform.rotation = ti.rotation;
}
void OnLoginResponse(uint id, object obj, object localArg)
{
Debug.Log("id" + id);
if (obj == null)
{
Debug.LogError("no response data!!!");
return;
}
armanager.places.Clear();
armanager.location.Latitude = 22.5f;
armanager.location.Longitude = 113.943372f;
NearByPlayer nbp = obj as NearByPlayer;
for (int i = 0; i < nbp.data.Count; i++)
{
PlaceInfo info = new PlaceInfo();
Debug.Log("players:" + nbp.data[i].uid);
Debug.Log("name:" + nbp.data[i].uname);
Debug.Log("latitude:" + nbp.data[i].latitude);
Debug.Log("longitude:" + nbp.data[i].longitude);
Debug.Log("distance:" + nbp.data[i].distance);
info.id = nbp.data [i].uid;
info.Name = nbp.data [i].uname;
info.Latitude = nbp.data [i].latitude;
info.Longitude = nbp.data [i].longitude;
info.Distance = nbp.data [i].distance;
armanager.places.Add(info);
}
armanager.ShowPlaces();
}
public MapObjectData(PlaceInfo data)
{
x = (int)data.pos.x;
y = (int)data.pos.y;
team = data.team.ToString();
no = data.no;
type = data.type.ToString();
}
public async Task <PlaceInfo> Store(PlaceInfo placeInfo)
{
await _context.PlaceInfos.AddAsync(placeInfo);
await _context.SaveChangesAsync();
return(placeInfo);
}
private LocationResponse GetLocationForPlace(PlaceInfo place)
{
var link = string.Format(_locationApiLink, place.location_id, _accessKey);
var jsonStream = _fetcher.GetHttpStream(link);
var placeLocation = JsonConvert.DeserializeObject <LocationResponse>(jsonStream);
return(placeLocation);
}
private static bool IsAValidAttraction(PlaceInfo place)
{
var allowedGroupList = _applicableGroupsString.Split(',').ToList();
var allowedGroupCategoryList = _applicableGroupCategories.Split(',').ToList();
return(place.locationResponse.groups != null &&
place.locationResponse.groups.Exists(x => allowedGroupList.Contains(x.name)) &&
place.locationResponse.groups.Any(group => group.categories.Exists(x => allowedGroupCategoryList.Contains(x.name))));
}
public int Add(PlaceInfo placeInfo)
{
string sQry = "INSERT INTO [BillGatesPlaceInfo] ([Place],[About],[City],[State],[Country]) " +
"VALUES('" + placeInfo.Place + "','" + placeInfo.About + "','" + placeInfo.City + "','" +
placeInfo.State + "','" + placeInfo.Country + "')";
int retVal = ExecuteCRUDByQuery(sQry);
return(retVal);
}
public static PlaceModel ToPlaceModel(PlaceInfo placeInfo)
{
PlaceModel model = new PlaceModel();
model.Id = placeInfo.PlaceId;
model.Keyname = placeInfo.KeyName;
model.TemplateId = placeInfo.PageTemplateId;
return(model);
}
public PlaceInfo Add(AddPlaceInfoInput input)
{
PlaceInfo entity = this.CreateEntity <PlaceInfo>();
entity.Address = input.Address;
entity.Code = input.Code;
entity.Describe = input.Describe;
entity.PlaceName = input.PlaceName;
return(this.DbContext.Insert(entity));
}
public IActionResult Post([FromBody] PlaceInfo newPlace)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
_placeInfoService.CreateNewPlace(newPlace);
return(CreatedAtAction("Post", newPlace));
}
public object Clone()
{
PlaceInfo clone = new PlaceInfo();
clone.pos = pos;
clone.team = team;
clone.type = type;
clone.no = no;
return(clone);
}
private static string retrieveRegionDescription(PlaceInfo pi)
{
string region_desc = string.Empty;
if (pi != null && pi.Region != null && !string.IsNullOrEmpty(pi.Region.Description))
{
region_desc = pi.Region.Description;
}
return(region_desc);
}
private static string retrieveLocalityDescription(PlaceInfo pi)
{
string locality_desc = string.Empty;
if (pi != null && pi.Locality != null && !string.IsNullOrEmpty(pi.Locality.Description))
{
locality_desc = pi.Locality.Description;
}
return(locality_desc);
}
private static BarData PlaceToBar(PlaceInfo place)
{
return(new BarData
{
Title = place.name,
BarId = place.name, // Temporary solution until we decide on BarId
Latitude = double.Parse(place.locationResponse.latitude, CultureInfo.InvariantCulture),
Longitude = double.Parse(place.locationResponse.longitude, CultureInfo.InvariantCulture),
Ratings = new List <int>()
});
}
private async Task <bool> UpdateMyLocation()
{
try
{
var newLocation = await _locationProvider.GetLocationAsync();
if (newLocation == null)
{
return(false);
}
var distance = Utilities.GpsUtils.Distance(myLocation, newLocation);
if (distance < 100 && Math.Abs(myLocation.Altitude - newLocation.Altitude) < 30)
{
return(false);
}
bool needRefresh = false;
if (distance > 100)
{
myLocation.Latitude = newLocation.Latitude;
myLocation.Longitude = newLocation.Longitude;
needRefresh = true;
}
//keep old location if new location has no altitude
if (!Utilities.GpsUtils.HasAltitude(myLocation) ||
(Utilities.GpsUtils.HasAltitude(newLocation) && Math.Abs(newLocation.Altitude - myLocation.Altitude) > 100))
{
myLocation.Altitude = newLocation.Altitude;
needRefresh = true;
}
if (needRefresh)
{
var poi = Database.GetNearestPoi(myLocation, iGpsUtilities);
if (poi != null)
{
myLocationPlaceInfo = new PlaceInfo(poi.Poi.Name, poi.Poi.Country);
}
else
{
myLocationPlaceInfo = (await PlaceNameProvider.AsyncGetPlaceName(myLocation));
}
}
return(needRefresh);
}
catch (Exception ex)
{
LogError("Location update error", ex);
return(false);
}
}
public async Task<PlaceInfo> GetGeoInfo(string id)
{
var f = flFactory.GetInstance();
var placeInfo = new PlaceInfo();
f.PhotosGeoGetLocationAsync(id, (data) =>
{
placeInfo = data.Result;
});
return placeInfo;
}
public static string NameWithCountry(PlaceInfo pi)
{
return pi.name + ", " + pi.country.name;
}
private void LoadElements(System.Xml.XmlReader reader)
{
while (reader.LocalName != "photo")
{
switch (reader.LocalName)
{
case "owner":
ParseOwner(reader);
break;
case "title":
Title = reader.ReadElementContentAsString();
break;
case "description":
Description = reader.ReadElementContentAsString();
break;
case "visibility":
ParseVisibility(reader);
break;
case "permissions":
ParsePermissions(reader);
break;
case "editability":
ParseEditability(reader);
break;
case "publiceditability":
ParsePublicEditability(reader);
break;
case "dates":
ParseDates(reader);
break;
case "usage":
ParseUsage(reader);
break;
case "comments":
CommentsCount = reader.ReadElementContentAsInt();
break;
case "notes":
ParseNotes(reader);
break;
case "tags":
ParseTags(reader);
break;
case "urls":
ParseUrls(reader);
break;
case "location":
Location = new PlaceInfo();
((IFlickrParsable)Location).Load(reader);
break;
case "geoperms":
GeoPermissions = new GeoPermissions();
((IFlickrParsable)GeoPermissions).Load(reader);
break;
case "video":
VideoInfo = new VideoInfo();
((IFlickrParsable)VideoInfo).Load(reader);
break;
case "people":
HasPeople = reader.GetAttribute("haspeople") == "1";
reader.Skip();
break;
case "path_alias":
PathAlias = reader.Value;
break;
default:
UtilityMethods.CheckParsingException(reader);
reader.Skip();
break;
}
}
reader.Skip();
}
