public ExternalIdentityProviderDto GetIdentityProvider(ExternalIdentityProviderDto provider)
		{ 
			var idp = new ExternalIdentityProviderDto ();
			ActionHelper.Execute (delegate() {
				var serverDto = GetServerDto ();
				var auth = SnapInContext.Instance.AuthTokenManager.GetAuthToken (serverDto.ServerName);
				var tenantName = GetTenant ();
				idp = SnapInContext.Instance.ServiceGateway.ExternalIdentityProvider.Get (serverDto, tenantName, provider, auth.Token);
			});
			return idp;
		}
 public bool Delete(ServerDto serverDto, string tenant, ExternalIdentityProviderDto externalIdentityProvider, Token token)
 {
     var url = string.Format(ServiceConfigManager.ExternalIdentityProviderEndPoint, serverDto.Protocol, serverDto.ServerName, serverDto.Port, tenant, externalIdentityProvider.EntityID);
     ServicePointManager.ServerCertificateValidationCallback = delegate { return true; };
     var requestConfig = new RequestSettings
     {
         Method = HttpMethod.Delete,
     };
     var headers = ServiceHelper.AddHeaders(ServiceConfigManager.JsonContentType);
     var json = "access_token=" + token.AccessToken + "&token_type=" + token.TokenType.ToString().ToLower();
     var response = _webRequestManager.GetResponse(url, requestConfig, headers, null, json);
     return string.IsNullOrEmpty(response);
 }
 public ExternalIdentityProviderDto Get(ServerDto serverDto, string tenantName, ExternalIdentityProviderDto externalIdentityProvider, Token token)
 {
     var name = Uri.EscapeDataString(externalIdentityProvider.EntityID);
     tenantName = Uri.EscapeDataString(tenantName);
     var url = string.Format(ServiceConfigManager.GetExternalIdentityProviderPostEndPoint, serverDto.Protocol, serverDto.ServerName, serverDto.Port, tenantName, externalIdentityProvider.EntityID);
     ServicePointManager.ServerCertificateValidationCallback = delegate { return true; };
     var requestConfig = new RequestSettings
     {
         Method = HttpMethod.Post,
     };
     var headers = ServiceHelper.AddHeaders(ServiceConfigManager.JsonContentType);
     var postData = "access_token=" + token.AccessToken + "&token_type=" + token.TokenType.ToString().ToLower();
     var response = _webRequestManager.GetResponse(url, requestConfig, headers, null, postData);
     return JsonConvert.Deserialize<ExternalIdentityProviderDto>(response, true);
 }
 public ExternalIdentityProviderDto Create(ServerDto server, string tenantName, ExternalIdentityProviderDto externalIdentityProvider, Token token)
 {
     tenantName = Uri.EscapeDataString(tenantName);
     var url = string.Format(ServiceConfigManager.ExternalIdentityProvidersEndPoint, server.Protocol, server.ServerName, server.Port, tenantName);
     var dto = typeof(ExternalIdentityProviderDto).Assembly;
     var json = JsonConvert.Serialize(externalIdentityProvider, true);
     ServicePointManager.ServerCertificateValidationCallback = delegate { return true; };
     var requestConfig = new RequestSettings
     {
         Method = HttpMethod.Post,
     };
     var headers = ServiceHelper.AddHeaders(ServiceConfigManager.JsonContentType);
     json = "access_token=" + token.AccessToken + "&token_type=" + token.TokenType.ToString().ToLower() + "&" + json;
     var response = _webRequestManager.GetResponse(url, requestConfig, headers, null, json);
     return JsonConvert.Deserialize<ExternalIdentityProviderDto>(response);
 }
		public void DeleteExternalIdentityProvider(ExternalIdentityProviderDto dto)
		{
			ActionHelper.Execute (delegate() {
				var serverDto = GetServerDto ();
				var tenant = GetTenant ();
				var auth = SnapInContext.Instance.AuthTokenManager.GetAuthToken (serverDto.ServerName);
				var success = SnapInContext.Instance.ServiceGateway.ExternalIdentityProvider.Delete (serverDto, tenant, dto, auth.Token);
				if (success) {
					UIErrorHelper.ShowAlert ("External Identity Provider " + dto.EntityID + " deleted successfully", "Information");
				} else {

					UIErrorHelper.ShowAlert ("Failed to delete External Identity Provider " + dto.EntityID, "Information");
				}
				Refresh (this, EventArgs.Empty);
			});
		}
		private ExternalIdentityProviderDto AddExternalIdp(ExternalIdentityProviderDto idp)
		{
			var serverDto = GetServerDto ();
			var auth = SnapInContext.Instance.AuthTokenManager.GetAuthToken(serverDto.ServerName);
			var tenantName = GetTenant();
			return SnapInContext.Instance.ServiceGateway.ExternalIdentityProvider.Create(serverDto, tenantName, idp, auth.Token);
		}
 public ExternalIdentityProviderDto Update(ServerDto serverDto, string tenant, ExternalIdentityProviderDto externalIdentityProvider, Token token)
 {
     var url = string.Format(ServiceConfigManager.ExternalIdentityProviderEndPoint, serverDto.Protocol, serverDto.ServerName, serverDto.Port, tenant, externalIdentityProvider.EntityID);
     var json = JsonConvert.Serialize(externalIdentityProvider);
     json = SerializationJsonHelper.Cleanup(json);
     json = Cleanup(json);
     ServicePointManager.ServerCertificateValidationCallback = delegate { return true; };
     var requestConfig = new RequestSettings
     {
         Method = HttpMethod.Put,
     };
     var headers = ServiceHelper.AddHeaders(ServiceConfigManager.JsonContentType);
     json = "access_token=" + token.AccessToken + "&token_type=" + token.TokenType.ToString().ToLower() + "&" + json;
     var response = _webRequestManager.GetResponse(url, requestConfig, headers, null, json);
     response = SerializationJsonHelper.JsonToDictionary("subjectFormats", response);
     var dto = typeof(IdentityProviderDto).Assembly;
     return JsonConvert.Deserialize<ExternalIdentityProviderDto>(response, "root", dto.GetTypes(), true);
 }
		public override void AwakeFromNib ()
		{
			base.AwakeFromNib ();
			ExternalIdentityProviderDto = new ExternalIdentityProviderDto () {
				NameIDFormats = new List<string>(),
				SubjectFormats = new Dictionary<string, string>(),
				SsoServices = new List<ServiceEndpointDto>(),
				SloServices = new List<ServiceEndpointDto>(),
				SigningCertificates = new CertificateChainDto{
					Certificates = new List<CertificateDto>()
				}
			};

			// Name Id formats
			BtnAddNameIdFormat.Activated += (object sender, EventArgs e) => {
				if(string.IsNullOrEmpty(TxtNameIdFormat.StringValue))
				{
					UIErrorHelper.ShowAlert ("Name Id format cannot be empty", "Alert");
					return;
				}
				ExternalIdentityProviderDto.NameIDFormats.Add(TxtNameIdFormat.StringValue);
				ReloadTableView(LstNameIdFormat, ExternalIdentityProviderDto.NameIDFormats);
				TxtNameIdFormat.StringValue = (NSString)string.Empty;
			};

			BtnRemoveNameIdFormat.Activated += (object sender, EventArgs e) => {
				if (LstNameIdFormat.SelectedRows.Count > 0) {
					foreach (var row in LstNameIdFormat.SelectedRows) {

						ExternalIdentityProviderDto.NameIDFormats.RemoveAt((int)row);
					}
					ReloadTableView(LstNameIdFormat, ExternalIdentityProviderDto.NameIDFormats);
				}
			};
			ReloadTableView(LstNameIdFormat, ExternalIdentityProviderDto.NameIDFormats);

			// Subject formats
			BtnAddSubjectFormat.Activated += (object sender, EventArgs e) => {
				if(string.IsNullOrEmpty(TxtSubjectFormatName.StringValue))
				{
					UIErrorHelper.ShowAlert ("Subject format name cannot be empty", "Alert");
					return;
				}
				if(string.IsNullOrEmpty(TxtSubjectFormatValue.StringValue))
				{
					UIErrorHelper.ShowAlert ("Subject format value cannot be empty", "Alert");
					return;
				}
				if(ExternalIdentityProviderDto.SubjectFormats.ContainsKey(TxtSubjectFormatName.StringValue))
				{
					UIErrorHelper.ShowAlert ("Subject format name already exists", "Alert");
					return;
				}
				ExternalIdentityProviderDto.SubjectFormats.Add(TxtSubjectFormatName.StringValue, TxtSubjectFormatValue.StringValue);
				ReloadTableView(LstSubjectFormat, ExternalIdentityProviderDto.SubjectFormats);
				TxtSubjectFormatName.StringValue = (NSString)string.Empty;
				TxtSubjectFormatValue.StringValue = (NSString)string.Empty;
			};

			BtnRemoveSubjectFormat.Activated += (object sender, EventArgs e) => {
				if (LstSubjectFormat.SelectedRows.Count > 0) {
					foreach (var row in LstSubjectFormat.SelectedRows) {
						var source = LstSubjectFormat.DataSource as DictionaryDataSource;
						var name = source.Entries[(int)row];
						ExternalIdentityProviderDto.SubjectFormats.Remove(name);
					}
					ReloadTableView(LstSubjectFormat, ExternalIdentityProviderDto.SubjectFormats);
				}
			};
			ReloadTableView(LstSubjectFormat, ExternalIdentityProviderDto.SubjectFormats);

			// Certificates
			BtnAddCertificate.Activated +=	(object sender, EventArgs e) => {
				var openPanel = new NSOpenPanel();
				openPanel.ReleasedWhenClosed = true;
				openPanel.Prompt = "Select file";

				var result = openPanel.RunModal();
				if (result == 1)
				{
					var filePath = openPanel.Url.AbsoluteString.Replace("file://",string.Empty);
					var cert = new X509Certificate2 ();
					ActionHelper.Execute (delegate() {
						cert.Import (filePath);
						var certfificateDto = new CertificateDto { Encoded = cert.ToPem(), };
						ExternalIdentityProviderDto.SigningCertificates.Certificates.Add(certfificateDto);
						ReloadCertificates();
					});
				}
			};

			BtnRemoveCertificate.Activated += (object sender, EventArgs e) => {
				if (LstCertificates.SelectedRows.Count > 0) {
					foreach (var row in LstCertificates.SelectedRows) {
						ExternalIdentityProviderDto.SigningCertificates.Certificates.RemoveAt ((int)row);
					}
					ReloadCertificates();
				}
			};
			ReloadCertificates ();

			// Sso Services
			BtnAddSso.Activated += OnAddSsoServices;
			BtnRemoveSso.Activated += OnRemoveSsoServices;	
			InitializeSsoServices ();

			// Slo Services
			BtnAddSlo.Activated += OnAddSloServices;
			BtnRemoveSlo.Activated += OnRemoveSloServices;	
			InitializeSloServices ();

			this.BtnSave.Activated += (object sender, EventArgs e) => {
				if (string.IsNullOrEmpty (TxtUniqueId.StringValue)) {
					UIErrorHelper.ShowAlert ("Please choose a Unique Id", "Alert");
				} else if (ExternalIdentityProviderDto.NameIDFormats.Count() < 1) {
					UIErrorHelper.ShowAlert ("Please choose a Name Id format", "Alert");
				} else if (ExternalIdentityProviderDto.SubjectFormats.Count() < 1) {
					UIErrorHelper.ShowAlert ("Please choose a Subject Id format", "Alert");
				} else if (ExternalIdentityProviderDto.SsoServices.Count() < 1) {
					UIErrorHelper.ShowAlert ("Please choose a Sso Service", "Alert");
				} else if (ExternalIdentityProviderDto.SloServices.Count() < 1) {
					UIErrorHelper.ShowAlert ("Please choose a Slo service", "Alert");
				} else if (ExternalIdentityProviderDto.SigningCertificates.Certificates.Count() < 1) {
					UIErrorHelper.ShowAlert ("Please choose a certificate", "Alert");
				} else {
					ExternalIdentityProviderDto.EntityID = TxtUniqueId.StringValue;
					ExternalIdentityProviderDto.JitEnabled = ChkJit.StringValue == "1";

					ActionHelper.Execute(delegate {
						var auth = SnapInContext.Instance.AuthTokenManager.GetAuthToken(ServerDto.ServerName);
						SnapInContext.Instance.ServiceGateway.ExternalIdentityProvider.Create(ServerDto,TenantName,ExternalIdentityProviderDto,auth.Token);
						this.Close ();
						NSApplication.SharedApplication.StopModalWithCode (1);
					});
				}
			};

			BtnClose.Activated += (object sender, EventArgs e) => {
				this.Close ();
				NSApplication.SharedApplication.StopModalWithCode (0);
			};
			BtnViewCertificate.Activated += (object sender, EventArgs e) => 
			{
				if (LstCertificates.SelectedRows.Count > 0) {
					var row = LstCertificates.SelectedRows.First();
					var encoded = ExternalIdentityProviderDto.SigningCertificates.Certificates[(int)row].Encoded;
					var bytes = System.Text.Encoding.ASCII.GetBytes (encoded);
					var certificate = new X509Certificate2(bytes);
					CertificateService.DisplayX509Certificate2(this, certificate);
				}
			};
		}