public async Task <System.Version> GetServerVersion(StandardServerTypes serverType)
{
var result = await FetchAsync($"server/version/{serverType}");
var versionString = JsonConvert.DeserializeObject <string>(result, new Newtonsoft.Json.Converters.VersionConverter());
var version = Version.Parse(versionString);
return(version);
}
public async Task <bool> IsServerTypeAvailable(StandardServerTypes serverType)
{
if (serverType == StandardServerTypes.IIS)
{
return(await _serverProvider.IsAvailable());
}
return(false);
}
public async Task <List <DomainOption> > GetServerSiteDomainOptions(StandardServerTypes serverType, string serverSiteId)
{
if (serverType == StandardServerTypes.IIS)
{
return(await _certifyManager.GetDomainOptionsFromSite(serverSiteId));
}
else
{
return(new List <DomainOption>());
}
}
public async Task <List <ActionStep> > RunServerDiagnostics(StandardServerTypes serverType, string siteId)
{
if (serverType == StandardServerTypes.IIS)
{
return(await _certifyManager.RunServerDiagnostics(serverType, siteId));
}
else
{
return(null);
}
}
public List <SiteBindingItem> GetServerSiteList(StandardServerTypes serverType)
{
if (serverType == StandardServerTypes.IIS)
{
return(_certifyManager.GetPrimaryWebSites(Management.CoreAppSettings.Current.IgnoreStoppedSites));
}
else
{
return(new List <SiteBindingItem>());
}
}
public async Task <List <BindingInfo> > GetServerSiteList(StandardServerTypes serverType)
{
if (serverType == StandardServerTypes.IIS)
{
return(await _certifyManager.GetPrimaryWebSites(Management.CoreAppSettings.Current.IgnoreStoppedSites));
}
else
{
return(new List <BindingInfo>());
}
}
/// <summary>
/// check if Server type (e.g. IIS) is available, if so also populates IISVersion
/// </summary>
/// <param name="serverType"></param>
/// <returns></returns>
public async Task <bool> CheckServerAvailability(StandardServerTypes serverType)
{
IsIISAvailable = await CertifyClient.IsServerAvailable(StandardServerTypes.IIS);
if (IsIISAvailable)
{
IISVersion = await CertifyClient.GetServerVersion(StandardServerTypes.IIS);
}
RaisePropertyChangedEvent(nameof(IISVersion));
return(IsIISAvailable);
}
public async Task <bool> IsServerAvailable(StandardServerTypes serverType)
{
DebugLog();
if (serverType == StandardServerTypes.IIS)
{
return(await _certifyManager.IsServerTypeAvailable(serverType));
}
else
{
return(false);
}
}
public async Task <string> GetServerVersion(StandardServerTypes serverType)
{
if (serverType == StandardServerTypes.IIS)
{
var version = await _certifyManager.GetServerTypeVersion(serverType);
return(version.ToString());
}
else
{
return(null);
}
}
/// <summary>
/// WIP: For current configured environment, show preview of recommended site management (for
/// local IIS, scan sites and recommend actions)
/// </summary>
/// <returns></returns>
public async Task <List <ManagedCertificate> > PreviewManagedCertificates(StandardServerTypes serverType,
ICertifiedServer serverProvider, ICertifyManager certifyManager)
{
var sites = new List <ManagedCertificate>();
if (serverType == StandardServerTypes.IIS)
{
try
{
var allSites = await serverProvider.GetSiteBindingList(CoreAppSettings.Current.IgnoreStoppedSites);
var iisSites = allSites
.OrderBy(s => s.SiteId)
.ThenBy(s => s.Host);
var siteIds = iisSites.GroupBy(x => x.SiteId);
foreach (var s in siteIds)
{
var managedCertificate = new ManagedCertificate {
Id = s.Key
};
managedCertificate.ItemType = ManagedCertificateType.SSL_ACME;
managedCertificate.TargetHost = "localhost";
managedCertificate.Name = iisSites.First(i => i.SiteId == s.Key).SiteName;
//TODO: replace site binding with domain options
//managedCertificate.SiteBindings = new List<ManagedCertificateBinding>();
/* foreach (var binding in s)
* {
* var managedBinding = new ManagedCertificateBinding { Hostname = binding.Host, IP = binding.IP, Port = binding.Port, UseSNI = true, CertName = "Certify_" + binding.Host };
* // managedCertificate.SiteBindings.Add(managedBinding);
* }*/
sites.Add(managedCertificate);
}
}
catch (Exception)
{
//can't read sites
Debug.WriteLine("Can't get IIS site list.");
}
}
return(sites);
}
/// <summary>
/// Check if the target service provider is available on the host machine
/// </summary>
/// <param name="serverType"></param>
/// <returns></returns>
public async Task <bool> IsServerTypeAvailable(StandardServerTypes serverType)
{
if (serverType == StandardServerTypes.IIS)
{
if (_useWindowsNativeFeatures)
{
return(await _serverProvider.IsAvailable());
}
else
{
// non-windows platform
return(false);
}
}
return(false);
}
public async Task <List <SiteBindingItem> > GetServerSiteList(StandardServerTypes serverType)
{
var result = await FetchAsync($"server/sitelist/{serverType}");
return(JsonConvert.DeserializeObject <List <SiteBindingItem> >(result));
}
public async Task <bool> IsServerAvailable(StandardServerTypes serverType)
{
var result = await FetchAsync($"server/isavailable/{serverType}");
return(bool.Parse(result));
}
internal async Task <List <BindingInfo> > GetServerSiteList(StandardServerTypes serverType)
{
return(await CertifyClient.GetServerSiteList(serverType));
}
public async Task <Version> GetServerTypeVersion(StandardServerTypes serverType) => await _serverProvider.GetServerVersion();
/// <summary>
/// For a given server type and service identifier, return list of domain options (identifiers) currently in use.
/// </summary>
/// <param name="serverType"></param>
/// <param name="siteId"></param>
/// <returns></returns>
internal async Task <List <DomainOption> > GetServerSiteDomains(StandardServerTypes serverType, string siteId)
{
return(await _certifyClient.GetServerSiteDomains(serverType, siteId));
}
public async Task <List <ActionStep> > RunServerDiagnostics(StandardServerTypes serverType, string siteId) => await _serverProvider.RunConfigurationDiagnostics(siteId);
public async Task <List <ActionStep> > RunConfigurationDiagnostics(StandardServerTypes serverType, string serverSiteId)
{
var results = await FetchAsync($"server/diagnostics/{serverType}/{serverSiteId}");
return(JsonConvert.DeserializeObject <List <ActionStep> >(results));
}
public async Task <List <DomainOption> > GetServerSiteDomains(StandardServerTypes serverType, string serverSiteId)
{
var result = await FetchAsync($"server/sitedomains/{serverType}/{serverSiteId}");
return(JsonConvert.DeserializeObject <List <DomainOption> >(result));
}
public async Task <Version> GetServerTypeVersion(StandardServerTypes serverType)
{
return(await this._serverProvider.GetServerVersion());
}
