2057 lines
81 KiB
C#
2057 lines
81 KiB
C#
// Copyright (c) 2015, Outercurve Foundation.
|
|
// All rights reserved.
|
|
//
|
|
// Redistribution and use in source and binary forms, with or without modification,
|
|
// are permitted provided that the following conditions are met:
|
|
//
|
|
// - Redistributions of source code must retain the above copyright notice, this
|
|
// list of conditions and the following disclaimer.
|
|
//
|
|
// - Redistributions in binary form must reproduce the above copyright notice,
|
|
// this list of conditions and the following disclaimer in the documentation
|
|
// and/or other materials provided with the distribution.
|
|
//
|
|
// - Neither the name of the Outercurve Foundation nor the names of its
|
|
// contributors may be used to endorse or promote products derived from this
|
|
// software without specific prior written permission.
|
|
//
|
|
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
|
|
// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
|
// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
|
// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
|
|
// ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
|
// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
|
// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
|
|
// ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
|
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
using System;
|
|
using System.Linq;
|
|
using System.Net;
|
|
using System.Net.Sockets;
|
|
using System.Net.NetworkInformation;
|
|
using System.Runtime.CompilerServices;
|
|
using System.Xml;
|
|
using System.Data;
|
|
using System.Collections.Specialized;
|
|
using System.Collections.Generic;
|
|
using System.Text;
|
|
using WebsitePanel.Providers.Common;
|
|
using WebsitePanel.Providers.EnterpriseStorage;
|
|
using WebsitePanel.Providers.HostedSolution;
|
|
using WebsitePanel.Providers.OS;
|
|
using WebsitePanel.Providers.RemoteDesktopServices;
|
|
using WebsitePanel.Providers.Web;
|
|
using System.Net.Mail;
|
|
using System.Collections;
|
|
using WebsitePanel.EnterpriseServer.Base.RDS;
|
|
|
|
namespace WebsitePanel.EnterpriseServer
|
|
{
|
|
public class RemoteDesktopServicesController
|
|
{
|
|
private RemoteDesktopServicesController()
|
|
{
|
|
|
|
}
|
|
|
|
public static int GetRemoteDesktopServiceId(int itemId)
|
|
{
|
|
return GetRdsServiceId(itemId);
|
|
}
|
|
|
|
public static RdsCollection GetRdsCollection(int collectionId)
|
|
{
|
|
return GetRdsCollectionInternal(collectionId);
|
|
}
|
|
|
|
public static RdsCollectionSettings GetRdsCollectionSettings(int collectionId)
|
|
{
|
|
return GetRdsCollectionSettingsInternal(collectionId);
|
|
}
|
|
|
|
public static List<RdsCollection> GetOrganizationRdsCollections(int itemId)
|
|
{
|
|
return GetOrganizationRdsCollectionsInternal(itemId);
|
|
}
|
|
|
|
public static int AddRdsCollection(int itemId, RdsCollection collection)
|
|
{
|
|
return AddRdsCollectionInternal(itemId, collection);
|
|
}
|
|
|
|
public static ResultObject EditRdsCollection(int itemId, RdsCollection collection)
|
|
{
|
|
return EditRdsCollectionInternal(itemId, collection);
|
|
}
|
|
|
|
public static ResultObject EditRdsCollectionSettings(int itemId, RdsCollection collection)
|
|
{
|
|
return EditRdsCollectionSettingsInternal(itemId, collection);
|
|
}
|
|
|
|
public static RdsCollectionPaged GetRdsCollectionsPaged(int itemId, string filterColumn, string filterValue, string sortColumn, int startRow, int maximumRows)
|
|
{
|
|
return GetRdsCollectionsPagedInternal(itemId, filterColumn, filterValue, sortColumn, startRow, maximumRows);
|
|
}
|
|
|
|
public static ResultObject RemoveRdsCollection(int itemId, RdsCollection collection)
|
|
{
|
|
return RemoveRdsCollectionInternal(itemId, collection);
|
|
}
|
|
|
|
public static List<StartMenuApp> GetAvailableRemoteApplications(int itemId, string collectionName)
|
|
{
|
|
return GetAvailableRemoteApplicationsInternal(itemId, collectionName);
|
|
}
|
|
|
|
public static RdsServersPaged GetRdsServersPaged(string filterColumn, string filterValue, string sortColumn, int startRow, int maximumRows)
|
|
{
|
|
return GetRdsServersPagedInternal(filterColumn, filterValue, sortColumn, startRow, maximumRows);
|
|
}
|
|
|
|
public static List<RdsUserSession> GetRdsUserSessions(int collectionId)
|
|
{
|
|
return GetRdsUserSessionsInternal(collectionId);
|
|
}
|
|
|
|
public static RdsServersPaged GetFreeRdsServersPaged(int packageId, string filterColumn, string filterValue, string sortColumn, int startRow, int maximumRows)
|
|
{
|
|
return GetFreeRdsServersPagedInternal(packageId, filterColumn, filterValue, sortColumn, startRow, maximumRows);
|
|
}
|
|
|
|
public static RdsServersPaged GetOrganizationRdsServersPaged(int itemId, int? collectionId, string filterColumn, string filterValue, string sortColumn, int startRow, int maximumRows)
|
|
{
|
|
return GetOrganizationRdsServersPagedInternal(itemId, collectionId, filterColumn, filterValue, sortColumn, startRow, maximumRows);
|
|
}
|
|
|
|
public static RdsServersPaged GetOrganizationFreeRdsServersPaged(int itemId, string filterColumn, string filterValue, string sortColumn, int startRow, int maximumRows)
|
|
{
|
|
return GetOrganizationFreeRdsServersPagedInternal(itemId, filterColumn, filterValue, sortColumn, startRow, maximumRows);
|
|
}
|
|
|
|
public static RdsServer GetRdsServer(int rdsSeverId)
|
|
{
|
|
return GetRdsServerInternal(rdsSeverId);
|
|
}
|
|
|
|
public static ResultObject SetRDServerNewConnectionAllowed(int itemId, bool newConnectionAllowed, int rdsSeverId)
|
|
{
|
|
return SetRDServerNewConnectionAllowedInternal(itemId, newConnectionAllowed, rdsSeverId);
|
|
}
|
|
|
|
public static List<RdsServer> GetCollectionRdsServers(int collectionId)
|
|
{
|
|
return GetCollectionRdsServersInternal(collectionId);
|
|
}
|
|
|
|
public static List<RdsServer> GetOrganizationRdsServers(int itemId)
|
|
{
|
|
return GetOrganizationRdsServersInternal(itemId);
|
|
}
|
|
|
|
public static ResultObject AddRdsServer(RdsServer rdsServer)
|
|
{
|
|
return AddRdsServerInternal(rdsServer);
|
|
}
|
|
|
|
public static ResultObject AddRdsServerToCollection(int itemId, RdsServer rdsServer, RdsCollection rdsCollection)
|
|
{
|
|
return AddRdsServerToCollectionInternal(itemId, rdsServer, rdsCollection);
|
|
}
|
|
|
|
public static ResultObject AddRdsServerToOrganization(int itemId, int serverId)
|
|
{
|
|
return AddRdsServerToOrganizationInternal(itemId, serverId);
|
|
}
|
|
|
|
public static ResultObject RemoveRdsServer(int rdsServerId)
|
|
{
|
|
return RemoveRdsServerInternal(rdsServerId);
|
|
}
|
|
|
|
public static ResultObject RemoveRdsServerFromCollection(int itemId, RdsServer rdsServer, RdsCollection rdsCollection)
|
|
{
|
|
return RemoveRdsServerFromCollectionInternal(itemId, rdsServer, rdsCollection);
|
|
}
|
|
|
|
public static ResultObject RemoveRdsServerFromOrganization(int itemId, int rdsServerId)
|
|
{
|
|
return RemoveRdsServerFromOrganizationInternal(itemId, rdsServerId);
|
|
}
|
|
|
|
public static ResultObject UpdateRdsServer(RdsServer rdsServer)
|
|
{
|
|
return UpdateRdsServerInternal(rdsServer);
|
|
}
|
|
|
|
public static List<OrganizationUser> GetRdsCollectionUsers(int collectionId)
|
|
{
|
|
return GetRdsCollectionUsersInternal(collectionId);
|
|
}
|
|
|
|
public static ResultObject SetUsersToRdsCollection(int itemId, int collectionId, List<OrganizationUser> users)
|
|
{
|
|
return SetUsersToRdsCollectionInternal(itemId, collectionId, users);
|
|
}
|
|
|
|
public static ResultObject AddRemoteApplicationToCollection(int itemId, RdsCollection collection, RemoteApplication application)
|
|
{
|
|
return AddRemoteApplicationToCollectionInternal(itemId, collection, application);
|
|
}
|
|
|
|
public static List<RemoteApplication> GetCollectionRemoteApplications(int itemId, string collectionName)
|
|
{
|
|
return GetCollectionRemoteApplicationsInternal(itemId, collectionName);
|
|
}
|
|
|
|
public static ResultObject RemoveRemoteApplicationFromCollection(int itemId, RdsCollection collection, RemoteApplication application)
|
|
{
|
|
return RemoveRemoteApplicationFromCollectionInternal(itemId, collection, application);
|
|
}
|
|
|
|
public static ResultObject SetRemoteApplicationsToRdsCollection(int itemId, int collectionId, List<RemoteApplication> remoteApps)
|
|
{
|
|
return SetRemoteApplicationsToRdsCollectionInternal(itemId, collectionId, remoteApps);
|
|
}
|
|
|
|
public static ResultObject DeleteRemoteDesktopService(int itemId)
|
|
{
|
|
return DeleteRemoteDesktopServiceInternal(itemId);
|
|
}
|
|
|
|
public static int GetOrganizationRdsUsersCount(int itemId)
|
|
{
|
|
return GetOrganizationRdsUsersCountInternal(itemId);
|
|
}
|
|
|
|
public static int GetOrganizationRdsServersCount(int itemId)
|
|
{
|
|
return GetOrganizationRdsServersCountInternal(itemId);
|
|
}
|
|
|
|
public static int GetOrganizationRdsCollectionsCount(int itemId)
|
|
{
|
|
return GetOrganizationRdsCollectionsCountInternal(itemId);
|
|
}
|
|
|
|
public static List<string> GetApplicationUsers(int itemId, int collectionId, RemoteApplication remoteApp)
|
|
{
|
|
return GetApplicationUsersInternal(itemId, collectionId, remoteApp);
|
|
}
|
|
|
|
public static ResultObject SetApplicationUsers(int itemId, int collectionId, RemoteApplication remoteApp, List<string> users)
|
|
{
|
|
return SetApplicationUsersInternal(itemId, collectionId, remoteApp, users);
|
|
}
|
|
|
|
public static ResultObject LogOffRdsUser(int itemId, string unifiedSessionId, string hostServer)
|
|
{
|
|
return LogOffRdsUserInternal(itemId, unifiedSessionId, hostServer);
|
|
}
|
|
|
|
public static List<string> GetRdsCollectionSessionHosts(int collectionId)
|
|
{
|
|
return GetRdsCollectionSessionHostsInternal(collectionId);
|
|
}
|
|
|
|
public static RdsServerInfo GetRdsServerInfo(int? itemId, string fqdnName)
|
|
{
|
|
return GetRdsServerInfoInternal(itemId, fqdnName);
|
|
}
|
|
|
|
public static string GetRdsServerStatus(int? itemId, string fqdnName)
|
|
{
|
|
return GetRdsServerStatusInternal(itemId, fqdnName);
|
|
}
|
|
|
|
public static ResultObject ShutDownRdsServer(int? itemId, string fqdnName)
|
|
{
|
|
return ShutDownRdsServerInternal(itemId, fqdnName);
|
|
}
|
|
|
|
public static ResultObject RestartRdsServer(int? itemId, string fqdnName)
|
|
{
|
|
return RestartRdsServerInternal(itemId, fqdnName);
|
|
}
|
|
|
|
public static List<OrganizationUser> GetRdsCollectionLocalAdmins(int collectionId)
|
|
{
|
|
return GetRdsCollectionLocalAdminsInternal(collectionId);
|
|
}
|
|
|
|
public static ResultObject SaveRdsCollectionLocalAdmins(OrganizationUser[] users, int collectionId)
|
|
{
|
|
return SaveRdsCollectionLocalAdminsInternal(users, collectionId);
|
|
}
|
|
|
|
public static ResultObject InstallSessionHostsCertificate(RdsServer rdsServer)
|
|
{
|
|
return InstallSessionHostsCertificateInternal(rdsServer);
|
|
}
|
|
|
|
public static RdsCertificate GetRdsCertificateByServiceId(int serviceId)
|
|
{
|
|
return GetRdsCertificateByServiceIdInternal(serviceId);
|
|
}
|
|
|
|
public static RdsCertificate GetRdsCertificateByItemId(int? itemId)
|
|
{
|
|
return GetRdsCertificateByItemIdInternal(itemId);
|
|
}
|
|
|
|
public static ResultObject AddRdsCertificate(RdsCertificate certificate)
|
|
{
|
|
return AddRdsCertificateInternal(certificate);
|
|
}
|
|
|
|
public static List<ServiceInfo> GetRdsServices()
|
|
{
|
|
return GetRdsServicesInternal();
|
|
}
|
|
|
|
public static string GetRdsSetupLetter(int itemId, int? accountId)
|
|
{
|
|
return GetRdsSetupLetterInternal(itemId, accountId);
|
|
}
|
|
|
|
public static int SendRdsSetupLetter(int itemId, int? accountId, string to, string cc)
|
|
{
|
|
return SendRdsSetupLetterInternal(itemId, accountId, to, cc);
|
|
}
|
|
|
|
public static RdsServerSettings GetRdsServerSettings(int serverId, string settingsName)
|
|
{
|
|
return GetRdsServerSettingsInternal(serverId, settingsName);
|
|
}
|
|
|
|
public static int UpdateRdsServerSettings(int serverId, string settingsName, RdsServerSettings settings)
|
|
{
|
|
return UpdateRdsServerSettingsInternal(serverId, settingsName, settings);
|
|
}
|
|
|
|
public static ResultObject ShadowSession(int itemId, string sessionId, bool control)
|
|
{
|
|
return ShadowSessionInternal(itemId, sessionId, control);
|
|
}
|
|
|
|
public static ResultObject ImportCollection(int itemId, string collectionName)
|
|
{
|
|
return ImportCollectionInternal(itemId, collectionName);
|
|
}
|
|
|
|
private static ResultObject ImportCollectionInternal(int itemId, string collectionName)
|
|
{
|
|
var result = TaskManager.StartResultTask<ResultObject>("REMOTE_DESKTOP_SERVICES", "SHADOW_RDS_SESSION");
|
|
|
|
try
|
|
{
|
|
Organization org = OrganizationController.GetOrganization(itemId);
|
|
|
|
if (org == null)
|
|
{
|
|
result.IsSuccess = false;
|
|
result.AddError("IMPORT_RDS_COLLECTION", new NullReferenceException("Organization not found"));
|
|
|
|
return result;
|
|
}
|
|
|
|
var existingCollections = GetRdsCollectionsPaged(itemId, "", "", "", 0, Int32.MaxValue).Collections;
|
|
|
|
if (existingCollections.Select(e => e.Name.ToLower()).Contains(collectionName.ToLower()))
|
|
{
|
|
result.IsSuccess = false;
|
|
throw new InvalidOperationException(string.Format("Collection {0} already exists in database", collectionName));
|
|
}
|
|
|
|
var rds = RemoteDesktopServicesHelpers.GetRemoteDesktopServices(RemoteDesktopServicesHelpers.GetRemoteDesktopServiceID(org.PackageId));
|
|
var collection = rds.GetExistingCollection(collectionName);
|
|
var newCollection = new RdsCollection
|
|
{
|
|
Name = collection.CollectionName,
|
|
Description = collection.Description,
|
|
DisplayName = collection.CollectionName
|
|
};
|
|
|
|
newCollection.Id = DataProvider.AddRDSCollection(itemId, newCollection.Name, newCollection.Description, newCollection.DisplayName);
|
|
newCollection.Settings = RemoteDesktopServicesHelpers.ParseCollectionSettings(collection.CollectionSettings);
|
|
newCollection.Settings.RdsCollectionId = newCollection.Id;
|
|
newCollection.Settings.Id = DataProvider.AddRdsCollectionSettings(newCollection.Settings);
|
|
var existingSessionHosts = GetRdsServersPagedInternal("", "", "", 1, 1000).Servers;
|
|
RemoteDesktopServicesHelpers.FillSessionHosts(collection.SessionHosts, existingSessionHosts, newCollection.Id, itemId);
|
|
newCollection.Servers = ObjectUtils.CreateListFromDataReader<RdsServer>(DataProvider.GetRDSServersByCollectionId(newCollection.Id)).ToList();
|
|
UserInfo user = PackageController.GetPackageOwner(org.PackageId);
|
|
var organizationUsers = OrganizationController.GetOrganizationUsersPaged(itemId, null, null, null, 0, Int32.MaxValue).PageUsers.Select(u => u.SamAccountName.Split('\\').Last().ToLower());
|
|
var newUsers = organizationUsers.Where(x => collection.UserGroups.Select(a => a.PropertyValue.ToString().Split('\\').Last().ToLower()).Contains(x));
|
|
|
|
rds.ImportCollection(org.OrganizationId, newCollection, newUsers.ToArray());
|
|
|
|
var emptySettings = RemoteDesktopServicesHelpers.GetEmptyGpoSettings();
|
|
string xml = RemoteDesktopServicesHelpers.GetSettingsXml(emptySettings);
|
|
DataProvider.UpdateRdsServerSettings(newCollection.Id, string.Format("Collection-{0}-Settings", newCollection.Id), xml);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw TaskManager.WriteError(ex);
|
|
}
|
|
finally
|
|
{
|
|
if (!result.IsSuccess)
|
|
{
|
|
TaskManager.CompleteResultTask(result);
|
|
}
|
|
else
|
|
{
|
|
TaskManager.CompleteResultTask();
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
private static ResultObject ShadowSessionInternal(int itemId, string sessionId, bool control)
|
|
{
|
|
var result = TaskManager.StartResultTask<ResultObject>("REMOTE_DESKTOP_SERVICES", "SHADOW_RDS_SESSION");
|
|
|
|
try
|
|
{
|
|
Organization org = OrganizationController.GetOrganization(itemId);
|
|
|
|
if (org == null)
|
|
{
|
|
result.IsSuccess = false;
|
|
result.AddError("SHADOW_RDS_SESSION", new NullReferenceException("Organization not found"));
|
|
|
|
return result;
|
|
}
|
|
|
|
var rds = RemoteDesktopServicesHelpers.GetRemoteDesktopServices(RemoteDesktopServicesHelpers.GetRemoteDesktopServiceID(org.PackageId));
|
|
rds.ShadowSession(sessionId, control);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
result.AddError("REMOTE_DESKTOP_SERVICES_SHADOW_RDS_SESSION", ex);
|
|
}
|
|
finally
|
|
{
|
|
if (!result.IsSuccess)
|
|
{
|
|
TaskManager.CompleteResultTask(result);
|
|
}
|
|
else
|
|
{
|
|
TaskManager.CompleteResultTask();
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
private static RdsServerSettings GetRdsServerSettingsInternal(int serverId, string settingsName)
|
|
{
|
|
IDataReader reader = DataProvider.GetRdsServerSettings(serverId, settingsName);
|
|
|
|
var settings = new RdsServerSettings();
|
|
settings.ServerId = serverId;
|
|
settings.SettingsName = settingsName;
|
|
|
|
while (reader.Read())
|
|
{
|
|
settings.Settings.Add(new RdsServerSetting
|
|
{
|
|
PropertyName = (string)reader["PropertyName"],
|
|
PropertyValue = (string)reader["PropertyValue"],
|
|
ApplyAdministrators = Convert.ToBoolean(reader["ApplyAdministrators"]),
|
|
ApplyUsers = Convert.ToBoolean(reader["ApplyUsers"])
|
|
});
|
|
}
|
|
|
|
reader.Close();
|
|
|
|
return settings;
|
|
}
|
|
|
|
private static int UpdateRdsServerSettingsInternal(int serverId, string settingsName, RdsServerSettings settings)
|
|
{
|
|
TaskManager.StartTask("REMOTE_DESKTOP_SERVICES", "UPDATE_SETTINGS");
|
|
|
|
try
|
|
{
|
|
var collection = ObjectUtils.FillObjectFromDataReader<RdsCollection>(DataProvider.GetRDSCollectionById(serverId));
|
|
var rds = RemoteDesktopServicesHelpers.GetRemoteDesktopServices(GetRdsServiceId(collection.ItemId));
|
|
Organization org = OrganizationController.GetOrganization(collection.ItemId);
|
|
rds.ApplyGPO(org.OrganizationId, collection.Name, settings);
|
|
string xml = RemoteDesktopServicesHelpers.GetSettingsXml(settings);
|
|
|
|
DataProvider.UpdateRdsServerSettings(serverId, settingsName, xml);
|
|
|
|
return 0;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw TaskManager.WriteError(ex);
|
|
}
|
|
finally
|
|
{
|
|
TaskManager.CompleteTask();
|
|
}
|
|
}
|
|
|
|
private static string GetRdsSetupLetterInternal(int itemId, int? accountId)
|
|
{
|
|
Organization org = OrganizationController.GetOrganization(itemId);
|
|
|
|
if (org == null)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
UserInfo user = PackageController.GetPackageOwner(org.PackageId);
|
|
UserSettings settings = UserController.GetUserSettings(user.UserId, UserSettings.RDS_SETUP_LETTER);
|
|
string settingName = user.HtmlMail ? "HtmlBody" : "TextBody";
|
|
string body = settings[settingName];
|
|
|
|
if (String.IsNullOrEmpty(body))
|
|
{
|
|
return null;
|
|
}
|
|
|
|
string result = RemoteDesktopServicesHelpers.EvaluateMailboxTemplate(body, org, accountId, itemId);
|
|
|
|
return user.HtmlMail ? result : result.Replace("\n", "<br/>");
|
|
}
|
|
|
|
private static int SendRdsSetupLetterInternal(int itemId, int? accountId, string to, string cc)
|
|
{
|
|
int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo);
|
|
|
|
if (accountCheck < 0)
|
|
{
|
|
return accountCheck;
|
|
}
|
|
|
|
Organization org = OrganizationController.GetOrganization(itemId);
|
|
|
|
if (org == null)
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
UserInfo user = PackageController.GetPackageOwner(org.PackageId);
|
|
UserSettings settings = UserController.GetUserSettings(user.UserId, UserSettings.RDS_SETUP_LETTER);
|
|
string from = settings["From"];
|
|
|
|
if (cc == null)
|
|
{
|
|
cc = settings["CC"];
|
|
}
|
|
|
|
string subject = settings["Subject"];
|
|
string body = user.HtmlMail ? settings["HtmlBody"] : settings["TextBody"];
|
|
bool isHtml = user.HtmlMail;
|
|
MailPriority priority = MailPriority.Normal;
|
|
|
|
if (!String.IsNullOrEmpty(settings["Priority"]))
|
|
{
|
|
priority = (MailPriority)Enum.Parse(typeof(MailPriority), settings["Priority"], true);
|
|
}
|
|
|
|
if (String.IsNullOrEmpty(body))
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
if (to == null)
|
|
{
|
|
to = user.Email;
|
|
}
|
|
|
|
subject = RemoteDesktopServicesHelpers.EvaluateMailboxTemplate(subject, org, accountId, itemId);
|
|
body = RemoteDesktopServicesHelpers.EvaluateMailboxTemplate(body, org, accountId, itemId);
|
|
|
|
return MailHelper.SendMessage(from, to, cc, subject, body, priority, isHtml);
|
|
}
|
|
|
|
private static ResultObject InstallSessionHostsCertificateInternal(RdsServer rdsServer)
|
|
{
|
|
var result = TaskManager.StartResultTask<ResultObject>("REMOTE_DESKTOP_SERVICES", "INSTALL_CERTIFICATE");
|
|
|
|
try
|
|
{
|
|
int serviceId = GetRdsServiceId(rdsServer.ItemId);
|
|
var rds = RemoteDesktopServicesHelpers.GetRemoteDesktopServices(serviceId);
|
|
var certificate = GetRdsCertificateByServiceIdInternal(serviceId);
|
|
|
|
var array = Convert.FromBase64String(certificate.Hash);
|
|
char[] chars = new char[array.Length / sizeof(char)];
|
|
System.Buffer.BlockCopy(array, 0, chars, 0, array.Length);
|
|
string password = new string(chars);
|
|
byte[] content = Convert.FromBase64String(certificate.Content);
|
|
|
|
rds.InstallCertificate(content, password, new string[] {rdsServer.FqdName});
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw TaskManager.WriteError(ex);
|
|
}
|
|
finally
|
|
{
|
|
if (!result.IsSuccess)
|
|
{
|
|
TaskManager.CompleteResultTask(result);
|
|
}
|
|
else
|
|
{
|
|
TaskManager.CompleteResultTask();
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
private static RdsCertificate GetRdsCertificateByServiceIdInternal(int serviceId)
|
|
{
|
|
var result = ObjectUtils.FillObjectFromDataReader<RdsCertificate>(DataProvider.GetRdsCertificateByServiceId(serviceId));
|
|
|
|
return result;
|
|
}
|
|
|
|
private static RdsCertificate GetRdsCertificateByItemIdInternal(int? itemId)
|
|
{
|
|
int serviceId = GetRdsServiceId(itemId);
|
|
var result = ObjectUtils.FillObjectFromDataReader<RdsCertificate>(DataProvider.GetRdsCertificateByServiceId(serviceId));
|
|
|
|
return result;
|
|
}
|
|
|
|
private static ResultObject AddRdsCertificateInternal(RdsCertificate certificate)
|
|
{
|
|
var result = TaskManager.StartResultTask<ResultObject>("REMOTE_DESKTOP_SERVICES", "ADD_RDS_SERVER");
|
|
|
|
try
|
|
{
|
|
byte[] hash = new byte[certificate.Hash.Length * sizeof(char)];
|
|
System.Buffer.BlockCopy(certificate.Hash.ToCharArray(), 0, hash, 0, hash.Length);
|
|
certificate.Id = DataProvider.AddRdsCertificate(certificate.ServiceId, certificate.Content, hash, certificate.FileName, certificate.ValidFrom, certificate.ExpiryDate);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
if (ex.InnerException != null)
|
|
{
|
|
result.AddError("Unable to add RDS Certificate", ex.InnerException);
|
|
}
|
|
else
|
|
{
|
|
result.AddError("Unable to add RDS Certificate", ex);
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
if (!result.IsSuccess)
|
|
{
|
|
TaskManager.CompleteResultTask(result);
|
|
}
|
|
else
|
|
{
|
|
TaskManager.CompleteResultTask();
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
private static RdsCollection GetRdsCollectionInternal(int collectionId)
|
|
{
|
|
var collection = ObjectUtils.FillObjectFromDataReader<RdsCollection>(DataProvider.GetRDSCollectionById(collectionId));
|
|
var collectionSettings = ObjectUtils.FillObjectFromDataReader<RdsCollectionSettings>(DataProvider.GetRdsCollectionSettingsByCollectionId(collectionId));
|
|
collection.Settings = collectionSettings;
|
|
|
|
var result = TaskManager.StartResultTask<ResultObject>("REMOTE_DESKTOP_SERVICES", "ADD_RDS_COLLECTION");
|
|
|
|
try
|
|
{
|
|
// load organization
|
|
Organization org = OrganizationController.GetOrganization(collection.ItemId);
|
|
if (org == null)
|
|
{
|
|
result.IsSuccess = false;
|
|
result.AddError("", new NullReferenceException("Organization not found"));
|
|
}
|
|
|
|
var rds = RemoteDesktopServicesHelpers.GetRemoteDesktopServices(RemoteDesktopServicesHelpers.GetRemoteDesktopServiceID(org.PackageId));
|
|
|
|
rds.GetCollection(collection.Name);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
result.AddError("REMOTE_DESKTOP_SERVICES_ADD_RDS_COLLECTION", ex);
|
|
}
|
|
|
|
FillRdsCollection(collection);
|
|
|
|
return collection;
|
|
}
|
|
|
|
private static List<OrganizationUser> GetRdsCollectionLocalAdminsInternal(int collectionId)
|
|
{
|
|
var result = new List<OrganizationUser>();
|
|
var collection = ObjectUtils.FillObjectFromDataReader<RdsCollection>(DataProvider.GetRDSCollectionById(collectionId));
|
|
var servers = ObjectUtils.CreateListFromDataReader<RdsServer>(DataProvider.GetRDSServersByCollectionId(collection.Id)).ToList();
|
|
Organization org = OrganizationController.GetOrganization(collection.ItemId);
|
|
|
|
if (org == null)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
var rds = RemoteDesktopServicesHelpers.GetRemoteDesktopServices(RemoteDesktopServicesHelpers.GetRemoteDesktopServiceID(org.PackageId));
|
|
|
|
var organizationUsers = OrganizationController.GetOrganizationUsersPaged(collection.ItemId, null, null, null, 0, Int32.MaxValue).PageUsers;
|
|
var organizationAdmins = rds.GetRdsCollectionLocalAdmins(org.OrganizationId, collection.Name);
|
|
|
|
return organizationUsers.Where(o => organizationAdmins.Select(a => a.ToLower()).Contains(o.SamAccountName.ToLower())).ToList();
|
|
}
|
|
|
|
private static ResultObject SaveRdsCollectionLocalAdminsInternal(OrganizationUser[] users, int collectionId)
|
|
{
|
|
var result = TaskManager.StartResultTask<ResultObject>("REMOTE_DESKTOP_SERVICES", "SAVE_LOCAL_ADMINS");
|
|
|
|
try
|
|
{
|
|
var collection = ObjectUtils.FillObjectFromDataReader<RdsCollection>(DataProvider.GetRDSCollectionById(collectionId));
|
|
Organization org = OrganizationController.GetOrganization(collection.ItemId);
|
|
|
|
if (org == null)
|
|
{
|
|
result.IsSuccess = false;
|
|
result.AddError("", new NullReferenceException("Organization not found"));
|
|
return result;
|
|
}
|
|
|
|
var rds = RemoteDesktopServicesHelpers.GetRemoteDesktopServices(RemoteDesktopServicesHelpers.GetRemoteDesktopServiceID(org.PackageId));
|
|
var servers = ObjectUtils.CreateListFromDataReader<RdsServer>(DataProvider.GetRDSServersByCollectionId(collection.Id)).ToList();
|
|
|
|
rds.SaveRdsCollectionLocalAdmins(users.Select(u => u.AccountName).ToArray(), servers.Select(s => s.FqdName).ToArray(), org.OrganizationId, collection.Name);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw TaskManager.WriteError(ex);
|
|
}
|
|
finally
|
|
{
|
|
if (!result.IsSuccess)
|
|
{
|
|
TaskManager.CompleteResultTask(result);
|
|
}
|
|
else
|
|
{
|
|
TaskManager.CompleteResultTask();
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
private static RdsCollectionSettings GetRdsCollectionSettingsInternal(int collectionId)
|
|
{
|
|
var collection = ObjectUtils.FillObjectFromDataReader<RdsCollection>(DataProvider.GetRDSCollectionById(collectionId));
|
|
var settings = ObjectUtils.FillObjectFromDataReader<RdsCollectionSettings>(DataProvider.GetRdsCollectionSettingsByCollectionId(collectionId));
|
|
|
|
if (settings != null)
|
|
{
|
|
if (settings.SecurityLayer == null)
|
|
{
|
|
settings.SecurityLayer = SecurityLayerValues.Negotiate.ToString();
|
|
}
|
|
|
|
if (settings.EncryptionLevel == null)
|
|
{
|
|
settings.EncryptionLevel = EncryptionLevel.ClientCompatible.ToString();
|
|
}
|
|
|
|
if (settings.AuthenticateUsingNLA == null)
|
|
{
|
|
settings.AuthenticateUsingNLA = true;
|
|
}
|
|
}
|
|
|
|
return settings;
|
|
}
|
|
|
|
private static List<RdsCollection> GetOrganizationRdsCollectionsInternal(int itemId)
|
|
{
|
|
var collections = ObjectUtils.CreateListFromDataReader<RdsCollection>(DataProvider.GetRDSCollectionsByItemId(itemId));
|
|
|
|
foreach (var rdsCollection in collections)
|
|
{
|
|
FillRdsCollection(rdsCollection);
|
|
}
|
|
|
|
return collections;
|
|
}
|
|
|
|
private static int AddRdsCollectionInternal(int itemId, RdsCollection collection)
|
|
{
|
|
var result = TaskManager.StartResultTask<ResultObject>("REMOTE_DESKTOP_SERVICES", "ADD_RDS_COLLECTION");
|
|
var domainName = IPGlobalProperties.GetIPGlobalProperties().DomainName;
|
|
|
|
try
|
|
{
|
|
Organization org = OrganizationController.GetOrganization(itemId);
|
|
if (org == null)
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
var rds = RemoteDesktopServicesHelpers.GetRemoteDesktopServices(RemoteDesktopServicesHelpers.GetRemoteDesktopServiceID(org.PackageId));
|
|
|
|
foreach(var server in collection.Servers)
|
|
{
|
|
if (!server.FqdName.EndsWith(domainName, StringComparison.CurrentCultureIgnoreCase))
|
|
{
|
|
throw TaskManager.WriteError(new Exception("Fully Qualified Domain Name not valid."));
|
|
}
|
|
|
|
if (!rds.CheckRDSServerAvaliable(server.FqdName))
|
|
{
|
|
throw TaskManager.WriteError(new Exception(string.Format("Unable to connect to {0} server.", server.FqdName)));
|
|
}
|
|
}
|
|
|
|
collection.Name = RemoteDesktopServicesHelpers.GetFormattedCollectionName(collection.DisplayName, org.OrganizationId);
|
|
collection.Settings = RemoteDesktopServicesHelpers.GetDefaultCollectionSettings();
|
|
|
|
rds.CreateCollection(org.OrganizationId, collection);
|
|
var defaultGpoSettings = RemoteDesktopServicesHelpers.GetDefaultGpoSettings();
|
|
rds.ApplyGPO(org.OrganizationId, collection.Name, defaultGpoSettings);
|
|
collection.Id = DataProvider.AddRDSCollection(itemId, collection.Name, collection.Description, collection.DisplayName);
|
|
string xml = RemoteDesktopServicesHelpers.GetSettingsXml(defaultGpoSettings);
|
|
DataProvider.UpdateRdsServerSettings(collection.Id, string.Format("Collection-{0}-Settings", collection.Id), xml);
|
|
|
|
collection.Settings.RdsCollectionId = collection.Id;
|
|
int settingsId = DataProvider.AddRdsCollectionSettings(collection.Settings);
|
|
collection.Settings.Id = settingsId;
|
|
|
|
foreach (var server in collection.Servers)
|
|
{
|
|
DataProvider.AddRDSServerToCollection(server.Id, collection.Id);
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw TaskManager.WriteError(ex);
|
|
}
|
|
finally
|
|
{
|
|
if (!result.IsSuccess)
|
|
{
|
|
TaskManager.CompleteResultTask(result);
|
|
}
|
|
else
|
|
{
|
|
TaskManager.CompleteResultTask();
|
|
}
|
|
}
|
|
|
|
return collection.Id;
|
|
}
|
|
|
|
private static ResultObject EditRdsCollectionInternal(int itemId, RdsCollection collection)
|
|
{
|
|
var result = TaskManager.StartResultTask<ResultObject>("REMOTE_DESKTOP_SERVICES", "EDIT_RDS_COLLECTION");
|
|
|
|
try
|
|
{
|
|
Organization org = OrganizationController.GetOrganization(itemId);
|
|
|
|
if (org == null)
|
|
{
|
|
result.IsSuccess = false;
|
|
result.AddError("", new NullReferenceException("Organization not found"));
|
|
return result;
|
|
}
|
|
|
|
var rds = RemoteDesktopServicesHelpers.GetRemoteDesktopServices(RemoteDesktopServicesHelpers.GetRemoteDesktopServiceID(org.PackageId));
|
|
var existingServers =
|
|
ObjectUtils.CreateListFromDataReader<RdsServer>(DataProvider.GetRDSServersByCollectionId(collection.Id)).ToList();
|
|
var removedServers = existingServers.Where(x => !collection.Servers.Select(y => y.Id).Contains(x.Id));
|
|
var newServers = collection.Servers.Where(x => !existingServers.Select(y => y.Id).Contains(x.Id));
|
|
|
|
foreach(var server in removedServers)
|
|
{
|
|
DataProvider.RemoveRDSServerFromCollection(server.Id);
|
|
}
|
|
|
|
rds.AddSessionHostServersToCollection(org.OrganizationId, collection.Name, newServers.ToArray());
|
|
rds.MoveSessionHostsToCollectionOU(collection.Servers.ToArray(), collection.Name, org.OrganizationId);
|
|
|
|
foreach (var server in newServers)
|
|
{
|
|
DataProvider.AddRDSServerToCollection(server.Id, collection.Id);
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
result.AddError("REMOTE_DESKTOP_SERVICES_ADD_RDS_COLLECTION", ex);
|
|
}
|
|
finally
|
|
{
|
|
if (!result.IsSuccess)
|
|
{
|
|
TaskManager.CompleteResultTask(result);
|
|
}
|
|
else
|
|
{
|
|
TaskManager.CompleteResultTask();
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
private static ResultObject EditRdsCollectionSettingsInternal(int itemId, RdsCollection collection)
|
|
{
|
|
var result = TaskManager.StartResultTask<ResultObject>("REMOTE_DESKTOP_SERVICES", "EDIT_RDS_COLLECTION_SETTINGS");
|
|
|
|
try
|
|
{
|
|
Organization org = OrganizationController.GetOrganization(itemId);
|
|
|
|
if (org == null)
|
|
{
|
|
result.IsSuccess = false;
|
|
result.AddError("", new NullReferenceException("Organization not found"));
|
|
return result;
|
|
}
|
|
|
|
var rds = RemoteDesktopServicesHelpers.GetRemoteDesktopServices(RemoteDesktopServicesHelpers.GetRemoteDesktopServiceID(org.PackageId));
|
|
rds.EditRdsCollectionSettings(collection);
|
|
var collectionSettings = ObjectUtils.FillObjectFromDataReader<RdsCollectionSettings>(DataProvider.GetRdsCollectionSettingsByCollectionId(collection.Id));
|
|
|
|
if (collectionSettings == null)
|
|
{
|
|
DataProvider.AddRdsCollectionSettings(collection.Settings);
|
|
}
|
|
else
|
|
{
|
|
DataProvider.UpdateRDSCollectionSettings(collection.Settings);
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
result.AddError("REMOTE_DESKTOP_SERVICES_ADD_RDS_COLLECTION", ex);
|
|
throw TaskManager.WriteError(ex);
|
|
}
|
|
finally
|
|
{
|
|
if (!result.IsSuccess)
|
|
{
|
|
TaskManager.CompleteResultTask(result);
|
|
}
|
|
else
|
|
{
|
|
TaskManager.CompleteResultTask();
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
private static RdsCollectionPaged GetRdsCollectionsPagedInternal(int itemId, string filterColumn, string filterValue, string sortColumn, int startRow, int maximumRows)
|
|
{
|
|
DataSet ds = DataProvider.GetRDSCollectionsPaged(itemId, filterColumn, filterValue, sortColumn, startRow, maximumRows);
|
|
|
|
var result = new RdsCollectionPaged
|
|
{
|
|
RecordsCount = (int)ds.Tables[0].Rows[0][0]
|
|
};
|
|
|
|
List<RdsCollection> tmpCollections = new List<RdsCollection>();
|
|
|
|
ObjectUtils.FillCollectionFromDataView(tmpCollections, ds.Tables[1].DefaultView);
|
|
|
|
foreach (var collection in tmpCollections)
|
|
{
|
|
collection.Servers = GetCollectionRdsServersInternal(collection.Id);
|
|
}
|
|
|
|
result.Collections = tmpCollections.ToArray();
|
|
|
|
return result;
|
|
}
|
|
|
|
private static ResultObject RemoveRdsCollectionInternal(int itemId, RdsCollection collection)
|
|
{
|
|
var result = TaskManager.StartResultTask<ResultObject>("REMOTE_DESKTOP_SERVICES", "REMOVE_RDS_COLLECTION");
|
|
|
|
try
|
|
{
|
|
// load organization
|
|
Organization org = OrganizationController.GetOrganization(itemId);
|
|
if (org == null)
|
|
{
|
|
result.IsSuccess = false;
|
|
result.AddError("", new NullReferenceException("Organization not found"));
|
|
return result;
|
|
}
|
|
|
|
var rds = RemoteDesktopServicesHelpers.GetRemoteDesktopServices(RemoteDesktopServicesHelpers.GetRemoteDesktopServiceID(org.PackageId));
|
|
var servers = ObjectUtils.CreateListFromDataReader<RdsServer>(DataProvider.GetRDSServersByCollectionId(collection.Id)).ToArray();
|
|
rds.RemoveCollection(org.OrganizationId, collection.Name, servers);
|
|
|
|
DataProvider.DeleteRDSServerSettings(collection.Id);
|
|
DataProvider.DeleteRDSCollection(collection.Id);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
result.AddError("REMOTE_DESKTOP_SERVICES_REMOVE_RDS_COLLECTION", ex);
|
|
}
|
|
finally
|
|
{
|
|
if (!result.IsSuccess)
|
|
{
|
|
TaskManager.CompleteResultTask(result);
|
|
}
|
|
else
|
|
{
|
|
TaskManager.CompleteResultTask();
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
private static List<StartMenuApp> GetAvailableRemoteApplicationsInternal(int itemId, string collectionName)
|
|
{
|
|
var result = new List<StartMenuApp>();
|
|
|
|
var taskResult = TaskManager.StartResultTask<ResultObject>("REMOTE_DESKTOP_SERVICES",
|
|
"GET_AVAILABLE_REMOTE_APPLICATIOBNS");
|
|
|
|
try
|
|
{
|
|
// load organization
|
|
Organization org = OrganizationController.GetOrganization(itemId);
|
|
|
|
if (org == null)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
var rds = RemoteDesktopServicesHelpers.GetRemoteDesktopServices(RemoteDesktopServicesHelpers.GetRemoteDesktopServiceID(org.PackageId));
|
|
|
|
result.AddRange(rds.GetAvailableRemoteApplications(collectionName));
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
taskResult.AddError("REMOTE_DESKTOP_SERVICES_ADD_RDS_COLLECTION", ex);
|
|
}
|
|
finally
|
|
{
|
|
if (!taskResult.IsSuccess)
|
|
{
|
|
TaskManager.CompleteResultTask(taskResult);
|
|
}
|
|
else
|
|
{
|
|
TaskManager.CompleteResultTask();
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
private static RdsServersPaged GetRdsServersPagedInternal(string filterColumn, string filterValue, string sortColumn, int startRow, int maximumRows)
|
|
{
|
|
DataSet ds = DataProvider.GetRDSServersPaged(null, null, filterColumn, filterValue, sortColumn, startRow, maximumRows, true, true);
|
|
|
|
RdsServersPaged result = new RdsServersPaged();
|
|
result.RecordsCount = (int)ds.Tables[0].Rows[0][0];
|
|
|
|
List<RdsServer> tmpServers = new List<RdsServer>();
|
|
|
|
ObjectUtils.FillCollectionFromDataView(tmpServers, ds.Tables[1].DefaultView);
|
|
|
|
foreach (var tmpServer in tmpServers)
|
|
{
|
|
RemoteDesktopServicesHelpers.FillRdsServerData(tmpServer);
|
|
}
|
|
|
|
result.Servers = tmpServers.ToArray();
|
|
|
|
return result;
|
|
}
|
|
|
|
private static List<RdsUserSession> GetRdsUserSessionsInternal(int collectionId)
|
|
{
|
|
var result = new List<RdsUserSession>();
|
|
var collection = ObjectUtils.FillObjectFromDataReader<RdsCollection>(DataProvider.GetRDSCollectionById(collectionId));
|
|
var organization = OrganizationController.GetOrganization(collection.ItemId);
|
|
|
|
if (organization == null)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
var rds = RemoteDesktopServicesHelpers.GetRemoteDesktopServices(RemoteDesktopServicesHelpers.GetRemoteDesktopServiceID(organization.PackageId));
|
|
var userSessions = rds.GetRdsUserSessions(collection.Name).ToList();
|
|
var organizationUsers = OrganizationController.GetOrganizationUsersPaged(collection.ItemId, null, null, null, 0, Int32.MaxValue).PageUsers;
|
|
|
|
foreach(var userSession in userSessions)
|
|
{
|
|
var organizationUser = organizationUsers.FirstOrDefault(o => o.SamAccountName.Equals(userSession.SamAccountName, StringComparison.CurrentCultureIgnoreCase));
|
|
|
|
if (organizationUser != null)
|
|
{
|
|
userSession.IsVip = organizationUser.IsVIP;
|
|
result.Add(userSession);
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
private static RdsServersPaged GetFreeRdsServersPagedInternal(int itemId, string filterColumn, string filterValue, string sortColumn, int startRow, int maximumRows)
|
|
{
|
|
RdsServersPaged result = new RdsServersPaged();
|
|
Organization org = OrganizationController.GetOrganization(itemId);
|
|
|
|
if (org == null)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
var rds = RemoteDesktopServicesHelpers.GetRemoteDesktopServices(RemoteDesktopServicesHelpers.GetRemoteDesktopServiceID(org.PackageId));
|
|
var existingServers = rds.GetServersExistingInCollections();
|
|
|
|
DataSet ds = DataProvider.GetRDSServersPaged(null, null, filterColumn, filterValue, sortColumn, startRow, maximumRows);
|
|
result.RecordsCount = (int)ds.Tables[0].Rows[0][0];
|
|
|
|
List<RdsServer> tmpServers = new List<RdsServer>();
|
|
|
|
ObjectUtils.FillCollectionFromDataView(tmpServers, ds.Tables[1].DefaultView);
|
|
tmpServers = tmpServers.Where(x => !existingServers.Select(y => y.ToUpper()).Contains(x.FqdName.ToUpper())).ToList();
|
|
result.Servers = tmpServers.ToArray();
|
|
|
|
return result;
|
|
}
|
|
|
|
private static List<string> GetRdsCollectionSessionHostsInternal(int collectionId)
|
|
{
|
|
var result = new List<string>();
|
|
var collection = ObjectUtils.FillObjectFromDataReader<RdsCollection>(DataProvider.GetRDSCollectionById(collectionId));
|
|
Organization org = OrganizationController.GetOrganization(collection.ItemId);
|
|
|
|
if (org == null)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
var rds = RemoteDesktopServicesHelpers.GetRemoteDesktopServices(RemoteDesktopServicesHelpers.GetRemoteDesktopServiceID(org.PackageId));
|
|
result = rds.GetRdsCollectionSessionHosts(collection.Name).ToList();
|
|
|
|
return result;
|
|
}
|
|
|
|
private static RdsServersPaged GetOrganizationRdsServersPagedInternal(int itemId, int? collectionId, string filterColumn, string filterValue, string sortColumn, int startRow, int maximumRows)
|
|
{
|
|
DataSet ds = DataProvider.GetRDSServersPaged(itemId, collectionId, filterColumn, filterValue, sortColumn, startRow, maximumRows, ignoreRdsCollectionId: !collectionId.HasValue);
|
|
|
|
RdsServersPaged result = new RdsServersPaged();
|
|
result.RecordsCount = (int)ds.Tables[0].Rows[0][0];
|
|
|
|
List<RdsServer> tmpServers = new List<RdsServer>();
|
|
|
|
ObjectUtils.FillCollectionFromDataView(tmpServers, ds.Tables[1].DefaultView);
|
|
|
|
result.Servers = tmpServers.ToArray();
|
|
|
|
return result;
|
|
}
|
|
|
|
private static RdsServersPaged GetOrganizationFreeRdsServersPagedInternal(int itemId, string filterColumn, string filterValue, string sortColumn, int startRow, int maximumRows)
|
|
{
|
|
DataSet ds = DataProvider.GetRDSServersPaged(itemId, null, filterColumn, filterValue, sortColumn, startRow, maximumRows);
|
|
|
|
RdsServersPaged result = new RdsServersPaged();
|
|
result.RecordsCount = (int)ds.Tables[0].Rows[0][0];
|
|
|
|
List<RdsServer> tmpServers = new List<RdsServer>();
|
|
|
|
ObjectUtils.FillCollectionFromDataView(tmpServers, ds.Tables[1].DefaultView);
|
|
|
|
result.Servers = tmpServers.ToArray();
|
|
|
|
return result;
|
|
}
|
|
|
|
private static RdsServer GetRdsServerInternal(int rdsSeverId)
|
|
{
|
|
return ObjectUtils.FillObjectFromDataReader<RdsServer>(DataProvider.GetRDSServerById(rdsSeverId));
|
|
}
|
|
|
|
private static ResultObject SetRDServerNewConnectionAllowedInternal(int itemId, bool newConnectionAllowed, int rdsSeverId)
|
|
{
|
|
ResultObject result = TaskManager.StartResultTask<ResultObject>("REMOTE_DESKTOP_SERVICES", "SET_RDS_SERVER_NEW_CONNECTIONS_ALLOWED"); ;
|
|
try
|
|
{
|
|
// load organization
|
|
Organization org = OrganizationController.GetOrganization(itemId);
|
|
if (org == null)
|
|
{
|
|
result.IsSuccess = false;
|
|
result.AddError("", new NullReferenceException("Organization not found"));
|
|
return result;
|
|
}
|
|
|
|
var rds = RemoteDesktopServicesHelpers.GetRemoteDesktopServices(RemoteDesktopServicesHelpers.GetRemoteDesktopServiceID(org.PackageId));
|
|
|
|
var rdsServer = GetRdsServer(rdsSeverId);
|
|
|
|
if (rdsServer == null)
|
|
{
|
|
result.IsSuccess = false;
|
|
result.AddError("", new NullReferenceException("RDS Server not found"));
|
|
return result;
|
|
}
|
|
|
|
rds.SetRDServerNewConnectionAllowed(newConnectionAllowed, rdsServer);
|
|
rdsServer.ConnectionEnabled = newConnectionAllowed;
|
|
DataProvider.UpdateRDSServer(rdsServer);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
result.AddError("REMOTE_DESKTOP_SERVICES_SET_RDS_SERVER_NEW_CONNECTIONS_ALLOWED", ex);
|
|
}
|
|
finally
|
|
{
|
|
if (!result.IsSuccess)
|
|
{
|
|
TaskManager.CompleteResultTask(result);
|
|
}
|
|
else
|
|
{
|
|
TaskManager.CompleteResultTask();
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
private static ResultObject AddRdsServerInternal(RdsServer rdsServer)
|
|
{
|
|
var result = TaskManager.StartResultTask<ResultObject>("REMOTE_DESKTOP_SERVICES", "ADD_RDS_SERVER");
|
|
|
|
try
|
|
{
|
|
int serviceId = GetRdsMainServiceId();
|
|
var rds = RemoteDesktopServicesHelpers.GetRemoteDesktopServices(serviceId);
|
|
|
|
if (rds.CheckRDSServerAvaliable(rdsServer.FqdName))
|
|
{
|
|
var domainName = IPGlobalProperties.GetIPGlobalProperties().DomainName;
|
|
|
|
if (rdsServer.FqdName.EndsWith(domainName, StringComparison.CurrentCultureIgnoreCase))
|
|
{
|
|
rds.AddSessionHostFeatureToServer(rdsServer.FqdName);
|
|
rds.MoveSessionHostToRdsOU(rdsServer.Name);
|
|
rdsServer.Id = DataProvider.AddRDSServer(rdsServer.Name, rdsServer.FqdName, rdsServer.Description);
|
|
}
|
|
else
|
|
{
|
|
throw TaskManager.WriteError(new Exception("Fully Qualified Domain Name not valid."));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
throw TaskManager.WriteError(new Exception(string.Format("Unable to connect to {0} server. Please double check Server Full Name setting and retry.", rdsServer.FqdName)));
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
if (!result.IsSuccess)
|
|
{
|
|
TaskManager.CompleteResultTask(result);
|
|
}
|
|
else
|
|
{
|
|
TaskManager.CompleteResultTask();
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
private static ResultObject AddRdsServerToCollectionInternal(int itemId, RdsServer rdsServer, RdsCollection rdsCollection)
|
|
{
|
|
var result = TaskManager.StartResultTask<ResultObject>("REMOTE_DESKTOP_SERVICES", "ADD_RDS_SERVER_TO_COLLECTION");
|
|
|
|
try
|
|
{
|
|
// load organization
|
|
Organization org = OrganizationController.GetOrganization(itemId);
|
|
if (org == null)
|
|
{
|
|
result.IsSuccess = false;
|
|
result.AddError("", new NullReferenceException("Organization not found"));
|
|
return result;
|
|
}
|
|
|
|
var rds = RemoteDesktopServicesHelpers.GetRemoteDesktopServices(RemoteDesktopServicesHelpers.GetRemoteDesktopServiceID(org.PackageId));
|
|
|
|
if (!rds.CheckSessionHostFeatureInstallation(rdsServer.FqdName))
|
|
{
|
|
rds.AddSessionHostFeatureToServer(rdsServer.FqdName);
|
|
}
|
|
|
|
rds.AddSessionHostServerToCollection(org.OrganizationId, rdsCollection.Name, rdsServer);
|
|
|
|
DataProvider.AddRDSServerToCollection(rdsServer.Id, rdsCollection.Id);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
result.AddError("REMOTE_DESKTOP_SERVICES_ADD_RDS_SERVER_TO_COLLECTION", ex);
|
|
}
|
|
finally
|
|
{
|
|
if (!result.IsSuccess)
|
|
{
|
|
TaskManager.CompleteResultTask(result);
|
|
}
|
|
else
|
|
{
|
|
TaskManager.CompleteResultTask();
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
private static ResultObject RemoveRdsServerFromCollectionInternal(int itemId, RdsServer rdsServer, RdsCollection rdsCollection)
|
|
{
|
|
var result = TaskManager.StartResultTask<ResultObject>("REMOTE_DESKTOP_SERVICES", "REMOVE_RDS_SERVER_FROM_COLLECTION");
|
|
|
|
try
|
|
{
|
|
// load organization
|
|
Organization org = OrganizationController.GetOrganization(itemId);
|
|
if (org == null)
|
|
{
|
|
result.IsSuccess = false;
|
|
result.AddError("", new NullReferenceException("Organization not found"));
|
|
return result;
|
|
}
|
|
|
|
var rds = RemoteDesktopServicesHelpers.GetRemoteDesktopServices(RemoteDesktopServicesHelpers.GetRemoteDesktopServiceID(org.PackageId));
|
|
|
|
rds.RemoveSessionHostServerFromCollection(org.OrganizationId, rdsCollection.Name, rdsServer);
|
|
|
|
DataProvider.RemoveRDSServerFromCollection(rdsServer.Id);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
result.AddError("REMOTE_DESKTOP_SERVICES_REMOVE_RDS_SERVER_FROM_COLLECTION", ex);
|
|
}
|
|
finally
|
|
{
|
|
if (!result.IsSuccess)
|
|
{
|
|
TaskManager.CompleteResultTask(result);
|
|
}
|
|
else
|
|
{
|
|
TaskManager.CompleteResultTask();
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
private static ResultObject UpdateRdsServerInternal(RdsServer rdsServer)
|
|
{
|
|
var result = TaskManager.StartResultTask<ResultObject>("REMOTE_DESKTOP_SERVICES", "UPDATE_RDS_SERVER");
|
|
|
|
try
|
|
{
|
|
DataProvider.UpdateRDSServer(rdsServer);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
result.AddError("REMOTE_DESKTOP_SERVICES_UPDATE_RDS_SERVER", ex);
|
|
}
|
|
finally
|
|
{
|
|
if (!result.IsSuccess)
|
|
{
|
|
TaskManager.CompleteResultTask(result);
|
|
}
|
|
else
|
|
{
|
|
TaskManager.CompleteResultTask();
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
private static ResultObject AddRdsServerToOrganizationInternal(int itemId, int serverId)
|
|
{
|
|
var result = TaskManager.StartResultTask<ResultObject>("REMOTE_DESKTOP_SERVICES", "ADD_RDS_SERVER_TO_ORGANIZATION");
|
|
|
|
try
|
|
{
|
|
// load organization
|
|
Organization org = OrganizationController.GetOrganization(itemId);
|
|
if (org == null)
|
|
{
|
|
result.IsSuccess = false;
|
|
result.AddError("", new NullReferenceException("Organization not found"));
|
|
return result;
|
|
}
|
|
|
|
var rds = RemoteDesktopServicesHelpers.GetRemoteDesktopServices(RemoteDesktopServicesHelpers.GetRemoteDesktopServiceID(org.PackageId));
|
|
|
|
RdsServer rdsServer = GetRdsServer(serverId);
|
|
rds.MoveRdsServerToTenantOU(rdsServer.FqdName, org.OrganizationId);
|
|
DataProvider.AddRDSServerToOrganization(itemId, serverId);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw TaskManager.WriteError(ex);
|
|
}
|
|
finally
|
|
{
|
|
if (!result.IsSuccess)
|
|
{
|
|
TaskManager.CompleteResultTask(result);
|
|
}
|
|
else
|
|
{
|
|
TaskManager.CompleteResultTask();
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
private static ResultObject RemoveRdsServerFromOrganizationInternal(int itemId, int rdsServerId)
|
|
{
|
|
var result = TaskManager.StartResultTask<ResultObject>("REMOTE_DESKTOP_SERVICES", "REMOVE_RDS_SERVER_FROM_ORGANIZATION");
|
|
|
|
try
|
|
{
|
|
Organization org = OrganizationController.GetOrganization(itemId);
|
|
|
|
if (org == null)
|
|
{
|
|
result.IsSuccess = false;
|
|
result.AddError("", new NullReferenceException("Organization not found"));
|
|
return result;
|
|
}
|
|
|
|
var rdsServer = ObjectUtils.FillObjectFromDataReader<RdsServer>(DataProvider.GetRDSServerById(rdsServerId));
|
|
var rds = RemoteDesktopServicesHelpers.GetRemoteDesktopServices(RemoteDesktopServicesHelpers.GetRemoteDesktopServiceID(org.PackageId));
|
|
rds.RemoveRdsServerFromTenantOU(rdsServer.FqdName, org.OrganizationId);
|
|
DataProvider.RemoveRDSServerFromOrganization(rdsServerId);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw TaskManager.WriteError(ex);
|
|
}
|
|
finally
|
|
{
|
|
if (!result.IsSuccess)
|
|
{
|
|
TaskManager.CompleteResultTask(result);
|
|
}
|
|
else
|
|
{
|
|
TaskManager.CompleteResultTask();
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
private static ResultObject RemoveRdsServerInternal(int rdsServerId)
|
|
{
|
|
var result = TaskManager.StartResultTask<ResultObject>("REMOTE_DESKTOP_SERVICES", "REMOVE_RDS_SERVER");
|
|
|
|
try
|
|
{
|
|
DataProvider.DeleteRDSServer(rdsServerId);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
result.AddError("REMOTE_DESKTOP_SERVICES_REMOVE_RDS_SERVER", ex);
|
|
}
|
|
finally
|
|
{
|
|
if (!result.IsSuccess)
|
|
{
|
|
TaskManager.CompleteResultTask(result);
|
|
}
|
|
else
|
|
{
|
|
TaskManager.CompleteResultTask();
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
private static List<OrganizationUser> GetRdsCollectionUsersInternal(int collectionId)
|
|
{
|
|
return ObjectUtils.CreateListFromDataReader<OrganizationUser>(DataProvider.GetRDSCollectionUsersByRDSCollectionId(collectionId));
|
|
}
|
|
|
|
private static ResultObject SetUsersToRdsCollectionInternal(int itemId, int collectionId, List<OrganizationUser> users)
|
|
{
|
|
var result = TaskManager.StartResultTask<ResultObject>("REMOTE_DESKTOP_SERVICES", "ADD_USER_TO_RDS_COLLECTION");
|
|
|
|
try
|
|
{
|
|
// load organization
|
|
Organization org = OrganizationController.GetOrganization(itemId);
|
|
if (org == null)
|
|
{
|
|
result.IsSuccess = false;
|
|
result.AddError("", new NullReferenceException("Organization not found"));
|
|
return result;
|
|
}
|
|
|
|
var rds = RemoteDesktopServicesHelpers.GetRemoteDesktopServices(RemoteDesktopServicesHelpers.GetRemoteDesktopServiceID(org.PackageId));
|
|
|
|
var collection = GetRdsCollection(collectionId);
|
|
|
|
if (collection == null)
|
|
{
|
|
result.IsSuccess = false;
|
|
result.AddError("", new NullReferenceException("Collection not found"));
|
|
return result;
|
|
}
|
|
|
|
foreach(var user in users)
|
|
{
|
|
var account = OrganizationController.GetAccountByAccountName(itemId, user.AccountName);
|
|
|
|
user.AccountId = account.AccountId;
|
|
}
|
|
|
|
var usersInDb = GetRdsCollectionUsers(collectionId);
|
|
|
|
var accountNames = users.Select(x => x.AccountName).ToList();
|
|
|
|
//Set on server
|
|
rds.SetUsersInCollection(org.OrganizationId, collection.Name, users.Select(x => x.AccountName).ToArray());
|
|
|
|
//Remove from db
|
|
foreach (var userInDb in usersInDb)
|
|
{
|
|
if (!accountNames.Contains(userInDb.AccountName))
|
|
{
|
|
DataProvider.RemoveRDSUserFromRDSCollection(collectionId, userInDb.AccountId);
|
|
}
|
|
}
|
|
|
|
//Add to db
|
|
foreach (var user in users)
|
|
{
|
|
if (!usersInDb.Select(x => x.AccountName).Contains(user.AccountName))
|
|
{
|
|
DataProvider.AddRDSUserToRDSCollection(collectionId, user.AccountId);
|
|
}
|
|
}
|
|
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
result.AddError("REMOTE_DESKTOP_SERVICES_ADD_USER_TO_RDS_COLLECTION", ex);
|
|
}
|
|
finally
|
|
{
|
|
if (!result.IsSuccess)
|
|
{
|
|
TaskManager.CompleteResultTask(result);
|
|
}
|
|
else
|
|
{
|
|
TaskManager.CompleteResultTask();
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
private static List<string> GetApplicationUsersInternal(int itemId, int collectionId, RemoteApplication remoteApp)
|
|
{
|
|
var result = new List<string>();
|
|
Organization org = OrganizationController.GetOrganization(itemId);
|
|
|
|
if (org == null)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
var rds = RemoteDesktopServicesHelpers.GetRemoteDesktopServices(RemoteDesktopServicesHelpers.GetRemoteDesktopServiceID(org.PackageId));
|
|
var collection = ObjectUtils.FillObjectFromDataReader<RdsCollection>(DataProvider.GetRDSCollectionById(collectionId));
|
|
var users = rds.GetApplicationUsers(collection.Name, remoteApp.Alias);
|
|
result.AddRange(users);
|
|
|
|
return result;
|
|
}
|
|
|
|
private static ResultObject SetApplicationUsersInternal(int itemId, int collectionId, RemoteApplication remoteApp, List<string> users)
|
|
{
|
|
var result = TaskManager.StartResultTask<ResultObject>("REMOTE_DESKTOP_SERVICES", "SET_REMOTE_APP_USERS");
|
|
|
|
try
|
|
{
|
|
Organization org = OrganizationController.GetOrganization(itemId);
|
|
if (org == null)
|
|
{
|
|
result.IsSuccess = false;
|
|
result.AddError("", new NullReferenceException("Organization not found"));
|
|
return result;
|
|
}
|
|
|
|
var collection = ObjectUtils.FillObjectFromDataReader<RdsCollection>(DataProvider.GetRDSCollectionById(collectionId));
|
|
var rds = RemoteDesktopServicesHelpers.GetRemoteDesktopServices(RemoteDesktopServicesHelpers.GetRemoteDesktopServiceID(org.PackageId));
|
|
rds.SetApplicationUsers(collection.Name, remoteApp, users.ToArray());
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
result.AddError("REMOTE_DESKTOP_SERVICES_SET_REMOTE_APP_USERS", ex);
|
|
}
|
|
finally
|
|
{
|
|
if (!result.IsSuccess)
|
|
{
|
|
TaskManager.CompleteResultTask(result);
|
|
}
|
|
else
|
|
{
|
|
TaskManager.CompleteResultTask();
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
private static ResultObject LogOffRdsUserInternal(int itemId, string unifiedSessionId, string hostServer)
|
|
{
|
|
var result = TaskManager.StartResultTask<ResultObject>("REMOTE_DESKTOP_SERVICES", "LOG_OFF_RDS_USER");
|
|
|
|
try
|
|
{
|
|
Organization org = OrganizationController.GetOrganization(itemId);
|
|
|
|
if (org == null)
|
|
{
|
|
result.IsSuccess = false;
|
|
result.AddError("LOG_OFF_RDS_USER", new NullReferenceException("Organization not found"));
|
|
|
|
return result;
|
|
}
|
|
|
|
var rds = RemoteDesktopServicesHelpers.GetRemoteDesktopServices(RemoteDesktopServicesHelpers.GetRemoteDesktopServiceID(org.PackageId));
|
|
rds.LogOffRdsUser(unifiedSessionId, hostServer);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
result.AddError("REMOTE_DESKTOP_SERVICES_LOG_OFF_RDS_USER", ex);
|
|
}
|
|
finally
|
|
{
|
|
if (!result.IsSuccess)
|
|
{
|
|
TaskManager.CompleteResultTask(result);
|
|
}
|
|
else
|
|
{
|
|
TaskManager.CompleteResultTask();
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
private static ResultObject AddRemoteApplicationToCollectionInternal(int itemId, RdsCollection collection, RemoteApplication remoteApp)
|
|
{
|
|
var result = TaskManager.StartResultTask<ResultObject>("REMOTE_DESKTOP_SERVICES", "ADD_REMOTE_APP_TO_COLLECTION");
|
|
|
|
try
|
|
{
|
|
// load organization
|
|
Organization org = OrganizationController.GetOrganization(itemId);
|
|
if (org == null)
|
|
{
|
|
result.IsSuccess = false;
|
|
result.AddError("", new NullReferenceException("Organization not found"));
|
|
return result;
|
|
}
|
|
|
|
var rds = RemoteDesktopServicesHelpers.GetRemoteDesktopServices(RemoteDesktopServicesHelpers.GetRemoteDesktopServiceID(org.PackageId));
|
|
|
|
if (!string.IsNullOrEmpty(remoteApp.Alias))
|
|
{
|
|
remoteApp.Alias = remoteApp.DisplayName;
|
|
}
|
|
|
|
remoteApp.ShowInWebAccess = true;
|
|
rds.AddRemoteApplication(collection.Name, remoteApp);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
result.AddError("REMOTE_DESKTOP_SERVICES_ADD_REMOTE_APP_TO_COLLECTION", ex);
|
|
}
|
|
finally
|
|
{
|
|
if (!result.IsSuccess)
|
|
{
|
|
TaskManager.CompleteResultTask(result);
|
|
}
|
|
else
|
|
{
|
|
TaskManager.CompleteResultTask();
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
private static ResultObject ShutDownRdsServerInternal(int? itemId, string fqdnName)
|
|
{
|
|
var result = TaskManager.StartResultTask<ResultObject>("REMOTE_DESKTOP_SERVICES", "SHUTDOWN_RDS_SERVER");
|
|
|
|
try
|
|
{
|
|
int serviceId = GetRdsServiceId(itemId);
|
|
|
|
if (serviceId != -1)
|
|
{
|
|
var rds = RemoteDesktopServicesHelpers.GetRemoteDesktopServices(serviceId);
|
|
rds.ShutDownRdsServer(fqdnName);
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
result.AddError("REMOTE_DESKTOP_SERVICES_SHUTDOWN_RDS_SERVER", ex);
|
|
}
|
|
finally
|
|
{
|
|
if (!result.IsSuccess)
|
|
{
|
|
TaskManager.CompleteResultTask(result);
|
|
}
|
|
else
|
|
{
|
|
TaskManager.CompleteResultTask();
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
private static ResultObject RestartRdsServerInternal(int? itemId, string fqdnName)
|
|
{
|
|
var result = TaskManager.StartResultTask<ResultObject>("REMOTE_DESKTOP_SERVICES", "RESTART_RDS_SERVER");
|
|
|
|
try
|
|
{
|
|
int serviceId = GetRdsServiceId(itemId);
|
|
|
|
if (serviceId != -1)
|
|
{
|
|
var rds = RemoteDesktopServicesHelpers.GetRemoteDesktopServices(serviceId);
|
|
rds.RestartRdsServer(fqdnName);
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
result.AddError("REMOTE_DESKTOP_SERVICES_RESTART_RDS_SERVER", ex);
|
|
}
|
|
finally
|
|
{
|
|
if (!result.IsSuccess)
|
|
{
|
|
TaskManager.CompleteResultTask(result);
|
|
}
|
|
else
|
|
{
|
|
TaskManager.CompleteResultTask();
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
private static List<RemoteApplication> GetCollectionRemoteApplicationsInternal(int itemId, string collectionName)
|
|
{
|
|
var result = new List<RemoteApplication>();
|
|
|
|
// load organization
|
|
Organization org = OrganizationController.GetOrganization(itemId);
|
|
|
|
if (org == null)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
var rds = RemoteDesktopServicesHelpers.GetRemoteDesktopServices(RemoteDesktopServicesHelpers.GetRemoteDesktopServiceID(org.PackageId));
|
|
|
|
result.AddRange(rds.GetCollectionRemoteApplications(collectionName));
|
|
|
|
return result;
|
|
}
|
|
|
|
private static ResultObject RemoveRemoteApplicationFromCollectionInternal(int itemId, RdsCollection collection, RemoteApplication application)
|
|
{
|
|
var result = TaskManager.StartResultTask<ResultObject>("REMOTE_DESKTOP_SERVICES", "REMOVE_REMOTE_APP_FROM_COLLECTION");
|
|
|
|
try
|
|
{
|
|
// load organization
|
|
Organization org = OrganizationController.GetOrganization(itemId);
|
|
if (org == null)
|
|
{
|
|
result.IsSuccess = false;
|
|
result.AddError("", new NullReferenceException("Organization not found"));
|
|
return result;
|
|
}
|
|
|
|
var rds = RemoteDesktopServicesHelpers.GetRemoteDesktopServices(RemoteDesktopServicesHelpers.GetRemoteDesktopServiceID(org.PackageId));
|
|
|
|
rds.RemoveRemoteApplication(collection.Name, application);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
result.AddError("REMOTE_DESKTOP_SERVICES_REMOVE_REMOTE_APP_FROM_COLLECTION", ex);
|
|
}
|
|
finally
|
|
{
|
|
if (!result.IsSuccess)
|
|
{
|
|
TaskManager.CompleteResultTask(result);
|
|
}
|
|
else
|
|
{
|
|
TaskManager.CompleteResultTask();
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
private static ResultObject SetRemoteApplicationsToRdsCollectionInternal(int itemId, int collectionId, List<RemoteApplication> remoteApps)
|
|
{
|
|
ResultObject result = TaskManager.StartResultTask<ResultObject>("REMOTE_DESKTOP_SERVICES", "SET_APPS_TO_RDS_COLLECTION"); ;
|
|
try
|
|
{
|
|
// load organization
|
|
Organization org = OrganizationController.GetOrganization(itemId);
|
|
if (org == null)
|
|
{
|
|
result.IsSuccess = false;
|
|
result.AddError("", new NullReferenceException("Organization not found"));
|
|
return result;
|
|
}
|
|
|
|
var rds = RemoteDesktopServicesHelpers.GetRemoteDesktopServices(RemoteDesktopServicesHelpers.GetRemoteDesktopServiceID(org.PackageId));
|
|
|
|
var collection = GetRdsCollection(collectionId);
|
|
|
|
if (collection == null)
|
|
{
|
|
result.IsSuccess = false;
|
|
result.AddError("", new NullReferenceException("Collection not found"));
|
|
return result;
|
|
}
|
|
|
|
List<RemoteApplication> existingCollectionApps = GetCollectionRemoteApplications(itemId, collection.Name);
|
|
List<RemoteApplication> remoteAppsToAdd = remoteApps.Where(x => !existingCollectionApps.Select(p => p.Alias).Contains(x.Alias)).ToList();
|
|
foreach (var app in remoteAppsToAdd)
|
|
{
|
|
app.ShowInWebAccess = true;
|
|
AddRemoteApplicationToCollection(itemId, collection, app);
|
|
}
|
|
|
|
List<RemoteApplication> remoteAppsToRemove = existingCollectionApps.Where(x => !remoteApps.Select(p => p.Alias).Contains(x.Alias)).ToList();
|
|
foreach (var app in remoteAppsToRemove)
|
|
{
|
|
RemoveRemoteApplicationFromCollection(itemId, collection, app);
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
result.AddError("REMOTE_DESKTOP_SERVICES_SET_APPS_TO_RDS_COLLECTION", ex);
|
|
}
|
|
finally
|
|
{
|
|
if (!result.IsSuccess)
|
|
{
|
|
TaskManager.CompleteResultTask(result);
|
|
}
|
|
else
|
|
{
|
|
TaskManager.CompleteResultTask();
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
private static ResultObject DeleteRemoteDesktopServiceInternal(int itemId)
|
|
{
|
|
var result = TaskManager.StartResultTask<ResultObject>("REMOTE_DESKTOP_SERVICES", "CLEANUP");
|
|
|
|
try
|
|
{
|
|
var collections = GetOrganizationRdsCollections(itemId);
|
|
|
|
foreach (var collection in collections)
|
|
{
|
|
RemoveRdsCollection(itemId, collection);
|
|
}
|
|
|
|
var servers = GetOrganizationRdsServers(itemId);
|
|
|
|
foreach (var server in servers)
|
|
{
|
|
RemoveRdsServerFromOrganization(itemId, server.Id);
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
result.AddError("REMOTE_DESKTOP_SERVICES_CLEANUP", ex);
|
|
}
|
|
finally
|
|
{
|
|
if (!result.IsSuccess)
|
|
{
|
|
TaskManager.CompleteResultTask(result);
|
|
}
|
|
else
|
|
{
|
|
TaskManager.CompleteResultTask();
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
private static int GetOrganizationRdsUsersCountInternal(int itemId)
|
|
{
|
|
return DataProvider.GetOrganizationRdsUsersCount(itemId);
|
|
}
|
|
|
|
private static int GetOrganizationRdsServersCountInternal(int itemId)
|
|
{
|
|
return DataProvider.GetOrganizationRdsServersCount(itemId);
|
|
}
|
|
|
|
private static int GetOrganizationRdsCollectionsCountInternal(int itemId)
|
|
{
|
|
return DataProvider.GetOrganizationRdsCollectionsCount(itemId);
|
|
}
|
|
|
|
private static List<RdsServer> GetCollectionRdsServersInternal(int collectionId)
|
|
{
|
|
return ObjectUtils.CreateListFromDataReader<RdsServer>(DataProvider.GetRDSServersByCollectionId(collectionId)).ToList();
|
|
}
|
|
|
|
private static List<RdsServer> GetOrganizationRdsServersInternal(int itemId)
|
|
{
|
|
return ObjectUtils.CreateListFromDataReader<RdsServer>(DataProvider.GetRDSServersByItemId(itemId)).ToList();
|
|
}
|
|
|
|
private static List<ServiceInfo> GetRdsServicesInternal()
|
|
{
|
|
return ObjectUtils.CreateListFromDataSet<ServiceInfo>(DataProvider.GetServicesByGroupName(SecurityContext.User.UserId, ResourceGroups.RDS));
|
|
}
|
|
|
|
protected static int GetRdsMainServiceId()
|
|
{
|
|
var settings = SystemController.GetSystemSettings(WebsitePanel.EnterpriseServer.SystemSettings.RDS_SETTINGS);
|
|
|
|
if (!string.IsNullOrEmpty(settings["RdsMainController"]))
|
|
{
|
|
return Convert.ToInt32(settings["RdsMainController"]);
|
|
}
|
|
|
|
var rdsServices = GetRdsServicesInternal();
|
|
|
|
if (rdsServices.Any())
|
|
{
|
|
return rdsServices.First().ServiceId;
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
protected static RdsCollection FillRdsCollection(RdsCollection collection)
|
|
{
|
|
collection.Servers = GetCollectionRdsServersInternal(collection.Id) ?? new List<RdsServer>();
|
|
|
|
return collection;
|
|
}
|
|
|
|
protected static int GetRdsServiceId(int? itemId)
|
|
{
|
|
int serviceId = -1;
|
|
|
|
if (itemId.HasValue)
|
|
{
|
|
Organization org = OrganizationController.GetOrganization(itemId.Value);
|
|
|
|
if (org == null)
|
|
{
|
|
return serviceId;
|
|
}
|
|
|
|
serviceId = RemoteDesktopServicesHelpers.GetRemoteDesktopServiceID(org.PackageId);
|
|
}
|
|
else
|
|
{
|
|
serviceId = GetRdsMainServiceId();
|
|
}
|
|
|
|
return serviceId;
|
|
}
|
|
|
|
private static RdsServerInfo GetRdsServerInfoInternal(int? itemId, string fqdnName)
|
|
{
|
|
int serviceId = GetRdsServiceId(itemId);
|
|
var result = new RdsServerInfo();
|
|
|
|
if (serviceId != -1)
|
|
{
|
|
var rds = RemoteDesktopServicesHelpers.GetRemoteDesktopServices(serviceId);
|
|
result = rds.GetRdsServerInfo(fqdnName);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
private static string GetRdsServerStatusInternal(int? itemId, string fqdnName)
|
|
{
|
|
var result = "Unavailable";
|
|
var serviceId = GetRdsServiceId(itemId);
|
|
|
|
try
|
|
{
|
|
if (serviceId != -1)
|
|
{
|
|
var rds = RemoteDesktopServicesHelpers.GetRemoteDesktopServices(serviceId);
|
|
result = rds.GetRdsServerStatus(fqdnName);
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
|
|
return result;
|
|
}
|
|
}
|
|
}
|