private void button1_Click(object sender, RoutedEventArgs e)
{
if (textBoxEmail.Text.Length == 0)
{
errormessage.Text = "Enter an email.";
textBoxEmail.Focus();
}
else if (!textBoxEmail.Text.Equals("1") && (!Regex.IsMatch(textBoxEmail.Text, @"^[a-zA-Z][\w\.-]*[a-zA-Z0-9]@[a-zA-Z0-9][\w\.-]*[a-zA-Z0-9]\.[a-zA-Z][a-zA-Z\.]*[a-zA-Z]$")))
{
errormessage.Text = "Enter a valid email.";
textBoxEmail.Select(0, textBoxEmail.Text.Length);
textBoxEmail.Focus();
}
else if ((comboBoxDatabase.SelectedValue as ListBoxItem) == null)
{
errormessage.Text = "Select database from provided list";
}
else
{
// Save global variables with connection string to database selected from combo for future nhibernate use when initiation session
if ((comboBoxDatabase.SelectedValue as ListBoxItem).Content.ToString().Equals("mydb"))
{
Application.Current.Properties["HOSTNAME"] = "localhost";
Application.Current.Properties["DBSID"] = "mydb";
Application.Current.Properties["DBUSER"] = "******";
Application.Current.Properties["DBPASSWORD"] = "******";
}
else if ((comboBoxDatabase.SelectedValue as ListBoxItem).Content.ToString().Equals("mydbTest"))
{
Application.Current.Properties["HOSTNAME"] = "localhost";
Application.Current.Properties["DBSID"] = "mydbTest";
Application.Current.Properties["DBUSER"] = "******";
Application.Current.Properties["DBPASSWORD"] = "******";
}
string email = textBoxEmail.Text;
string password = passwordBox1.Password;
UserIdentity userInstance = new UserIdentity();
bool isUserAuthenticated = nhibernategateway.ValidateUserCredentials(email,password, out userInstance);
if (isUserAuthenticated)
{
Application.Current.Properties["LoggedUserID"] = userInstance.id.ToString();
Application.Current.Properties["LoggedUserEmail"] = userInstance.email.ToString();
MainConsole myMainWindow = new MainConsole();
System.Windows.Application.Current.ShutdownMode = ShutdownMode.OnMainWindowClose;
System.Windows.Application.Current.MainWindow = myMainWindow;
myMainWindow.Show();
Close();
}
else
{
errormessage.Text = "Please enter existing Email/Password.";
}
}
}
public void Terminate(UserIdentity userIdentity)
{
if (_serverSidePresentationSchemaTransfer.Contains(userIdentity))
_serverSidePresentationSchemaTransfer.Terminate(userIdentity);
else if (_serverSidePresentationTransfer.Contains(userIdentity))
_serverSidePresentationTransfer.Terminate(userIdentity);
}
protected void btnLogon_Click(object sender, EventArgs e)
{
if (AuthMod.ValidateUser(txtInputBrukernavn.Text, txtInputPassord.Text)) {
FormsAuthenticationTicket tkt = new FormsAuthenticationTicket(1, txtInputBrukernavn.Text, DateTime.Now,
DateTime.Now.AddMinutes(30), chkRememberMe.Checked, "AuthentiCationCookie");
string cookiestr = FormsAuthentication.Encrypt(tkt);
HttpCookie authCookie = new HttpCookie(FormsAuthentication.FormsCookieName, cookiestr);
if (chkRememberMe.Checked)
authCookie.Expires = tkt.Expiration;
authCookie.Path = FormsAuthentication.FormsCookiePath;
string encTicket = authCookie.Value;
if (!String.IsNullOrEmpty(encTicket)) {
var ticket = FormsAuthentication.Decrypt(encTicket);
UserIdentity id = new UserIdentity(ticket, AuthMod);
var userRoles = AuthMod.GetRolesForUser(id.Name);
var prin = new GenericPrincipal(id, userRoles);
HttpContext.Current.User = prin;
}
System.Threading.Thread.CurrentPrincipal = HttpContext.Current.User;
HttpContext.Current.Cache.Insert("customPrincipal", HttpContext.Current.User);
Response.Cookies.Add(authCookie);
FormsAuthentication.RedirectFromLoginPage(txtInputBrukernavn.Text, chkRememberMe.Checked);
} else {
logonErrorSpan.Visible = true;
//Response.Redirect("~/Public/Login.aspx", true);
}
}
private void _lockingStorage_OnRemoveItem(UserIdentity sender, ObjectKey key, LockingInfoWithCommunicationObject value)
{
if (RemoveItem != null)
{
RemoveItem(sender, key, value.LockingInfo);
}
}
public FileTransferObject? Receive(UserIdentity userIdentity, string resourceId)
{
if (_serverSidePresentationSchemaTransfer.Contains(userIdentity))
return _serverSidePresentationSchemaTransfer.Receive(userIdentity, resourceId);
else if (_serverSidePresentationTransfer.Contains(userIdentity))
return _serverSidePresentationTransfer.Receive(userIdentity, resourceId);
return null;
}
public FileSaveStatus Send(UserIdentity userIdentity, FileTransferObject obj)
{
if (_serverSidePresentationSchemaTransfer.Contains(userIdentity))
return _serverSidePresentationSchemaTransfer.Send(userIdentity, obj);
else if (_serverSidePresentationTransfer.Contains(userIdentity))
return _serverSidePresentationTransfer.Send(userIdentity, obj);
return FileSaveStatus.Abort;
}
// deauthenticates the user given by the input session
public void Deauthenticate(ref UserSession session)
{
// gets the sessions authenticated id (possibly null)
var authenticatedId = session?.Identity().AuthenticatedId;
if (authenticatedId == null) return;
// deauthenticates the current user
var userId = new UserIdentity(authenticatedId.GetValueOrDefault(), "");
session = new UserSession(userId, false);
}
public int MapIdentity(string userid, string identytProvider, string identityValue)
{
var mapping = new UserIdentity();
mapping.UserId = new Guid(userid);
mapping.IdentityProvider = identytProvider;
mapping.IdentityValue = identityValue;
_context.AddToUserIdentities(mapping);
_context.SaveChanges();
return mapping.IdentityID;
}
public FileTransferObject? Receive(UserIdentity userIdentity, string resourceId)
{
try
{
return _serverSideGroupFileTransfer.Receive(userIdentity, resourceId);
}
catch(Exception ex)
{
_config.EventLog.WriteError(string.Format("ConfigurationExportHelper.Receive: {0}", ex));
return null;
}
}
//private readonly LockingNotifier _notifier = new LockingNotifier();
public LockingService(UserIdentity systemUser, IEventLogging log)
{
_systemUser = systemUser;
_log = log;
_timer = new Timer(_interval);
_timer.Elapsed += new ElapsedEventHandler(_timer_Elapsed);
_timer.Start();
_lockingStorage = new LockingStorage();
_lockingStorage.OnAddItem += _lockingStorage_OnAddItem;
_lockingStorage.OnRemoveItem += _lockingStorage_OnRemoveItem;
//_lockingStorage.OnAddItem += new TechnicalServices.Common.StorageAction<ObjectKey, LockingInfo>(_notifier.SubscribeForMonitor);
//_lockingStorage.OnRemoveItem +=new TechnicalServices.Common.StorageAction<ObjectKey,LockingInfo>(_notifier.UnSubscribeForMonitor);
}
public ServerSideFileReceive(UserIdentity userIdentity, /*IResourceEx<T> resourceEx*/IFileInfoProvider provider)
{
//_resourceEx = resourceEx;
_userIdentity = userIdentity;
//Resource = resource;
_provider = provider;
//_resourceFileInfo = _resource.ResourceInfo as ResourceFileInfo;
if (OperationContext.Current != null && OperationContext.Current.Channel != null)
{
_communicationObject = OperationContext.Current.Channel;
_communicationObject.Faulted += new EventHandler(Abort);
}
}
// authenticates and provides a user with a corresponding session
public UserSession Authenticate(string email, string password)
{
// returns null if user could not be authenticated based on the input
using (var db = new SmartPoolContext())
{
// queries the database for users with the specified input
var userQuery = from users in db.Users
where users.Email == email && users.Password == password
select users.UserId;
// checks to see whether the input was matched by the query
var userId = new UserIdentity(userQuery.First(), password);
return userQuery.Any() ? new UserSession(userId, true) : null;
}
}
public PresentationListController(PresentationListForm AView)
{
_instance = this;
view = AView;
identity = Thread.CurrentPrincipal as UserIdentity;
DesignerClient.Instance.PresentationNotifier.OnObjectLocked += new EventHandler<NotifierEventArg<LockingInfo>>(PresentationNotifier_OnObjectLocked);
DesignerClient.Instance.PresentationNotifier.OnObjectUnLocked += new EventHandler<NotifierEventArg<LockingInfo>>(PresentationNotifier_OnObjectUnLocked);
DesignerClient.Instance.PresentationNotifier.OnPresentationAdded += new EventHandler<NotifierEventArg<PresentationInfo>>(PresentationNotifier_OnPresentationAdded);
DesignerClient.Instance.PresentationNotifier.OnPresentationDeleted += new EventHandler<NotifierEventArg<PresentationInfo>>(PresentationNotifier_OnPresentationDeleted);
DesignerClient.Instance.PresentationNotifier.OnObjectChanged += new EventHandler<NotifierEventArg<IList<ObjectInfo>>>(PresentationNotifier_OnObjectChanged);
DesignerClient.Instance.PresentationWorker.SubscribeForGlobalMonitoring();
}
public override bool DeleteSource(UserIdentity sender, DeviceResourceDescriptor descriptor)
{
_sync.AcquireWriterLock(Timeout.Infinite);
try
{
bool isSuccess = base.DeleteSource(sender, descriptor);
if (isSuccess)
_cache.DeleteResource(descriptor);
return isSuccess;
}
finally
{
_sync.ReleaseWriterLock();
}
}
public override bool DeletePresentation(UserIdentity sender, string uniqueName)
{
_sync.AcquireWriterLock(Timeout.Infinite);
try
{
bool isSuccess = base.DeletePresentation(sender, uniqueName);
if (isSuccess)
_cache.Delete(ObjectKeyCreator.CreatePresentationKey(uniqueName));
return isSuccess;
}
finally
{
_sync.ReleaseWriterLock();
}
}
public override bool SavePresentation(UserIdentity sender, Presentation presentation)
{
_sync.AcquireWriterLock(Timeout.Infinite);
try
{
bool isSuccess = base.SavePresentation(sender, presentation);
if (isSuccess)
_cache.Add(ObjectKeyCreator.CreatePresentationKey(presentation),
presentation);
return isSuccess;
}
finally
{
_sync.ReleaseWriterLock();
}
}
/// <summary>
/// Authenticate the request.
/// Using Custom Forms Authentication since I'm not using the "RolesProvider".
/// Roles are manually stored / encrypted in a cookie in <see cref="FormsAuthenticationService.SignIn"/>
/// This takes out the roles from the cookie and rebuilds the Principal w/ the decrypted roles.
/// http://msdn.microsoft.com/en-us/library/aa302397.aspx
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
public static void RebuildUserFromCookies()
{
string cookieName = FormsAuthentication.FormsCookieName;
HttpCookie authCookie = HttpContext.Current.Request.Cookies[cookieName];
if (null == authCookie) return;
FormsAuthenticationTicket authTicket = FormsAuthentication.Decrypt(authCookie.Value);
String[] roles = authTicket.UserData.Split(new char[] { ',' });
// Create an Identity object
IIdentity id = new UserIdentity(0, authTicket.Name, "Forms", true);
IPrincipal principal = new UserPrincipal(0, authTicket.Name, roles, id);
// Attach the new principal object to the current HttpContext object
HttpContext.Current.User = principal;
}
public void LoginStatusChange(UserIdentity user, LogOnStatus newLoginStatus)
{
switch (newLoginStatus)
{
case LogOnStatus.LogOn:
_list.Add(user);
break;
case LogOnStatus.LogOff:
//int index = _list. FindIndex(value => value.Name == user.Name);
//if (index >= 0)
// _list.RemoveAt(index);
_list.Remove(user);
break;
default:
throw new ApplicationException("Ненене Дэвид Блейн ненене");
}
}
public static string GetPresentationStatusDescr(string Name, PresentationStatus status, UserIdentity id)
{
StringBuilder sb = new StringBuilder();
string userName = string.Empty;
if ((id != null) && (id.User != null))
userName = string.IsNullOrEmpty(id.User.FullName) ? id.User.Name : id.User.FullName;
switch (status)
{
case PresentationStatus.Deleted: sb.Append("Сценарий уже удален"); break;
case PresentationStatus.LockedForEdit: sb.AppendFormat("Сценарий заблокирован пользователем {0} для редактирования", userName); break;
case PresentationStatus.LockedForShow: sb.AppendFormat("Сценарий заблокирован пользователем {0} для показа", userName); break;
case PresentationStatus.SlideLocked: sb.Append("Сцена сценария заблокирована"); break;
case PresentationStatus.Unknown: sb.Append("Неизвестно"); break;
case PresentationStatus.AlreadyLocallyOpened: sb.Append("Сценарий уже открыт в другом экземпляре Дизайнера"); break;
}
return sb.ToString();
}
public override DeviceResourceDescriptor SaveSource(UserIdentity sender, DeviceResourceDescriptor resourceDescriptor, Dictionary<string, string> fileDic)
{
_sync.AcquireWriterLock(Timeout.Infinite);
try
{
DeviceResourceDescriptor stored
= base.SaveSource(sender, resourceDescriptor, fileDic);
if (null != stored)
{
_cache.AddResource(stored);
}
return stored;
}
finally
{
_sync.ReleaseWriterLock();
}
}
public async Task<ActionResult> Register(RegisterViewModel model)
{
if (ModelState.IsValid)
{
var user = new UserIdentity(model.UserName);
var result = await _userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
await SignInAsync(user, isPersistent: false);
return RedirectToAction("Index", "Home");
}
else
{
AddErrors(result);
}
}
// If we got this far, something failed, redisplay form
return View(model);
}
public void TestIdentityConstruction()
{
// Arrange
string testIdentityString = string.Format("{0}{2}{1}", Provider, Identity, UserIdentity.IdentitySeparator);
UserIdentity userIdentity = null;
// Act
try
{
userIdentity = new UserIdentity(testIdentityString);
}
catch (Exception e)
{
Assert.Fail(e.Message);
}
// Assert
Assert.IsNotNull(userIdentity);
Assert.AreEqual(userIdentity.IdentityProvider, IdentityProviderType.Email);
Assert.AreEqual(userIdentity.IdentityValue, Identity);
}
public BackgroundPresentationManager(IServerConfiguration config,
IPresentationWorker worker,
PresentationShowPreparator preparator,
DisplayAndEquipmentMonitor monitor,
IShowDisplayAndDeviceCommand showDisplayAndDeviceCommand,
UserIdentity systemUser)
{
_config = config;
_showPreparator = preparator;
_monitor = monitor;
_worker = worker;
_showDisplayAndDeviceCommand = showDisplayAndDeviceCommand;
_systemUser = systemUser;
_restoreShowTimer = new Timer(RestoreShow);
TimeSpan interval =TimeSpan.FromSeconds(BackgroundPresentationRestoreTimeout);
_backgroundPresentationChange = new Timer(MonitorForBackgroundPresentation, null, interval, interval);
// мониторинг оборудования
_monitor.OnStateChange += new EventHandler<TechnicalServices.Interfaces.ConfigModule.Server.EqiupmentStateChangeEventArgs>(_monitor_OnStateChange);
// мониторинг изменения в фоновом сценарии
_worker.OnPresentationChanged += new EventHandler<PresentationChangedEventArgs>(_worker_OnPresentationChanged);
}
public async Task<ActionResult> Register(RegisterViewModel model, string redirectUrl)
{
if (ModelState.IsValid)
{
if (_userService.CheckEmail(model.Email))
{
ModelState.AddModelError("", "This Email is already occupied. Please enter another Email!");
}
else
{
var user = new UserIdentity {UserName = model.Name, Email = model.Email};
var result = await _userManager.CreateAsync(user, model.Password);
if (result == IdentityResult.Success)
{
user = await _userManager.FindByNameAsync(model.Email);
await SignInAsync(user, true);
return RedirectToAction("Inbox", "Lists");
}
}
}
return View(model);
}
public void TestIdentityConstructionFromEncodedString()
{
// Arrange
string encodedString = Convert.ToBase64String(Encoding.UTF8.GetBytes(Identity));
string testIdentityString = string.Format("{0}{2}{1}", Provider, encodedString, UserIdentity.IdentitySeparator);
UserIdentity userIdentity = null;
// Act
try
{
userIdentity = new UserIdentity(testIdentityString, true);
}
catch (Exception e)
{
Assert.Fail(e.Message);
}
// Assert
Assert.IsNotNull(userIdentity);
Assert.AreEqual(userIdentity.IdentityProvider, IdentityProviderType.Email);
Assert.AreEqual(userIdentity.IdentityValue, Identity);
Assert.AreEqual(userIdentity.EncodedIdentity, testIdentityString);
}
public bool CreateFormsAuthenticationTicket(string loginName, AuthenticateUserResponse response)
{
// If we got here, we are authorized. Let's attempt to get the identity.
var identity = new UserIdentity
{
FirstName = response.FirstName,
LastName = response.LastName,
LoginName = loginName
};
// Create the ticket
FormsAuthenticationTicket ticket = new FormsAuthenticationTicket(
1,
GlobalSettings.Exigo.Api.CompanyKey + "_" + loginName,
DateTime.Now,
DateTime.Now.AddMinutes(GlobalSettings.Backoffices.SessionTimeout),
false,
identity.SerializeProperties());
// Encrypt the ticket
string encTicket = FormsAuthentication.Encrypt(ticket);
// Create the cookie.
HttpCookie cookie = HttpContext.Current.Request.Cookies[FormsAuthentication.FormsCookieName]; //saved user
if (cookie == null)
{
HttpContext.Current.Response.Cookies.Add(new HttpCookie(FormsAuthentication.FormsCookieName, encTicket));
}
else
{
cookie.Value = encTicket;
HttpContext.Current.Response.Cookies.Set(cookie);
}
return true;
}
public dynamic obterTrilhaTutorialPorCategoriaIdPaginado(int categoriaId, int tutorialId, UserIdentity usuarioLogado)
{
return(bmTrilhaTutorial.obterTrilhaTutorialPorCategoriaIdPaginado(categoriaId, tutorialId, usuarioLogado.Usuario.ID, usuarioLogado.Nivel));
}
public async Task FlowWithInvalidTypeInputValidationShouldFailAndNotChangeStateProperly()
{
// Arrange
var input = new PlainText()
{
Text = "Ping!"
};
Message.Content = input;
var invalidInputMessage = new Message()
{
From = UserIdentity.ToNode(),
To = ApplicationIdentity.ToNode(),
Content = new MediaLink()
};
var messageType = "text/plain";
var messageContent = "Pong!";
var validationMessageContent = "Invalid message type";
var flow = new Flow()
{
Id = Guid.NewGuid().ToString(),
States = new[]
{
new State
{
Id = "root",
Root = true,
Input = new Input
{
Validation = new InputValidation
{
Rule = InputValidationRule.Type,
Type = PlainText.MediaType,
Error = validationMessageContent
}
},
Outputs = new[]
{
new Output
{
StateId = "ping"
}
}
},
new State
{
Id = "ping",
InputActions = new[]
{
new Action
{
Type = "SendMessage",
Settings = new JObject()
{
{ "type", messageType },
{ "content", messageContent }
}
}
}
}
}
};
var target = GetTarget();
// Act
await target.ProcessInputAsync(invalidInputMessage, flow, CancellationToken);
await target.ProcessInputAsync(Message, flow, CancellationToken);
// Assert
StateManager.Received(1).SetStateIdAsync(Context, "ping", Arg.Any <CancellationToken>());
StateManager.Received(1).DeleteStateIdAsync(Context, Arg.Any <CancellationToken>());
Sender
.Received(1)
.SendMessageAsync(
Arg.Is <Message>(m =>
m.Id != null &&
m.To.ToIdentity().Equals(UserIdentity) &&
m.Type.ToString().Equals(messageType) &&
m.Content.ToString() == validationMessageContent),
Arg.Any <CancellationToken>());
Sender
.Received(1)
.SendMessageAsync(
Arg.Is <Message>(m =>
m.Id != null &&
m.To.ToIdentity().Equals(UserIdentity) &&
m.Type.ToString().Equals(messageType) &&
m.Content.ToString() == messageContent),
Arg.Any <CancellationToken>());
}
public async Task <IActionResult> OnPostConfirmationAsync(string returnUrl = null)
{
returnUrl = returnUrl ?? Url.Content("~/");
// Get the information about the user from the external login provider
var info = await _signInManager.GetExternalLoginInfoAsync();
if (info == null)
{
ErrorMessage = "Error loading external login information during confirmation.";
return(RedirectToPage("./Login", new { ReturnUrl = returnUrl }));
}
if (ModelState.IsValid)
{
var user = new UserIdentity {
UserName = Input.Email, Email = Input.Email
};
var result = await _userManager.CreateAsync(user);
if (result.Succeeded)
{
result = await _userManager.AddLoginAsync(user, info);
if (result.Succeeded)
{
_logger.LogInformation("User created an account using {Name} provider.", info.LoginProvider);
// If account confirmation is required, we need to show the link if we don't have a real email sender
if (_userManager.Options.SignIn.RequireConfirmedAccount)
{
return(RedirectToPage("./RegisterConfirmation", new { Email = Input.Email }));
}
await _signInManager.SignInAsync(user, isPersistent : false);
var userId = await _userManager.GetUserIdAsync(user);
var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
code = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(code));
var callbackUrl = Url.Page(
"/Account/ConfirmEmail",
pageHandler: null,
values: new { area = "Identity", userId = userId, code = code },
protocol: Request.Scheme);
await _emailSender.SendEmailAsync(Input.Email, "Confirm your email",
$"Please confirm your account by <a href='{HtmlEncoder.Default.Encode(callbackUrl)}'>clicking here</a>.");
return(LocalRedirect(returnUrl));
}
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
LoginProvider = info.LoginProvider;
ReturnUrl = returnUrl;
return(Page());
}
private async Task <Session> ConsoleSampleClient()
{
var application = new ApplicationInstance {
ApplicationType = ApplicationType.Client
};
#region Create an Application Configuration
Console.WriteLine(" 1 - Create an Application Configuration.");
ExitCode = ExitCode.ErrorCreateApplication;
// Load the Application Configuration and use the specified config section "Technosoftware.SimpleClient"
var config = await application.LoadConfigurationAsync("Technosoftware.SimpleClient");
// check the application certificate.
var haveAppCertificate = await application.CheckApplicationInstanceCertificateAsync(false, CertificateFactory.DefaultKeySize, CertificateFactory.DefaultLifeTime);
reverseConnectManager_ = null;
if (ReverseConnectUri != null)
{
// start the reverse connection manager
reverseConnectManager_ = new ReverseConnectManager();
reverseConnectManager_.AddEndpoint(ReverseConnectUri);
reverseConnectManager_.StartService(config);
}
if (haveAppCertificate)
{
config.ApplicationUri = X509Utils.GetApplicationUriFromCertificate(config.SecurityConfiguration.ApplicationCertificate.Certificate);
if (config.SecurityConfiguration.AutoAcceptUntrustedCertificates)
{
autoAccept_ = true;
}
config.CertificateValidator.CertificateValidation += OnCertificateValidation;
}
else
{
Console.WriteLine(" WARN: missing application certificate, using unsecured connection.");
}
#endregion
#region Discover endpoints
Console.WriteLine(" 2 - Discover endpoints of {0}.", endpointUrl_);
ExitCode = ExitCode.ErrorDiscoverEndpoints;
EndpointDescription selectedEndpoint;
if (reverseConnectManager_ == null)
{
selectedEndpoint = Discover.SelectEndpoint(endpointUrl_, haveAppCertificate && !SecurityNone, 15000);
}
else
{
Console.WriteLine(" Waiting for reverse connection.");
var connection = await reverseConnectManager_.WaitForConnection(
new Uri(endpointUrl_), null, new CancellationTokenSource(60000).Token);
if (connection == null)
{
throw new ServiceResultException(StatusCodes.BadTimeout, "Waiting for a reverse connection timed out.");
}
selectedEndpoint = Discover.SelectEndpoint(config, connection, haveAppCertificate && !SecurityNone, 15000);
}
Console.WriteLine(" Selected endpoint uses: {0}",
selectedEndpoint.SecurityPolicyUri.Substring(selectedEndpoint.SecurityPolicyUri.LastIndexOf('#') + 1));
#endregion
#region Create a session with OPC UA server
Console.WriteLine(" 3 - Create a session with OPC UA server.");
ExitCode = ExitCode.ErrorCreateSession;
// create the user identity
UserIdentity userIdentity;
if (String.IsNullOrEmpty(Username) && String.IsNullOrEmpty(Password))
{
userIdentity = new UserIdentity(new AnonymousIdentityToken());
}
else
{
userIdentity = new UserIdentity(Username, Password);
}
// create worker session
if (reverseConnectManager_ == null)
{
session_ = await CreateSessionAsync(config, selectedEndpoint, userIdentity).ConfigureAwait(false);
}
else
{
Console.WriteLine(" Waiting for reverse connection.");
// Define the cancellation token.
var source = new CancellationTokenSource(60000);
var token = source.Token;
try
{
var connection = await reverseConnectManager_.WaitForConnection(
new Uri(endpointUrl_), null, token);
if (connection == null)
{
throw new ServiceResultException(StatusCodes.BadTimeout,
"Waiting for a reverse connection timed out.");
}
session_ = await CreateSessionAsync(config, connection, selectedEndpoint, userIdentity)
.ConfigureAwait(false);
}
finally
{
source.Dispose();
}
}
// register keep alive handler
session_.SessionKeepAliveEvent += OnSessionKeepAliveEvent;
#endregion
#region Browse the OPC UA Server
Console.WriteLine(" 4 - Browse address space.");
// Create the browser
var browser = new Browser(session_)
{
BrowseDirection = BrowseDirection.Forward,
ReferenceTypeId = ReferenceTypeIds.HierarchicalReferences,
IncludeSubtypes = true,
NodeClassMask = 0,
ContinueUntilDone = false
};
// Browse from the RootFolder
var references = browser.Browse(Objects.ObjectsFolder);
GetElements(session_, browser, 0, references, Verbose);
#endregion
#region Read a single value
Console.WriteLine(" 5 - Read a single value.");
var simulatedDataValue = session_.ReadValue(simulatedDataNodeId_);
Console.WriteLine("Node Value:" + simulatedDataValue.Value);
#endregion
#region Read multiple values
Console.WriteLine(" 6 - Read multiple values.");
// The input parameters of the ReadValues() method
var variableIds = new List <NodeId>();
var expectedTypes = new List <Type>();
// Add a node to the list
variableIds.Add(simulatedDataNodeId_);
// Add an expected type to the list (null means we get the original type from the server)
expectedTypes.Add(null);
// Add another node to the list
variableIds.Add(staticDataNodeId1_);
// Add an expected type to the list (null means we get the original type from the server)
expectedTypes.Add(null);
// Add another node to the list
variableIds.Add(staticDataNodeId2_);
// Add an expected type to the list (null means we get the original type from the server)
expectedTypes.Add(null);
session_.ReadValues(variableIds, expectedTypes, out var values, out var errors);
// write the result to the console.
for (var i = 0; i < values.Count; i++)
{
Console.WriteLine("Status of Read of Node {0} is: {1}", variableIds[i].ToString(), errors[i]);
}
for (var i = 0; i < values.Count; i++)
{
Console.WriteLine("Value of Read of Node {0} is: Value: {1}", variableIds[i].ToString(), values[i]);
}
#endregion
#region Read multiple values asynchronous
Console.WriteLine(" 7 - Read multiple values asynchronous.");
// start reading the value (setting a 10 second timeout).
session_.BeginReadValues(
variableIds,
0,
TimestampsToReturn.Both,
OnReadComplete,
new UserData {
Session = session_, NodeIds = variableIds
});
#endregion
#region Write a value
Console.WriteLine(" 8 - Write a value.");
short writeInt = 1234;
Console.WriteLine("Write Value: " + writeInt);
session_.WriteValue(staticDataNodeId1_, new DataValue(writeInt));
// read it again to check the new value
Console.WriteLine("Node Value (should be {0}): {1}", session_.ReadValue(staticDataNodeId1_).Value, writeInt);
#endregion
#region Write multiple values at once
Console.WriteLine(" 9 - Write multiple values at once.");
writeInt = 5678;
var writeDouble = 1234.1234;
var nodeIds = new List <NodeId>();
var dataValues = new List <DataValue>();
nodeIds.Add(staticDataNodeId1_);
nodeIds.Add(staticDataNodeId2_);
dataValues.Add(new DataValue(writeInt));
dataValues.Add(new DataValue(writeDouble));
Console.WriteLine("Write Values: {0} and {1}", writeInt, writeDouble);
var statusCodes = session_.WriteValues(nodeIds, dataValues);
Console.WriteLine("Returned status codes:");
foreach (var statusCode in statusCodes)
{
Console.WriteLine("Status: {0}", statusCode.ToString());
}
// read it again to check the new value
Console.WriteLine("Node Value (should be {0}): {1}", session_.ReadValue(staticDataNodeId1_).Value, writeInt);
Console.WriteLine("Node Value (should be {0}): {1}", session_.ReadValue(staticDataNodeId2_).Value, writeDouble);
#endregion
#region Write multiple values asynchronous
Console.WriteLine("10 - Write multiple values asynchronous.");
// start writing the values.
session_.BeginWriteValues(
nodeIds,
dataValues,
OnWriteComplete,
new UserData {
Session = session_, NodeIds = nodeIds
});
#endregion
#region Call a Method
Console.WriteLine("11 - Call a Method.");
INode node = session_.ReadNode(callHelloMethodNodeId_);
if (node is MethodNode)
{
var methodId = callHelloMethodNodeId_;
var objectId = methodsNodeId_;
var inputArguments = new VariantCollection {
new Variant("from Technosoftware")
};
var request = new CallMethodRequest {
ObjectId = objectId, MethodId = methodId, InputArguments = inputArguments
};
var requests = new CallMethodRequestCollection {
request
};
var responseHeader = session_.Call(
null,
requests,
out var results,
out var diagnosticInfos);
if (StatusCode.IsBad(results[0].StatusCode))
{
throw new ServiceResultException(new ServiceResult(results[0].StatusCode, 0, diagnosticInfos,
responseHeader.StringTable));
}
Console.WriteLine("{0}", results[0].OutputArguments[0]);
}
#endregion
#region Create a subscription with publishing interval of 1 second
Console.WriteLine("12 - Create a subscription with publishing interval of 1 second.");
ExitCode = ExitCode.ErrorCreateSubscription;
subscription_ = new Subscription(session_.DefaultSubscription)
{
PublishingInterval = 1000
};
#endregion
#region Add all dynamic values and the server time to the subscription
Console.WriteLine("13 - Add all dynamic values and the server time to the subscription.");
ExitCode = ExitCode.ErrorMonitoredItem;
var list = new List <MonitoredItem> {
new MonitoredItem(subscription_.DefaultItem)
{
DisplayName = "ServerStatusCurrentTime", StartNodeId = "i=" + Variables.Server_ServerStatus_CurrentTime
}
};
list.ForEach(i => i.MonitoredItemNotificationEvent += OnNotification);
var newItem = new MonitoredItem(subscription_.DefaultItem)
{
DisplayName = "Simulated Data Value",
StartNodeId = new NodeId(simulatedDataNodeId_)
};
newItem.MonitoredItemNotificationEvent += OnMonitoredItemNotificationEvent;
list.Add(newItem);
subscription_.AddItems(list);
#endregion
#region Add the subscription to the session
Console.WriteLine("14 - Add the subscription to the session.");
ExitCode = ExitCode.ErrorAddSubscription;
session_.AddSubscription(subscription_);
subscription_.Create();
#endregion
#region Running...Press Ctrl-C to exit...
Console.WriteLine("15 - Running...Press Ctrl-C to exit...");
ExitCode = ExitCode.ErrorRunning;
#endregion
return(session_);
}
public Session(
OperationContext context,
IServerInternal server,
X509Certificate2 serverCertificate,
NodeId authenticationToken,
byte[] serverNonce,
string sessionName,
ApplicationDescription clientDescription,
string endpointUrl,
X509Certificate2 clientCertificate,
double sessionTimeout,
uint maxResponseMessageSize,
double maxRequestAge,
int maxBrowseContinuationPoints,
int maxHistoryContinuationPoints)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
if (server == null)
{
throw new ArgumentNullException("server");
}
// verify that a secure channel was specified.
if (context.ChannelContext == null)
{
throw new ServiceResultException(StatusCodes.BadSecureChannelIdInvalid);
}
m_server = server;
m_authenticationToken = authenticationToken;
m_serverNonce = serverNonce;
m_sessionName = sessionName;
m_serverCertificate = serverCertificate;
m_clientCertificate = clientCertificate;
m_secureChannelId = context.ChannelContext.SecureChannelId;
m_maxResponseMessageSize = maxResponseMessageSize;
m_maxRequestAge = maxRequestAge;
m_maxBrowseContinuationPoints = maxBrowseContinuationPoints;
m_maxHistoryContinuationPoints = maxHistoryContinuationPoints;
m_endpoint = context.ChannelContext.EndpointDescription;
// use anonymous the default identity.
m_identity = new UserIdentity();
// initialize diagnostics.
m_diagnostics = new SessionDiagnosticsDataType();
m_diagnostics.SessionId = null;
m_diagnostics.SessionName = sessionName;
m_diagnostics.ClientDescription = clientDescription;
m_diagnostics.ServerUri = null;
m_diagnostics.EndpointUrl = endpointUrl;
m_diagnostics.LocaleIds = new StringCollection();
m_diagnostics.ActualSessionTimeout = sessionTimeout;
m_diagnostics.ClientConnectionTime = DateTime.UtcNow;
m_diagnostics.ClientLastContactTime = DateTime.UtcNow;
m_diagnostics.CurrentSubscriptionsCount = 0;
m_diagnostics.CurrentMonitoredItemsCount = 0;
m_diagnostics.CurrentPublishRequestsInQueue = 0;
m_diagnostics.TotalRequestCount = new ServiceCounterDataType();
m_diagnostics.UnauthorizedRequestCount = 0;
m_diagnostics.ReadCount = new ServiceCounterDataType();
m_diagnostics.HistoryReadCount = new ServiceCounterDataType();
m_diagnostics.WriteCount = new ServiceCounterDataType();
m_diagnostics.HistoryUpdateCount = new ServiceCounterDataType();
m_diagnostics.CallCount = new ServiceCounterDataType();
m_diagnostics.CreateMonitoredItemsCount = new ServiceCounterDataType();
m_diagnostics.ModifyMonitoredItemsCount = new ServiceCounterDataType();
m_diagnostics.SetMonitoringModeCount = new ServiceCounterDataType();
m_diagnostics.SetTriggeringCount = new ServiceCounterDataType();
m_diagnostics.DeleteMonitoredItemsCount = new ServiceCounterDataType();
m_diagnostics.CreateSubscriptionCount = new ServiceCounterDataType();
m_diagnostics.ModifySubscriptionCount = new ServiceCounterDataType();
m_diagnostics.SetPublishingModeCount = new ServiceCounterDataType();
m_diagnostics.PublishCount = new ServiceCounterDataType();
m_diagnostics.RepublishCount = new ServiceCounterDataType();
m_diagnostics.TransferSubscriptionsCount = new ServiceCounterDataType();
m_diagnostics.DeleteSubscriptionsCount = new ServiceCounterDataType();
m_diagnostics.AddNodesCount = new ServiceCounterDataType();
m_diagnostics.AddReferencesCount = new ServiceCounterDataType();
m_diagnostics.DeleteNodesCount = new ServiceCounterDataType();
m_diagnostics.DeleteReferencesCount = new ServiceCounterDataType();
m_diagnostics.BrowseCount = new ServiceCounterDataType();
m_diagnostics.BrowseNextCount = new ServiceCounterDataType();
m_diagnostics.TranslateBrowsePathsToNodeIdsCount = new ServiceCounterDataType();
m_diagnostics.QueryFirstCount = new ServiceCounterDataType();
m_diagnostics.QueryNextCount = new ServiceCounterDataType();
m_diagnostics.RegisterNodesCount = new ServiceCounterDataType();
m_diagnostics.UnregisterNodesCount = new ServiceCounterDataType();
// initialize security diagnostics.
m_securityDiagnostics = new SessionSecurityDiagnosticsDataType();
m_securityDiagnostics.SessionId = m_sessionId;
m_securityDiagnostics.ClientUserIdOfSession = m_identity.DisplayName;
m_securityDiagnostics.AuthenticationMechanism = m_identity.TokenType.ToString();
m_securityDiagnostics.Encoding = context.ChannelContext.MessageEncoding.ToString();
m_securityDiagnostics.ClientUserIdHistory = new StringCollection();
m_securityDiagnostics.ClientUserIdHistory.Add(m_identity.DisplayName);
EndpointDescription description = context.ChannelContext.EndpointDescription;
if (description != null)
{
m_securityDiagnostics.TransportProtocol = new Uri(description.EndpointUrl).Scheme;
m_securityDiagnostics.SecurityMode = m_endpoint.SecurityMode;
m_securityDiagnostics.SecurityPolicyUri = m_endpoint.SecurityPolicyUri;
}
if (clientCertificate != null)
{
m_securityDiagnostics.ClientCertificate = clientCertificate.RawData;
}
ServerSystemContext systemContext = m_server.DefaultSystemContext.Copy(context);
// create diagnostics object.
m_sessionId = server.DiagnosticsNodeManager.CreateSessionDiagnostics(
systemContext,
m_diagnostics,
OnUpdateDiagnostics,
m_securityDiagnostics,
OnUpdateSecurityDiagnostics);
// report the audit event.
ReportAuditCreateSessionEvent(systemContext);
TraceState("CREATED");
}
public async Task <IndividualUserIdentityResponse> UpdateUserIdentityAsync(long userId, UserIdentity identity)
{
var body = new { identity };
return(await GenericPostAsync <IndividualUserIdentityResponse>($"users/{userId}/identities.json", body));
}
/// <summary>
/// Activates an existing session
/// </summary>
public virtual bool ActivateSession(
OperationContext context,
NodeId authenticationToken,
SignatureData clientSignature,
List <SoftwareCertificate> clientSoftwareCertificates,
ExtensionObject userIdentityToken,
SignatureData userTokenSignature,
StringCollection localeIds,
out byte[] serverNonce)
{
serverNonce = null;
Session session = null;
UserIdentityToken newIdentity = null;
UserTokenPolicy userTokenPolicy = null;
lock (m_lock)
{
// find session.
if (!m_sessions.TryGetValue(authenticationToken, out session))
{
throw new ServiceResultException(StatusCodes.BadSessionClosed);
}
// create new server nonce.
serverNonce = new byte[m_minNonceLength];
IBuffer buffer = CryptographicBuffer.GenerateRandom((uint)m_minNonceLength);
CryptographicBuffer.CopyToByteArray(buffer, out serverNonce);
// validate before activation.
session.ValidateBeforeActivate(
context,
clientSignature,
clientSoftwareCertificates,
userIdentityToken,
userTokenSignature,
localeIds,
serverNonce,
out newIdentity,
out userTokenPolicy);
}
IUserIdentity identity = null;
IUserIdentity effectiveIdentity = null;
ServiceResult error = null;
try
{
// check if the application has a callback which validates the identity tokens.
lock (m_eventLock)
{
if (m_ImpersonateUser != null)
{
ImpersonateEventArgs args = new ImpersonateEventArgs(newIdentity, userTokenPolicy);
m_ImpersonateUser(session, args);
if (ServiceResult.IsBad(args.IdentityValidationError))
{
error = args.IdentityValidationError;
}
else
{
identity = args.Identity;
effectiveIdentity = args.EffectiveIdentity;
}
}
}
// parse the token manually if the identity is not provided.
if (identity == null)
{
identity = new UserIdentity(newIdentity);
}
// use the identity as the effectiveIdentity if not provided.
if (effectiveIdentity == null)
{
effectiveIdentity = identity;
}
}
catch (Exception e)
{
if (e is ServiceResultException)
{
throw;
}
throw ServiceResultException.Create(
StatusCodes.BadIdentityTokenInvalid,
e,
"Could not validate user identity token: {0}",
newIdentity);
}
// check for validation error.
if (ServiceResult.IsBad(error))
{
throw new ServiceResultException(error);
}
// activate session.
bool contextChanged = session.Activate(
context,
clientSoftwareCertificates,
newIdentity,
identity,
effectiveIdentity,
localeIds,
serverNonce);
// raise session related event.
if (contextChanged)
{
RaiseSessionEvent(session, SessionEventReason.Activated);
}
// indicates that the identity context for the session has changed.
return(contextChanged);
}
public Task <IdentityResult> CreateUserAsync(UserIdentity user)
{
return(_userManager.CreateAsync(user));
}
private SecurityPrincipal(Dictionary<string,bool> securityPermissions, Dictionary<int,string> securityGroups, string username)
{
this._securityPermissions = securityPermissions;
this._securityGroups = securityGroups;
this._identity = UserIdentity.CreateUserIdentity(username);
}
public Task <IPhilatelicCollection> GetCollectionAsync(UserIdentity collector, Guid id)
{
// collector not needed here - given how data are organised in memeory
return(Task.Run(() => InMemoryStore.PhilatelicCollections[id]));
}
public Task <IEnumerable <ICollectableCollection> > GetCollectionNamesAsync(UserIdentity collectorId)
{
return(Task.Run(() => InMemoryStore.CollectorColletions[collectorId.Id]
.Select(id => InMemoryStore.PhilatelicCollections[id]) as IEnumerable <ICollectableCollection>));
}
public IndividualUserIdentityResponse UpdateUserIdentity(long userId, UserIdentity identity)
{
var body = new { identity };
return(GenericPost <IndividualUserIdentityResponse>(string.Format("users/{0}/identities.json", userId), body));
}
public static UserIdentity MapTo(this UserIdentity user, UserIdentity newUser)
{
return(Mapper.Map(newUser, user));
}
public UserIdentity GetIdentity(int customerID)
{
dynamic identity = null;
using (var context = ExigoDAL.Sql())
{
try
{
identity = context.Query <UserIdentity>(@"
SELECT
c.CustomerID
, c.FirstName
, c.LastName
, c.Company
, c.LoginName
, c.CustomerTypeID
, c.CustomerStatusID
, c.LanguageID
, c.DefaultWarehouseID
, c.CurrencyCode
, c.MainCountry AS 'Country'
FROM Customers c
WHERE c.CustomerID = @customerid
AND c.CanLogin = 1 -- Ensure that the Customer is allowed to Log in
", new
{
customerid = customerID
}).FirstOrDefault();
// Use the web service as a backup
if (identity == null)
{
var customer = ExigoDAL.WebService().GetCustomers(new GetCustomersRequest()
{
CustomerID = customerID
}).Customers.FirstOrDefault();
if (customer != null)
{
identity = new UserIdentity()
{
CustomerID = customer.CustomerID,
FirstName = customer.FirstName,
LastName = customer.LastName,
Company = customer.Company,
LoginName = customer.LoginName,
CustomerTypeID = customer.CustomerType,
CustomerStatusID = customer.CustomerStatus,
LanguageID = customer.LanguageID,
DefaultWarehouseID = customer.DefaultWarehouseID = (customer.DefaultWarehouseID > 0) ? customer.DefaultWarehouseID : Warehouses.Default,
CurrencyCode = customer.CurrencyCode,
Country = customer.MainCountry
};
}
}
}
catch (Exception ex)
{
Log.Error(ex, "Error Getting Identity: {Message}", ex.Message);
return(null);
}
}
return(identity);
}
public Task <UserIdentity> GetUserAsync(UserIdentity user)
{
return(_userManager.FindByIdAsync(user.Id.ToString()));
}
public IndividualUserIdentityResponse UpdateUserIdentity(long userId, UserIdentity identity)
{
var body = new { identity };
return(GenericPost <IndividualUserIdentityResponse>($"users/{userId}/identities.json", body));
}
public UserPrincipal(UserIdentity identity) : base(identity, identity.Roles)
{
}
internal static void RegisterReactionWait(TaskCompletionSource <string> completionSource, string[] option, ulong messageId, UserIdentity userId)
{
ReactionWaits.Add(new ReactionWait(completionSource, option, messageId, userId));
}
public void Setup()
{
Logger = new Mock <ILogger>();
PaperPusherClientMock = new Mock <IPaperpusherClient>();
CostBuilderMock = new Mock <ICostBuilder>();
PgUserServiceMock = new Mock <IPgUserService>();
EventService = new Mock <IEventService>();
PermissionService = new Mock <IPermissionService>();
SearchServiceMock = new Mock <IElasticSearchService>();
ActionBuilderMock = new Mock <IActionBuilder>();
ModuleService = new Mock <IModuleService>();
ActionBuilders = new[]
{
new Lazy <IActionBuilder, PluginMetadata>(
() => ActionBuilderMock.Object, new PluginMetadata {
BuType = BuType.Pg
})
};
UserServices = new EditableList <Lazy <IPgUserService, PluginMetadata> >
{
new Lazy <IPgUserService, PluginMetadata>(
() => PgUserServiceMock.Object, new PluginMetadata {
BuType = BuType.Pg
})
};
var costApprovalServiceMock = new Mock <ICostApprovalService>();
Mapper = new Mock <IMapper>();
ActivityLogServiceMock = new Mock <IActivityLogService>();
CostBuilders = new EditableList <Lazy <ICostBuilder, PluginMetadata> >
{
new Lazy <ICostBuilder, PluginMetadata>(
() => CostBuilderMock.Object, new PluginMetadata {
BuType = BuType.Pg
})
};
PostProcessorMock = new Mock <IActionPostProcessor>();
PostProcessors = new EditableList <Lazy <IActionPostProcessor, PluginMetadata> >
{
new Lazy <IActionPostProcessor, PluginMetadata>(
() => PostProcessorMock.Object, new PluginMetadata {
BuType = BuType.Pg
})
};
User = new UserIdentity
{
Email = "UserName",
AgencyId = Guid.NewGuid(),
BuType = BuType.Pg,
Id = Guid.NewGuid()
};
CostStageRevisionPermissionServiceMock = new Mock <ICostStageRevisionPermissionService>();
SupportNotificationServiceMock = new Mock <ISupportNotificationService>();
EFContext = EFContextFactory.CreateInMemoryEFContext();
CostService = new CostService(
CostBuilders,
UserServices,
EventService.Object,
PermissionService.Object,
PaperPusherClientMock.Object,
Logger.Object,
SearchServiceMock.Object,
EFContext,
ActionBuilders,
costApprovalServiceMock.Object,
Mapper.Object,
ActivityLogServiceMock.Object,
PostProcessors,
CostStageRevisionPermissionServiceMock.Object,
SupportNotificationServiceMock.Object,
ModuleService.Object
);
}
/// <summary>
/// Erstellt eine Session mit den Informationen des Konstruktors.
/// Es ist nur eine Session pro Server zulässig.
/// </summary>
/// <returns></returns>
private async Task CreateSessionAsync()
{
if (m_Session == null)
{
// Die Konfiguration für die Client/Server Beziehung wird erstellt.
m_Config = new ApplicationConfiguration()
{
ApplicationName = "UARC-Collector",
ApplicationType = ApplicationType.Client,
// ApplicationUri definiert den Namespace (Gültigkeitsbereich) des Zertifikats.
// Dieser Syntax muss für eine hohe Kompatibilität beibehalten werden.
ApplicationUri = "urn:" + Utils.GetHostName(),
SecurityConfiguration = new SecurityConfiguration
{
ApplicationCertificate = new CertificateIdentifier
{
StoreType = CertificateStoreType.X509Store,
StorePath = "CurrentUser\\My",
SubjectName = "UARC-Collector"
},
TrustedPeerCertificates = new CertificateTrustList
{
StoreType = "Directory",
StorePath = Path.Combine(Directory.GetCurrentDirectory(), "wwwroot", "OPC Foundation/CertificateStores/UA Applications"),
},
TrustedIssuerCertificates = new CertificateTrustList
{
StoreType = "Directory",
StorePath = Path.Combine(Directory.GetCurrentDirectory(), "wwwroot", "OPC Foundation/CertificateStores/UA Certificate Authorities"),
},
RejectedCertificateStore = new CertificateTrustList
{
StoreType = "Directory",
StorePath = Path.Combine(Directory.GetCurrentDirectory(), "wwwroot", "OPC Foundation/CertificateStores/RejectedCertificates"),
},
NonceLength = 32,
AutoAcceptUntrustedCertificates = autoAccept
},
TransportConfigurations = new TransportConfigurationCollection(),
TransportQuotas = new TransportQuotas {
OperationTimeout = 15000
},
ClientConfiguration = new ClientConfiguration {
DefaultSessionTimeout = TimeOut
}
};
// Die Konfiguration wird überprüft.
await m_Config.Validate(ApplicationType.Client);
// Wenn kein Zertifikat vorhanden ist, ist das Bool "haveAppCertificate" false.
bool haveAppCertificate = m_Config.SecurityConfiguration.ApplicationCertificate.Certificate != null;
// Wenn kein Zertifikat vorhanden ist, wird eine selbstsigniertes Zertifikat erzeugt.
if (!haveAppCertificate)
{
#region Varibalen zur Zertifikats erstellung
string storeType = m_Config.SecurityConfiguration.ApplicationCertificate.StoreType;
string storePath = m_Config.SecurityConfiguration.ApplicationCertificate.StorePath;
string password = null;
string applicationUri = m_Config.ApplicationUri;
string applicationName = m_Config.ApplicationName;
string subjectName = m_Config.SecurityConfiguration.ApplicationCertificate.SubjectName;
IList <String> domainNames = null; //GetLocalIpAddressAndDns(), von UAClient Helper API
ushort keySize = CertificateFactory.defaultKeySize; //must be multiples of 1024 (Beispiel 2048),
DateTime startTime = System.DateTime.Now;
ushort lifetimeInMonths = CertificateFactory.defaultLifeTime; //in month (Beispiel 24)
ushort hashSizeInBits = CertificateFactory.defaultHashSize; //(Beispiel 128)
bool isCA = false;
X509Certificate2 issuerCAKeyCert = null;
byte[] publicKey = null;
#endregion
X509Certificate2 certificate = CertificateFactory.CreateCertificate
(
storeType,
storePath,
password,
applicationUri,
applicationName,
subjectName,
domainNames,
keySize,
startTime,
lifetimeInMonths,
hashSizeInBits,
isCA,
issuerCAKeyCert,
publicKey
);
certificate.Verify();
m_Config.SecurityConfiguration.ApplicationCertificate.Certificate = certificate;
}
// "haveAppCertificate" wird neu beschrieben.
haveAppCertificate = (m_Config.SecurityConfiguration.ApplicationCertificate.Certificate != null);
if (haveAppCertificate)
{
//m_config.ApplicationUri = Utils.GetApplicationUriFromCertificate(m_config.SecurityConfiguration.ApplicationCertificate.Certificate);
if (m_Config.SecurityConfiguration.AutoAcceptUntrustedCertificates)
{
m_Config.CertificateValidator.CertificateValidation += CertificateValidator_CertificateValidation;
}
}
// Der passende Enpoint wird ausgewählt.
var selectedEndpoint = CoreClientUtils.SelectEndpoint(EndpointUrl, haveAppCertificate, 15000);
// EndpointConfiguration wiird erstellt.
var endpointConfiguration = EndpointConfiguration.Create(m_Config);
// Enpoint für Client wird erstellt.
var endpoint = new ConfiguredEndpoint(null, selectedEndpoint, endpointConfiguration);
// UserIdentity wird erstellt.
UserIdentity userIdentity = null;
if ((Username != null && Username != "") && (Password != null && Password != ""))
{
userIdentity = new UserIdentity(Username, Password);
}
else
{
userIdentity = new UserIdentity(); // --> AnonymousIdentityToken
}
// Session wird erstellt.
try
{
m_Session = await Session.Create(m_Config, endpoint, true, true, "Session_" + ServerLabel, 60000, userIdentity, null);
}
catch (Exception e)
{
if (e.Message == null)
{
e = new Exception(String.Format("Session {0} konnte nicht erfolgreich erstellt werden.", ServerLabel));
throw e;
}
else
{
throw e;
}
}
// KeepAliveHandler wird hinzugefügt.
m_Session.KeepAlive += Client_KeepAlive;
// Default Subscription null setzen, um Fehler zu verhindern
m_Session.DefaultSubscription = null;
}
else
{
throw new Exception("Eine Session ist bereits vorhanden");
}
}
/// <summary>
/// Connects to the OPC server asynchronously.
/// </summary>
public async Task <bool> ConnectAsync(OpcConnectionOptions connectionOptions, int operationTimeout = -1)
{
ApplicationInstance application = new ApplicationInstance
{
ApplicationName = string.Format("DrvOpcUa_{0} Driver", deviceNumStr),
ApplicationType = ApplicationType.Client,
ConfigSectionName = "Scada.Comm.Drivers.DrvOpcUa"
};
// load the application configuration
// TODO: use stream instead of file after updating OPCFoundation.NetStandard.Opc.Ua
WriteConfigFile(out string configFileName);
ApplicationConfiguration config = await application.LoadApplicationConfiguration(configFileName, false);
// check the application certificate
bool haveAppCertificate = await application.CheckApplicationInstanceCertificate(false, 0);
if (!haveAppCertificate)
{
throw new ScadaException(Locale.IsRussian ?
"Сертификат экземпляра приложения недействителен!" :
"Application instance certificate invalid!");
}
if (haveAppCertificate)
{
config.ApplicationUri = X509Utils.GetApplicationUriFromCertificate(
config.SecurityConfiguration.ApplicationCertificate.Certificate);
if (config.SecurityConfiguration.AutoAcceptUntrustedCertificates)
{
AutoAccept = true;
}
config.CertificateValidator.CertificateValidation += CertificateValidator_CertificateValidation;
}
else
{
log.WriteLine(Locale.IsRussian ?
"Предупреждение: отсутствует сертификат приложения, используется незащищенное соединение." :
"Warning: missing application certificate, using unsecure connection.");
}
// create session
EndpointDescription selectedEndpoint = operationTimeout > 0
? CoreClientUtils.SelectEndpoint(connectionOptions.ServerUrl, haveAppCertificate, operationTimeout)
: CoreClientUtils.SelectEndpoint(connectionOptions.ServerUrl, haveAppCertificate);
selectedEndpoint.SecurityMode = connectionOptions.SecurityMode;
selectedEndpoint.SecurityPolicyUri = connectionOptions.GetSecurityPolicy();
EndpointConfiguration endpointConfiguration = EndpointConfiguration.Create(config);
ConfiguredEndpoint endpoint = new ConfiguredEndpoint(null, selectedEndpoint, endpointConfiguration);
UserIdentity userIdentity = connectionOptions.AuthenticationMode == AuthenticationMode.Username ?
new UserIdentity(connectionOptions.Username, connectionOptions.Password) :
new UserIdentity(new AnonymousIdentityToken());
OpcSession = await Session.Create(config, endpoint, false,
"Rapid SCADA DrvOpcUa_" + deviceNumStr,
(uint)config.ClientConfiguration.DefaultSessionTimeout, userIdentity, null);
log.WriteLine(Locale.IsRussian ?
"OPC сессия успешно создана: {0}" :
"OPC session created successfully: {0}", connectionOptions.ServerUrl);
return(true);
}
//public LockStatus GetLockStatus(ObjectKey objectKey, out UserIdentity owner)
//{
// return _lockingStorage.GetLockStatus(objectKey, out owner);
//}
public bool ReleaseLock(UserIdentity user, ObjectKey objectKey)
{
return _lockingStorage.ReleaseLock(user, objectKey);
}
private void SetupUserIdentity()
{
userIdentity = new UserIdentity("GRS", 1, 1, "john.doe", "corporate.net", "ONEDEV", DateTime.Now, true, "", false, null, null, null);
userManager.Setup(p => p.UserIdentity).Returns(userIdentity);
}
public void UpdateUser(UserIdentity userIdentity)
{
throw new NotImplementedException();
}
/// <summary>
/// Configure <see cref="KubeClientOptions"/> from the settings specified in the <see cref="K8sConfig"/>.
/// </summary>
/// <param name="kubeClientOptions">
///
/// </param>
/// <param name="kubeContextName">
/// The name of the Kubernetes context to use.
///
/// If not specified, then the current context (as configured) will be used.
/// </param>
/// <param name="defaultKubeNamespace">
/// The default Kubernetes namespace to use.
/// </param>
/// <returns>
/// The configured <see cref="KubeClientOptions"/>.
/// </returns>
public KubeClientOptions ConfigureKubeClientOptions(KubeClientOptions kubeClientOptions, string kubeContextName = null, string defaultKubeNamespace = null)
{
if (kubeClientOptions == null)
{
throw new ArgumentNullException(nameof(kubeClientOptions));
}
string targetContextName = kubeContextName ?? CurrentContextName;
if (String.IsNullOrWhiteSpace(targetContextName))
{
throw new InvalidOperationException("The kubeContextName parameter was not specified, and the Kubernetes client configuration does not specify a current context.");
}
Context targetContext = Contexts.Find(context => context.Name == targetContextName);
if (targetContext == null)
{
throw new InvalidOperationException($"Cannot find a context in the Kubernetes client configuration named '{targetContextName}'.");
}
Cluster targetCluster = Clusters.Find(cluster => cluster.Name == targetContext.Config.ClusterName);
if (targetCluster == null)
{
throw new InvalidOperationException($"Cannot find a cluster in the Kubernetes client configuration named '{targetContext.Config.ClusterName}'.");
}
UserIdentity targetUser = UserIdentities.Find(user => user.Name == targetContext.Config.UserName);
if (targetUser == null)
{
throw new InvalidOperationException($"Cannot find a user identity in the Kubernetes client configuration named '{targetContext.Config.UserName}'.");
}
kubeClientOptions.ApiEndPoint = new Uri(targetCluster.Config.Server);
kubeClientOptions.KubeNamespace = defaultKubeNamespace;
kubeClientOptions.ClientCertificate = targetUser.Config.GetClientCertificate();
kubeClientOptions.AllowInsecure = targetCluster.Config.AllowInsecure;
kubeClientOptions.CertificationAuthorityCertificate = targetCluster.Config.GetCACertificate();
// Mixed authentication types are not supported.
if (kubeClientOptions.ClientCertificate == null)
{
string accessToken = targetUser.Config.GetRawToken();
if (!String.IsNullOrWhiteSpace(accessToken))
{
kubeClientOptions.AccessToken = accessToken;
kubeClientOptions.AuthStrategy = KubeAuthStrategy.BearerToken;
}
else
{
kubeClientOptions.AuthStrategy = KubeAuthStrategy.None;
}
AuthProviderConfig authProvider = targetUser.Config.AuthProvider;
if (authProvider != null)
{
kubeClientOptions.AuthStrategy = KubeAuthStrategy.BearerTokenProvider;
if (authProvider.Config.TryGetValue("cmd-path", out object accessTokenCommand))
{
kubeClientOptions.AccessTokenCommand = (string)accessTokenCommand;
}
if (authProvider.Config.TryGetValue("cmd-args", out object accessTokenCommandArguments))
{
kubeClientOptions.AccessTokenCommandArguments = (string)accessTokenCommandArguments;
}
if (authProvider.Config.TryGetValue("token-key", out object accessTokenSelector))
{
kubeClientOptions.AccessTokenSelector = (string)accessTokenSelector;
}
if (authProvider.Config.TryGetValue("expiry-key", out object accessTokenExpirySelector))
{
kubeClientOptions.AccessTokenExpirySelector = (string)accessTokenExpirySelector;
}
if (authProvider.Config.TryGetValue("access-token", out object initialAccessToken))
{
kubeClientOptions.InitialAccessToken = (string)initialAccessToken;
}
if (authProvider.Config.TryGetValue("expiry", out object initialTokenExpiry))
{
kubeClientOptions.InitialTokenExpiryUtc = DateTime.Parse((string)initialTokenExpiry,
provider: CultureInfo.InvariantCulture,
styles: DateTimeStyles.AssumeUniversal
);
}
}
}
else
{
kubeClientOptions.AuthStrategy = KubeAuthStrategy.ClientCertificate;
}
return(kubeClientOptions);
}
private string GetSessionKey(UserIdentity userIdentity) => $"user-{userIdentity.UserId}";
protected override FilesGroup InitDownload(UserIdentity userIdentity, FilesGroup resource)
{
return _presentationTransfer.InitPresentationExport(userIdentity, resource);
}
private async Task <UserIdentity> AutoProvisionUserAsync(string provider, string providerUserId, IEnumerable <Claim> claims)
{
// create a list of claims that we want to transfer into our store
var filtered = new List <Claim>();
// user's display name
var name = claims.FirstOrDefault(x => x.Type == JwtClaimTypes.Name)?.Value ??
claims.FirstOrDefault(x => x.Type == ClaimTypes.Name)?.Value;
if (name != null)
{
filtered.Add(new Claim(JwtClaimTypes.Name, name));
}
else
{
var first = claims.FirstOrDefault(x => x.Type == JwtClaimTypes.GivenName)?.Value ??
claims.FirstOrDefault(x => x.Type == ClaimTypes.GivenName)?.Value;
var last = claims.FirstOrDefault(x => x.Type == JwtClaimTypes.FamilyName)?.Value ??
claims.FirstOrDefault(x => x.Type == ClaimTypes.Surname)?.Value;
if (first != null && last != null)
{
filtered.Add(new Claim(JwtClaimTypes.Name, first + " " + last));
}
else if (first != null)
{
filtered.Add(new Claim(JwtClaimTypes.Name, first));
}
else if (last != null)
{
filtered.Add(new Claim(JwtClaimTypes.Name, last));
}
}
// email
var email = claims.FirstOrDefault(x => x.Type == JwtClaimTypes.Email)?.Value ??
claims.FirstOrDefault(x => x.Type == ClaimTypes.Email)?.Value;
if (email != null)
{
filtered.Add(new Claim(JwtClaimTypes.Email, email));
}
var user = new UserIdentity
{
UserName = Guid.NewGuid().ToString(),
};
var identityResult = await _userManager.CreateAsync(user);
if (!identityResult.Succeeded)
{
throw new Exception(identityResult.Errors.First().Description);
}
if (filtered.Any())
{
identityResult = await _userManager.AddClaimsAsync(user, filtered);
if (!identityResult.Succeeded)
{
throw new Exception(identityResult.Errors.First().Description);
}
}
identityResult = await _userManager.AddLoginAsync(user, new UserLoginInfo(provider, providerUserId, provider));
if (!identityResult.Succeeded)
{
throw new Exception(identityResult.Errors.First().Description);
}
return(user);
}
//public IPresentationDAL PresentationDAL{get; set;}
#region ILockService Members
public bool AcquireLock(ICommunicationObject communicationObject, UserIdentity user, ObjectKey objectKey, RequireLock requireLock)
{
return _lockingStorage.AcquireLock(communicationObject, user, objectKey, requireLock);
}
public async Task <IActionResult> ExternalLoginCallback()
{
// read external identity from the temporary cookie
var result = await HttpContext.AuthenticateAsync(IdentityServerConstants.ExternalCookieAuthenticationScheme);
if (result?.Succeeded != true)
{
throw new Exception("External authentication error");
}
// lookup our user and external provider info
var(user, provider, providerUserId, claims) = await FindUserFromExternalProviderAsync(result);
if (user == null)
{
// this might be where you might initiate a custom workflow for user registration
// in this sample we don't show how that would be done, as our sample implementation
// simply auto-provisions new external user
user = await AutoProvisionUserAsync(provider, providerUserId, claims);
if (user == null)
{
return(RedirectToAction("LoginError", "Home", new { Error = string.Join(" ", _notifications.GetNotifications().Select(a => $"{a.Key}: {a.Value}")) }));
}
}
// this allows us to collect any additonal claims or properties
// for the specific prtotocols used and store them in the local auth cookie.
// this is typically used to store data needed for signout from those protocols.
var additionalLocalClaims = new List <Claim>();
var localSignInProps = new AuthenticationProperties();
ProcessLoginCallbackForOidc(result, additionalLocalClaims, localSignInProps);
ProcessLoginCallbackForWsFed(result, additionalLocalClaims, localSignInProps);
ProcessLoginCallbackForSaml2p(result, additionalLocalClaims, localSignInProps);
// issue authentication cookie for user
// we must issue the cookie maually, and can't use the SignInManager because
// it doesn't expose an API to issue additional claims from the login workflow
// I don't have pride of this.
var s = new UserIdentity()
{
Id = user.Id,
Name = user.Name,
SecurityStamp = user.SecurityStamp,
AccessFailedCount = user.AccessFailedCount,
Bio = user.Bio,
Company = user.Company,
Email = user.Email,
EmailConfirmed = user.EmailConfirmed,
JobTitle = user.JobTitle,
LockoutEnabled = user.LockoutEnabled,
LockoutEnd = user.LockoutEnd,
PhoneNumber = user.PhoneNumber,
PhoneNumberConfirmed = user.PhoneNumberConfirmed,
Picture = user.Picture,
TwoFactorEnabled = user.TwoFactorEnabled,
Url = user.Url,
UserName = user.UserName,
};
var principal = await _signInManager.CreateUserPrincipalAsync(s);
additionalLocalClaims.AddRange(principal.Claims);
var name = principal.FindFirst(JwtClaimTypes.Name)?.Value ?? user.Id.ToString();
await _events.RaiseAsync(new UserLoginSuccessEvent(provider, providerUserId, user.Id.ToString(), name));
await HttpContext.SignInAsync(user.Id.ToString(), name, provider, localSignInProps, additionalLocalClaims.ToArray());
// delete temporary cookie used during external authentication
await HttpContext.SignOutAsync(IdentityConstants.ExternalScheme);
// validate return URL and redirect back to authorization endpoint or a local page
var returnUrl = result.Properties.Items["returnUrl"];
// check if external login is in the context of an OIDC request
var context = await _interaction.GetAuthorizationContextAsync(returnUrl);
if (context != null)
{
if (await _clientStore.IsPkceClientAsync(context.ClientId))
{
// if the client is PKCE then we assume it's native, so this change in how to
// return the response is for better UX for the end user.
return(View("Redirect", new RedirectViewModel {
RedirectUrl = returnUrl
}));
}
}
return(Redirect(returnUrl));
}
public async Task <IndividualUserIdentityResponse> AddUserIdentityAsync(long userId, UserIdentity identity)
{
var body = new { identity };
return(await GenericPostAsync <IndividualUserIdentityResponse>(string.Format("users/{0}/identities.json", userId), body));
}
public async Task <IdentityResult> DeleteUserAsync(UserIdentity user)
{
var userIdentity = await _userManager.FindByIdAsync(user.Id.ToString());
return(await _userManager.DeleteAsync(userIdentity));
}
public static UserDto ToModel(this UserIdentity user)
{
return(Mapper.Map <UserDto>(user));
}
/// <summary>
/// Add <see cref="KubeClientOptions"/> from local Kubernetes client configuration.
/// </summary>
/// <param name="services">
/// The service collection to configure.
/// </param>
/// <param name="kubeConfigFileName">
/// The optional name of a specific configuration file to use (defaults to "$HOME/.kube/config").
/// </param>
/// <param name="kubeContextName">
/// The optional name of a specific Kubernetes client context to use.
/// </param>
/// <param name="defaultKubeNamespace">
/// The default namespace to use (if not specified, "default" is used).
/// </param>
/// <returns>
/// The configured service collection.
/// </returns>
public static IServiceCollection AddKubeClientOptionsFromKubeConfig(this IServiceCollection services, string kubeConfigFileName = null, string kubeContextName = null, string defaultKubeNamespace = "default")
{
if (services == null)
{
throw new ArgumentNullException(nameof(services));
}
if (String.IsNullOrWhiteSpace(defaultKubeNamespace))
{
throw new ArgumentException("Argument cannot be null, empty, or entirely composed of whitespace: 'defaultNamespace'.", nameof(defaultKubeNamespace));
}
if (String.IsNullOrWhiteSpace(kubeConfigFileName))
{
kubeConfigFileName = Path.GetFullPath(Path.Combine(
Environment.GetEnvironmentVariable("HOME"),
".kube",
"config"
));
}
FileInfo kubeConfigFile = new FileInfo(kubeConfigFileName);
// IOptions<KubeClientOptions>
services.Configure <KubeClientOptions>(kubeClientOptions =>
{
Config config = Config.Load(kubeConfigFile);
string targetContextName = kubeContextName ?? config.CurrentContextName;
if (String.IsNullOrWhiteSpace(targetContextName))
{
throw new InvalidOperationException("The kubeContextName parameter was not specified, and the Kubernetes client configuration does not specify a current context.");
}
Context targetContext = config.Contexts.Find(context => context.Name == targetContextName);
if (targetContext == null)
{
throw new InvalidOperationException($"Cannot find a context in the Kubernetes client configuration named '{targetContextName}'.");
}
Cluster targetCluster = config.Clusters.Find(cluster => cluster.Name == targetContext.Config.ClusterName);
if (targetCluster == null)
{
throw new InvalidOperationException($"Cannot find a cluster in the Kubernetes client configuration named '{targetContext.Config.ClusterName}'.");
}
UserIdentity targetUser = config.UserIdentities.Find(user => user.Name == targetContext.Config.UserName);
if (targetUser == null)
{
throw new InvalidOperationException($"Cannot find a user identity in the Kubernetes client configuration named '{targetContext.Config.UserName}'.");
}
kubeClientOptions.ApiEndPoint = new Uri(targetCluster.Config.Server);
kubeClientOptions.KubeNamespace = defaultKubeNamespace;
kubeClientOptions.ClientCertificate = targetUser.Config.GetClientCertificate();
kubeClientOptions.CertificationAuthorityCertificate = targetCluster.Config.GetCACertificate();
kubeClientOptions.AccessToken = targetUser.Config.GetRawToken();
});
return(services);
}
