/// <summary>
/// Updates all rooms in the lobby.
/// </summary>
public void UpdateRooms()
{
var result = _connection.GetRooms(false);
Rooms.Clear();
bool found = false;
foreach (var room in result)
{
var model = new RoomViewModel()
{
Room = room
};
Rooms.Add(model);
if (CurrentRoom != null && room.Id == CurrentRoom.Id)
{
found = true;
CurrentRoom = model;
}
}
if (!found)
{
CurrentRoom = null;
}
}
/// <summary>
/// Creates Rooms by orthogonally dividing the interior of the Story perimeter by a quantity of x-axis and y-axis intervals.
/// Adds the new Rooms to the Rooms list.
/// New Rooms conform to Corridor and Service perimeters.
/// </summary>
/// <param name="xRooms">Quantity Rooms along the orthogonal x-axis.</param>
/// <param name="yRooms">Quantity Rooms along the orthogonal y-axis.</param>
/// <param name="height">Height of the new Rooms.</param>
/// <param name="setback">Offset from the Story perimeter.</param>
/// <param name="name">String identifier applied to every new Room.</param>
/// <param name="color">Rendering color of the Room as a Space.</param>
/// <returns>
/// None.
/// </returns>
public void RoomsByDivision(int xRooms = 1,
int yRooms = 1,
double height = 3.0,
double setback = 0.0,
string name = "",
Color color = null)
{
if (Perimeter == null)
{
throw new ArgumentNullException(Messages.PERIMETER_NULL_EXCEPTION);
}
if (setback < 0.0)
{
throw new ArgumentNullException(Messages.NONPOSITIVE_VALUE_EXCEPTION);
}
Rooms.Clear();
var polygon = Perimeter.Offset(setback * -1.0).First();
var roomGroup = new RoomGroup(polygon, xRooms, yRooms, name);
roomGroup.SetElevation(Elevation);
roomGroup.SetHeight(height);
Rooms.AddRange(roomGroup.Rooms);
RoomsColor = color;
FitRoomsToServices();
FitRoomsToCorridors();
}
async Task ExecuteLoadRoomsCommand()
{
if (IsBusy)
{
return;
}
IsBusy = true;
try
{
Rooms.Clear();
var rooms = await RoomDataStore.GetMembersAsync(true);
foreach (var room in rooms)
{
Rooms.Add(room);
}
}
catch (Exception ex)
{
Debug.WriteLine(ex);
}
finally
{
IsBusy = false;
}
}
public void GetAllRoomsAndCorridors()
{
Rooms.Clear();
Corridors.Clear();
ClearAllSpaces(TileMap, NumColumns, NumRows);
DetermineSpaceTypes();
for (int column = 0; column < NumColumns; column++)
{
for (int row = 0; row < NumRows; row++)
{
Tile activeSpace = GetFloorSpace(column, row);
if (activeSpace == null)
{
continue;
}
if (activeSpace.SpaceType == SpaceType.Room)
{
if (activeSpace.Parent == null)
{
Rooms.Add(CreateRoomFromSpace(activeSpace));
}
}
else if (activeSpace.SpaceType == SpaceType.Corridor)
{
if (activeSpace.Parent == null)
{
Corridors.Add(CreateCorridorFromSpace(activeSpace));
}
}
}
}
}
private async Task <bool> InitaliseRooms()
{
Rooms.Clear();
IMobileServiceTableQuery <RoomItem> roomQuery;
roomQuery = RoomTable.RoomSyncTable.Where(p => p.HomeId == SelectedHomeId);
await RoomTable.Read(roomQuery);
foreach (RoomItem RoomItem in RoomTable.RoomItems)
{
Room room = RoomConverter.CreateFrom(RoomItem);
IMobileServiceTableQuery <DeviceItem> deviceQuery;
deviceQuery = DeviceTable.deviceTable.Where(p => p.RoomId == room.Id);
await DeviceTable.Read(deviceQuery);
foreach (DeviceItem DeviceItem in DeviceTable.deviceItems)
{
Device device = DeviceConverter.CreateFrom(DeviceItem);
try
{
device = await Lights.GetLightState(device);
}
catch (Exception e)
{
device.HasAccess = false;
}
}
Rooms.Add(room);
}
return(true);
}
public void ResetWithHome(HMHome home)
{
Accessories.Clear();
Accessories.AddRange(home.Accessories);
Accessories.SortByLocalizedName(a => a.Name);
Rooms.Clear();
Rooms.AddRange(home.GetAllRooms());
Rooms.SortByLocalizedName(r => r.Name);
Zones.Clear();
Zones.AddRange(home.Zones);
Zones.SortByLocalizedName(z => z.Name);
ActionSets.Clear();
ActionSets.AddRange(home.ActionSets);
ActionSets.SortByTypeAndLocalizedName();
Triggers.Clear();
Triggers.AddRange(home.Triggers);
Triggers.SortByLocalizedName(t => t.Name);
ServiceGroups.Clear();
ServiceGroups.AddRange(home.ServiceGroups);
ServiceGroups.SortByLocalizedName(sg => sg.Name);
}
/// <summary>
///
/// </summary>
/// <param name="suite"></param>
/// <returns></returns>
private void PlaceByAxis()
{
if (Rooms.Count == 0)
{
return;
}
var area = 0.0;
foreach (var room in Rooms)
{
area += room.Area;
}
var roomRows = new List <RoomRow>();
while (RoomsPlaced.Count < Rooms.Count)
{
roomRows.Clear();
Perimeter = Shaper.RectangleByArea(area * 0.5, Ratio);
var roomRow = new RoomRow(Perimeter);
roomRows.Add(roomRow);
var i = 0;
while (i < Rooms.Count)
{
if (!roomRow.AddRoomFitted(Rooms[i], false))
{
break;
}
i++;
}
if (i == Rooms.Count)
{
return;
}
var compass = Perimeter.Compass();
var row = new Line(compass.SE, compass.SW);
var matchRow = new RoomRow(row, area / row.Length());
roomRows.Add(matchRow);
while (i < Rooms.Count)
{
if (!matchRow.AddRoomFitted(Rooms[i], false))
{
break;
}
i++;
}
Ratio += 0.1;
}
Rooms.Clear();
foreach (var roomRow in roomRows)
{
foreach (var room in roomRow.Rooms)
{
Rooms.Add(room);
}
}
Perimeter = Footprint;
}
public void GetRooms(int id_h, string package)
{
Rooms.Clear();
var rooms = RoomRepository.GetRooms(id_h, package);
foreach (var r in rooms)
{
Rooms.Add(r);
}
}
/// <summary>
/// Completely clears the current level
/// then constructs a new one.
/// </summary>
public static void NewLevel()
{
Grid.Clear();
Rooms.Clear();
Monsters.Clear();
ClearLocals();
Construct();
LevelUpMonsters(LevelCount);
LevelCount++;
}
private void RefreshRooms()
{
Rooms.Clear();
var rooms = App.DataService.GetAllRoomsForBuilding(CurrentBuilding.UID);
foreach (var room in rooms)
{
Rooms.Add(room);
}
}
/// <summary>
/// Private function conforming the Rooms all other Story Room lists.
/// </summary>
private void FitRooms()
{
var rooms = Rooms.ToList();
Rooms.Clear();
foreach (var room in rooms)
{
AddRoom(room);
}
}
private void ClearTabs()
{
foreach (var room in Rooms)
{
room.Dispose();
}
Rooms.Clear();
Rooms.Add(new RoomViewModel(this));
SelectedRoomIndex = 0;
}
public void Clear()
{
GameCenter.ClearAll();
UserManager.Clear();
Leagues.Clear();
Players.Clear();
Rooms.Clear();
Users.Clear();
PlayerToRoom.Clear();
RoomToLeague.Clear();
}
/// <summary>
/// Updates the Statistics TextBoxes with the current information
/// </summary>
public void UpdateStatistics()
{
Customers.Clear();
Facilities.Clear();
Cleaners.Clear();
Rooms.Clear();
foreach (Customer c in GlobalStatistics.Customers)
{
if (c.InArea != null)
{
Customers.AppendText($"ID: {c.ID} \t {c.Name} \t {c.AssignedRoom.ID} \t Location: {c.InArea.ID}\n");
}
else
{
Customers.AppendText($"ID: {c.ID} \t {c.Name} \t {c.AssignedRoom.ID}\n");
}
}
foreach (Cleaner c in GlobalStatistics.Cleaners)
{
if (c.CurrentTask != null)
{
Cleaners.AppendText($"ID: {c.CleanerID} \t {c.Name} \t Current Task: {c.CurrentTask.RoomToClean.Area.ID}\n");
}
else
{
Cleaners.AppendText($"ID: {c.CleanerID} \t {c.Name}\n");
}
}
foreach (Room c in GlobalStatistics.Rooms)
{
if (c.RoomOwner == null)
{
Rooms.AppendText($"ID: {c.ID} \t Room {c.Classification} Stars \t EMPTY\n");
}
else
{
Rooms.AppendText($"ID: {c.ID} \t Room {c.Classification} Stars \t {c.RoomOwner.ID}\n");
}
}
foreach (Restaurant c in GlobalStatistics.Restaurants)
{
Facilities.AppendText($"ID: {c.ID} \t Eating Time: {c.EatingTime} \t {c.Capacity}\n");
}
foreach (Cinema c in GlobalStatistics.Cinemas)
{
Facilities.AppendText($"ID: {c.ID} \t Movie Time: {c.MovieTime}\n");
}
foreach (Fitness c in GlobalStatistics.FitnessCenters)
{
Facilities.AppendText($"ID: {c.ID}\n");
}
}
private void ClearTabs()
{
AllUsers.Clear();
foreach (var room in Rooms)
{
room.Dispose();
}
Rooms.Clear();
Rooms.Add(new RoomViewModel(this, new Room(null, ServerModel.MainRoomName), null));
SelectedRoomIndex = 0;
}
private void ResetAlgorithm()
{
ResSchedule?.Clear();
Rooms?.Clear();
Classes?.Clear();
DictionaryOfSubjects?.Clear();
DictionaryOfGroups?.Clear();
Groups?.Clear();
Subjects?.Clear();
GroupSubjects?.Clear();
Teachers?.Clear();
TeacherSubjects?.Clear();
ClassRepo.DeleteAllFromDb();
}
public async Task <bool> GetRooms(string homeid)
{
Rooms.Clear();
IMobileServiceTableQuery <RoomItem> roomQuery;
roomQuery = RoomTable.RoomSyncTable.Where(p => p.HomeId == homeid);
await RoomTable.Read(roomQuery);
foreach (RoomItem RoomItem in RoomTable.RoomItems)
{
Room room = RoomConverter.CreateFrom(RoomItem);
Rooms.Add(room);
}
return(true);
}
public override Task Close()
{
CancelPreviousLogin();
Rooms.Clear();
LogRooms.Clear();
_xmppConnection.OnRosterItem -= OnClientRosterItem;
_xmppConnection.OnLogin -= OnLogin;
_xmppConnection.OnError -= OnError;
_xmppConnection.OnMessage -= OnMessage;
_xmppConnection.Close();
_xmppConnection = null;
return(Task.FromResult(1));
}
private void Shutdown()
{
if (!_valid)
{
return;
}
logger.Debug("Shutdown called.");
tokenSource.Cancel();
SaveConfigToFile();
Rooms.ToList().ForEach(rr =>
{
rr.Shutdown();
});
Rooms.Clear();
}
public void Close()
{
if (!ProjectLoaded)
{
return;
}
Rooms.Clear();
DoorSets.Clear();
Doors.Clear();
ScrollSets.Clear();
PlmSets.Clear();
ScrollPlmDatas.Clear();
Backgrounds.Clear();
Fxs.Clear();
SaveStations.Clear();
LevelDatas.Clear();
EnemySets.Clear();
EnemyGfxs.Clear();
ScrollAsms.Clear();
DoorAsms.Clear();
SetupAsms.Clear();
MainAsms.Clear();
TileSets.Clear();
TileTables.Clear();
TileSheets.Clear();
Palettes.Clear();
AreaMaps.Clear();
PlmTypes.Clear();
EnemyTypes.Clear();
CurrentRom = null;
ProjectPath = String.Empty;
RomFileName = String.Empty;
ProjectFileName = String.Empty;
RoomTiles.Clear();
MapTiles.Clear();
BackgroundImage = null;
ChangesMade = false;
ProjectLoaded = false;
ProjectClosed?.Invoke(this, null);
}
// Call the Worker thread to load the list of rooms for the connected project service uri
private void LoadRooms()
{
try
{
TeamRoomWindowCommand.Instance.LogMessage("Loading Rooms");
RoomUsers.Clear();
teamRoom = null;
Rooms.Clear();
cmbRoomList.Text = "Loading Team Rooms...";
if (projectCollectionUri != null)
{
RoomWorker.Instance.LoadRooms(projectCollectionUri);
}
}
catch (Exception ex) {
throw;
}
}
private async Task ConnectSocket()
{
for (var i = 0; i < 10 && _socket == null; i++)
{
var start = _api.RtmStart();
if (!start.Ok)
{
Logger.WarnFormat("Unable to start connection with Slack Adapter ({0}). Retrying", start.Error);
await Task.Delay(TimeSpan.FromSeconds(1));
continue;
}
// URL only valid for 30sec
_socket = new WebSocket(start.Url);
_botUserId = start.Self.Id;
_users = start.Users.ToList();
_rooms = start.Channels.ToList();
_ims = start.Ims.ToList();
Rooms.Clear();
Rooms.AddAll(start.Channels.Select(c => c.Name));
LogRooms.Clear();
LogRooms.AddAll(Rooms.Intersect(_logRooms, StringComparer.InvariantCultureIgnoreCase));
}
if (_socket == null)
{
Logger.Error("Unable to create socket for Slack Adapter");
return;
}
_socket.Closed += SocketOnClose;
_socket.Error += SocketOnError;
_socket.MessageReceived += SocketOnMessage;
_socket.Open();
Logger.Info("Slack socket connected");
}
/// <summary>
/// Creates Rooms by orthogonally dividing the interior of the Story perimeter by a quantity of x-axis and y-axis intervals.
/// Adds the new Rooms to the Rooms list.
/// New Rooms conform to Corridor and Service perimeters.
/// </summary>
/// <param name="xRooms">Quantity Rooms along the orthogonal x-axis.</param>
/// <param name="yRooms">Quantity Rooms along the orthogonal y-axis.</param>
/// <param name="height">Height of the new Rooms.</param>
/// <param name="setback">Offset from the Story perimeter.</param>
/// <param name="name">String identifier applied to every new Room.</param>
/// <param name="color">Rendering color of the Room as a Space.</param>
/// <returns>
/// None.
/// </returns>
public bool RoomsByDivision(int xRooms = 1,
int yRooms = 1,
double height = 3.0,
double setback = 0.0,
string name = "",
Color color = null,
bool fit = true)
{
if (Perimeter == null || height < 0.0 || setback < 0.0 || xRooms < 1 || yRooms < 1)
{
return(false);
}
var polygon = Perimeter.Offset(setback * -1.0).First();
var roomGroup =
new RoomGroup()
{
Name = name,
Perimeter = polygon
};
roomGroup.RoomsByDivision(xRooms, yRooms, height, name);
roomGroup.Elevation = Elevation;
roomGroup.SetHeight(height);
roomGroup.SetColor(color);
var fitRooms = new List <Room>(roomGroup.Rooms);
if (fit)
{
var toRooms = new List <Room>(Exclusions);
toRooms.AddRange(Services);
toRooms.AddRange(Corridors);
fitRooms = FitRooms(fitRooms, toRooms);
}
if (fitRooms.Count == 0)
{
return(false);
}
Rooms.Clear();
Rooms.AddRange(fitRooms);
return(true);
}
public async Task LoadRooms()
{
IsLoading = true;
RaisePropertyChanged(() => IsLoading);
foreach (var c in Service.Connections)
{
try
{
var rooms = await c.Client.GetRooms();
lock (Rooms)
{
var roomList = from r in rooms
where !r.Closed
orderby r.Count descending
select new RoomListItemViewModel(c, r);
Rooms.Clear();
if (roomList != null)
{
foreach (var r in roomList)
{
Rooms.Add(r);
}
}
IsLoading = false;
RaisePropertyChanged(() => IsLoading);
//RaisePropertyChanged(() => Rooms);
}
}
catch (Exception ex)
{
Mvx.Trace(c.Account.Url + " -> GetRooms Failed: " + ex);
}
}
}
public async Task <bool> DeleteAccount(string password)
{
if (IsBusy)
{
return(false);
}
if (People.HashString(password) != CurrentLoginInfo.PasswordHash)
{
ErrorDialog("Wrong password", "Verification failed");
return(false);
}
IsBusy = true;
return(await Task.Run(async() =>
{
try
{
System.Net.HttpStatusCode res = await _peopleController.DeleteByID(CurrentLoginInfo.ID);
if (res == System.Net.HttpStatusCode.OK)
{
Toast = "Successfully deleted";
Records.Clear();
Reservations.Clear();
Rooms.Clear();
Services.LocalData.DeleteLoginInfo();
IsLoggedIn = false;
CurrentLoginInfo = null;
return true;
}
}
catch (Exception e)
{
ErrorDialog(e.Message, "Task faild");
}
finally
{
IsBusy = false;
}
return true;
}));
}
private async void LogoutButton_OnClick(object sender, RoutedEventArgs e)
{
var logoutDialog = new ContentDialog
{
Title = "Are you sure you want to logout?",
Content = "Your actions will be saved.",
PrimaryButtonText = "Log out",
CloseButtonText = "Cancel"
};
var result = await logoutDialog.ShowAsync(); //Venter på brukerklikk
if (result != ContentDialogResult.Primary)
{
return;
}
RequestTimer.Dispose();
CurrentEmployee = null;
CurrentRoom = null;
Rooms.Clear();
Frame.Navigate(typeof(MainPage));
}
private void CreateNewReservationDialogViewModel_OnDateChanged()
{
if (Rooms != null)
{
if (Rooms.Any())
{
Rooms.Clear();
}
}
var rooms = _roomService.LoadAvailableRooms(StartDate, EndDate, PeopleNumber);
if (rooms != null)
{
Rooms = new ObservableCollection <AvailableRoomRequest>(rooms);
}
if (rooms is null)
{
MessageBox.Show("Nema slobodnih soba za izabrani period", "Obavestenje");
}
}
private void LoadRooms(IEnumerable <Room> rooms)
{
Rooms.Clear();
if (rooms != null)
{
foreach (var item in rooms)
{
Rooms.Add(item);
}
if (savedteamRoomId != 0 && Rooms.Select(x => x.Id).Contains(savedteamRoomId))
{
foreach (Room item in cmbRoomList.Items)
{
if (item.Id == savedteamRoomId)
{
cmbRoomList.SelectedIndex = cmbRoomList.Items.IndexOf(item);
break;
}
}
}
}
}
/// <summary>
/// Command for retrieving rooms from the database - implementation
/// </summary>
/// <returns></returns>
async Task ExecuteLoadRoomsCommand()
{
IsBusy = true;
try
{
Rooms.Clear();
var rooms = await DependencyService.Get <IConnector>().RoomsOverview();
foreach (var room in rooms)
{
Rooms.Add(room);
}
}
catch
{
Rooms = null;
}
finally
{
IsBusy = false;
}
}
/// <summary>
/// Clears the current Rooms list and creates new Rooms defined by orthogonal x- and y-axis divisions of the RoomGroup Perimeter.
/// </summary>
/// <param name="xRooms">The quantity of Rooms along orthogonal x-axis. Must be positive.</param>
/// <param name="yRooms">The quantity of Rooms along orthogonal y-axis. Must be positive.</param>
/// <returns>
/// True if the Rooms are created.
/// </returns>
public bool RoomsByDivision(int xRooms = 1, int yRooms = 1, double height = 3.0, string name = "")
{
if (Perimeter == null || xRooms < 1 || yRooms < 1 || height <= 0.0)
{
return(false);
}
var sizeX = SizeX / xRooms;
var sizeY = SizeY / yRooms;
var count = xRooms * yRooms;
var box = new TopoBox(Perimeter);
var newRooms = new List <Room>();
for (int xIdx = 0; xIdx < xRooms; xIdx++)
{
var xCoord = box.SW.X + (xIdx * sizeX);
for (int yIdx = 0; yIdx < yRooms; yIdx++)
{
var yCoord = box.SW.Y + (yIdx * sizeY);
var polygon = Shaper.Rectangle(sizeX, sizeY);
polygon = polygon.MoveFromTo(Vector3.Origin, new Vector3(xCoord, yCoord)).Intersection(Perimeter).First();
var room = new Room()
{
Height = height,
Name = name,
Perimeter = polygon
};
newRooms.Add(room);
}
}
if (newRooms.Count == 0)
{
return(false);
}
Rooms.Clear();
Rooms.AddRange(newRooms);
return(true);
}
