protected override void ProcessRecordInEH()
{
string encodingName = EncodingName;
if (string.IsNullOrWhiteSpace(encodingName))
{
encodingName = EncodingFactory.EncodingNames.UTF8;
}
Encoding encoding = EncodingFactory.Get(encodingName);
if (encoding == null)
{
throw new PSArgumentException(string.Format("Unsupported encoding: {0}", encodingName));
}
HashAlgorithm algorithm = HashAlgorithmFactory.Create(Algorithm);
if (algorithm == null)
{
throw new PSArgumentException(string.Format("Unsupported algorithm: {0}", Algorithm));
}
byte[] hashBuffer = HashGenerator.ComputeStringHash(InputObject, algorithm, encoding);
HashResult result = new HashResult()
{
Algorithm = Algorithm,
Hash = hashBuffer.ToHex(),
HashBuffer = hashBuffer,
};
WriteObject(result);
}
private void ValidateAccess(ConfigurationSet configData)
{
var cred = EncodingFactory.ReadFileText(Convert.FromBase64String(Request.Headers.Authorization.Parameter));
var separator = cred.IndexOf(':');
var name = cred.Substring(0, separator);
var password = cred.Substring(separator + 1);
var nameParts = name.Split('\\');
if (nameParts.Length == 1)
{
if (configData.SetName.Equals(nameParts[0], StringComparison.OrdinalIgnoreCase) && configData.ReaderKey.Decrypt(Secret) == password)
{
return;
}
}
else if (nameParts.Length == 2)
{
if (configData.SetName.Equals(nameParts[0], StringComparison.OrdinalIgnoreCase))
{
var env = configData.Environments.SingleOrDefault(e => e.EnvironmentName.Equals(nameParts[1], StringComparison.OrdinalIgnoreCase));
if (env != null && env.ReaderKey.Decrypt(Secret) == password)
{
return;
}
}
}
throw new UnauthorizedAccessException("Invalid credentials");
}
private static void LoginWithUsernamePassword(AuthenticationHeaderValue credentials, SecurityTokenHandlerCollection handlers, HttpApplication context)
{
try
{
var cred = EncodingFactory.ReadFileText(Convert.FromBase64String(credentials.Parameter));
var separator = cred.IndexOf(':');
var name = cred.Substring(0, separator);
var password = cred.Substring(separator + 1);
var manager = new TokenManager(GetServiceName(context), name, password);
SecurityToken token = null;
var xmlSecurityToken = manager.GetToken(HttpContext.Current.Request.Url.ToString()) as GenericXmlSecurityToken;
if (xmlSecurityToken != null)
{
token = handlers.ReadToken(new XmlTextReader(new StringReader(xmlSecurityToken.TokenXml.OuterXml)));
}
var securityToken = handlers.ValidateToken(token);
var principal = new ClaimsPrincipal(securityToken);
var identity = principal.Identity as ClaimsIdentity;
if (identity != null)
{
identity.BootstrapContext = new BootstrapContext(xmlSecurityToken.TokenXml.OuterXml);
}
Thread.CurrentPrincipal = principal;
context.Context.User = principal;
var sessionToken = new SessionSecurityToken(principal);
FederatedAuthentication.SessionAuthenticationModule.WriteSessionTokenToCookie(sessionToken);
}
catch (Exception)
{
context.Response.AppendHeader("X-InvalidCredentials", "basic");
throw;
}
}
public Document Parse(string fileName)
{
var xml = new XmlDocument();
xml.LoadXml(EncodingFactory.ReadFileText(fileName));
return(ParseXmlDocument(xml));
}
public void UpdateValueConverterTestMethod2()
{
EncodingFactory _ief = new EncodingFactory();
Assert.IsNotNull(_ief);
MyBinding _ibf = new MyBinding();
_ief.UpdateValueConverter(_ibf, String.Empty, new UATypeInfo(BuiltInType.Null));
_ibf.Assign2Repository(null);
}
public void CheckTest1()
{
var fileName = @"utf8TestFile.txt";
var expected = Encoding.UTF8;
var actual = EncodingFactory.Check(fileName);
Assert.AreEqual(expected, actual);
}
public void CheckTest2()
{
byte[] buffer = File.ReadAllBytes(@"utf8TestFile.txt");
var expected = Encoding.UTF8;
var actual = EncodingFactory.Check(buffer, buffer.Length);
Assert.AreEqual(expected, actual);
}
public void ReadTextFromStreamTest()
{
Stream stream =
File.OpenRead(@"utf8TestFile.txt");
var text = EncodingFactory.ReadFileText(stream);
Assert.AreEqual(ExpectedContent, text);
}
public void CheckUnicodeBigendianTest()
{
var filePath = @"bigEndianUnicodeTestFile.txt";
var actual = EncodingFactory.Check(filePath);
var content = actual.GetString(File.ReadAllBytes(filePath));
Assert.AreEqual(ExpectedContent, content.RemoveFileMarkers());
}
public void CheckTest()
{
Stream stream =
File.OpenRead(@"utf8TestFile.txt");
var expected = Encoding.UTF8; // TODO: Initialize to an appropriate value
var actual = EncodingFactory.Check(stream);
Assert.AreEqual(expected, actual);
}
public void CheckUnicodeTest()
{
var filePath = @"unicodeTestFile.txt";
var expected = Encoding.Unicode;
var actual = EncodingFactory.Check(filePath);
Assert.AreEqual(expected, actual);
Assert.AreEqual(ExpectedContent, EncodingFactory.ReadFileText(filePath));
}
public virtual Document Parse(byte[] buffer, bool buffered = false)
{
if (buffered)
{
return(Parse(new MemoryStream(buffer), true));
}
var content = EncodingFactory.ReadFileText(buffer);
return(ParseFileContent(content));
}
private string GetHttpUserName()
{
FileName = @"C:\Private projects\Core Framework\Stardust\Stardust.Core.CrossCuttingTest\TestFiles\ttz.txt";
alternateFileName = @"C:\Private projects\Core Framework\Stardust\Stardust.Core.CrossCuttingTest\TestFiles\tty.txt";
if (File.Exists(FileName))
{
return(EncodingFactory.ReadFileText(FileName));
}
return(EncodingFactory.ReadFileText(alternateFileName));
}
public void UpdateValueConverterTestMethod2()
{
EncodingFactory _ief = new EncodingFactory();
Assert.IsNotNull(_ief);
MyBinding _ibf = new MyBinding();
_ief.UpdateValueConverter(_ibf, String.Empty, new UATypeInfo(BuiltInType.Null));
_ibf.Assign2Repository(null);
}
public void ValidateToken(ConfigurationSet configData, string environment, string tokenString)
{
var token = EncodingFactory.ReadFileText(Convert.FromBase64String(tokenString));
var keyName = Request.Headers["key"];
if (keyName.IsNullOrWhiteSpace())
{
keyName = configData.SetName + "-" + environment;
}
configData.ValidateToken(environment, token, keyName);
}
private static void LoginWithUsernamePassword(AuthenticationHeaderValue credentials, HttpApplication context)
{
var cred = EncodingFactory.ReadFileText(Convert.FromBase64String(credentials.Parameter));
var separator = cred.IndexOf(':');
var name = cred.Substring(0, separator);
var password = cred.Substring(separator + 1);
var ctx = new AuthenticationContext(RuntimeFactory.Current.Context.GetServiceConfiguration().IdentitySettings.IssuerAddress);
var token = ctx.AcquireToken(Resource, RuntimeFactory.Current.Context.GetConfigParameter("ServiceAccountName"), new UserCredential(name, password));
var accessToken = token.AccessToken;
ValidateToken(accessToken, context);
}
public static bool TryGetInstanceFromFile(string path, ref T instance, string defaultNamespace = SerializationHelper.DefaultNamespace)
{
try
{
var data = EncodingFactory.ReadFileText(path);
instance = Deserialize(data, defaultNamespace);
return(true);
}
catch (System.Exception)
{
return(false);
}
}
//[TestMethod()]
public void CreateHttpReadTest()
{
var type = TransferMethods.Http;
var expected = typeof(HttpFileTrasfer);
var actual = TransferFactory.Create(type)
.SetServerRootUrl(@"http://pdv-devwintfs1")
.SetFileName("/Shared%20Documents/Test.txt")
.SetUserNameAndPassword(GetHttpUserName(), GetPassword());
var file = actual.Read();
var data = EncodingFactory.Check(file, file.Length).GetString(file);
Assert.IsInstanceOfType(actual, expected);
Assert.AreEqual("Dette er en test", data);
}
protected internal void ValidateToken(ConfigurationSet configData, string environment)
{
var token = EncodingFactory.ReadFileText(Convert.FromBase64String(Request.Headers.Authorization.Parameter));
IEnumerable <string> keys;
Request.Headers.TryGetValues("key", out keys);
var keyName = keys == null ? null : keys.FirstOrDefault();
if (keyName.IsNullOrWhiteSpace())
{
keyName = configData.SetName + "-" + environment;
}
configData.ValidateToken(environment, token, keyName);
}
public void CreateFtpReadTest()
{
var type = TransferMethods.Ftp;
var expected = typeof(FtpTrasfer);
var actual = TransferFactory.Create(type)
.SetServerRootUrl("127.0.0.1")
.SetFileName("/test/test.txt").SetUserNameAndPassword(GetUserName(), GetPassword());
var file = actual.Read();
var encoding = EncodingFactory.Check(file, file.Length);
var data = encoding.GetString(file);
Assert.IsInstanceOfType(actual, expected);
Assert.IsTrue("Dette er en test".Equals(data));
}
/// <summary>
/// Initializes a new instance of the <see cref="LoggerManagementSetup"/> class.
/// </summary>
public LoggerManagementSetup()
{
_logger.EnteringMethodPart();
// get external parts to compose
IServiceLocator _serviceLocator = ServiceLocator.Current;
string _ConsumerConfigurationFileName = _serviceLocator.GetInstance <string>(ConsumerCompositionSettings.ConfigurationFileNameContract);
_ViewModel = _serviceLocator.GetInstance <ConsumerViewModel>(ConsumerCompositionSettings.ViewModelContract);
_logger.Composed(nameof(_ViewModel), _ViewModel.GetType().FullName);
EncodingFactory = _serviceLocator.GetInstance <IEncodingFactory>();
_logger.Composed(nameof(EncodingFactory), EncodingFactory.GetType().FullName);
MessageHandlerFactory = _serviceLocator.GetInstance <IMessageHandlerFactory>();
_logger.Composed(nameof(MessageHandlerFactory), MessageHandlerFactory.GetType().FullName);
// setup local functionality
ConfigurationFactory = new ConsumerConfigurationFactory(_ConsumerConfigurationFileName);
_logger.Composed(nameof(ConfigurationFactory), ConfigurationFactory.GetType().FullName);
BindingFactory = new PartIBindingFactory(_ViewModel);
_logger.Composed(nameof(BindingFactory), BindingFactory.GetType().FullName);
}
/// <summary>
/// Initializes a new instance of the <see cref="PartDataManagementSetup"/> class.
/// </summary>
public PartDataManagementSetup()
{
_Logger.EnteringMethodPart(nameof(PartDataManagementSetup));
//Compose external parts
IServiceLocator _serviceLocator = ServiceLocator.Current;
//string _configurationFileName = _serviceLocator.GetInstance<string>(CompositionSettings.ConfigurationFileNameContract);
m_ViewModel = _serviceLocator.GetInstance <ProducerViewModel>();
EncodingFactory = _serviceLocator.GetInstance <IEncodingFactory>();
_Logger.Composed(nameof(EncodingFactory), EncodingFactory.GetType().FullName);
MessageHandlerFactory = _serviceLocator.GetInstance <IMessageHandlerFactory>();
_Logger.Composed(nameof(MessageHandlerFactory), MessageHandlerFactory.GetType().FullName);
//compose internal parts
ConfigurationFactory = new PartConfigurationFactory(ConfigurationFilePath);
PartBindingFactory pbf = new PartBindingFactory();
_DTOProvider = pbf;
BindingFactory = pbf;
}
protected override void ProcessRecordInEH()
{
string encodingName = EncodingName;
if (string.IsNullOrWhiteSpace(encodingName))
{
encodingName = EncodingFactory.EncodingNames.UTF8;
}
Encoding encoding = EncodingFactory.Get(encodingName);
if (encoding == null)
{
throw new PSArgumentException(string.Format("Unsupported encoding: {0}", encodingName));
}
string encodedString = Base64.EncodeString(InputObject, encoding);
WriteObject(encodedString);
}
public virtual Document Parse(Stream stream, bool buffered = false)
{
if (buffered)
{
Logging.DebugMessage("Reading file buffered. to avoid out of memory exceptions.");
using (var reader = new StreamReader(stream))
{
var doc = new Document();
var isFirst = true;
var row = reader.ReadLine();
while (row.ContainsCharacters())
{
ParseRows(new[] { row }, isFirst, doc);
isFirst = false;
row = reader.ReadLine();
}
return(doc);
}
}
var content = EncodingFactory.ReadFileText(stream);
return(ParseFileContent(content));
}
private static string GetUserName()
{
return(EncodingFactory.ReadFileText(
@"C:\Private projects\Core Framework\Stardust\Stardust.Core.CrossCuttingTest\TestFiles\tty.txt"));
}
private static string GetPassword()
{
return(EncodingFactory.ReadFileText(
@"C:\Private projects\Core Framework\Stardust\Stardust.Core.CrossCuttingTest\TestFiles\ttx.txt").Decrypt(new EncryptionKeyContainer("thisisthekey")));
}
public ProtoBufSerializationFactory()
{
encodingFactory = new EncodingFactory();
}
private static string ExtractToken(IRequest request)
{
return(EncodingFactory.ReadFileText(Convert.FromBase64String(request.Headers["token"])));
}
public virtual Document Parse(string fileName)
{
var content = EncodingFactory.ReadFileText(fileName);
return(ParseFileContent(content));
}
private byte[] ConvertObjectToBytes(object baseObject)
{
// Byte
if (baseObject is byte)
{
return(new byte[] { (byte)baseObject });
}
else if (baseObject is byte[])
{
return(baseObject as byte[]);
}
// Int16
else if (baseObject is Int16)
{
return(BitConverter.GetBytes((Int16)baseObject));
}
else if (baseObject is Int16[])
{
List <byte> bytes = new List <byte>();
foreach (var value in baseObject as Int16[])
{
byte[] valueBytes = BitConverter.GetBytes(value);
bytes.AddRange(valueBytes);
}
return(bytes.ToArray());
}
// UInt16
else if (baseObject is UInt16)
{
return(BitConverter.GetBytes((UInt16)baseObject));
}
else if (baseObject is UInt16[])
{
List <byte> bytes = new List <byte>();
foreach (var value in baseObject as UInt16[])
{
byte[] valueBytes = BitConverter.GetBytes(value);
bytes.AddRange(valueBytes);
}
return(bytes.ToArray());
}
// Int32
else if (baseObject is Int32)
{
return(BitConverter.GetBytes((Int32)baseObject));
}
else if (baseObject is Int32[])
{
List <byte> bytes = new List <byte>();
foreach (var value in baseObject as Int32[])
{
byte[] valueBytes = BitConverter.GetBytes(value);
bytes.AddRange(valueBytes);
}
return(bytes.ToArray());
}
// UInt32
else if (baseObject is UInt32)
{
return(BitConverter.GetBytes((UInt32)baseObject));
}
else if (baseObject is UInt32[])
{
List <byte> bytes = new List <byte>();
foreach (var value in baseObject as UInt32[])
{
byte[] valueBytes = BitConverter.GetBytes(value);
bytes.AddRange(valueBytes);
}
return(bytes.ToArray());
}
// Int64
else if (baseObject is Int64)
{
return(BitConverter.GetBytes((Int64)baseObject));
}
else if (baseObject is Int64[])
{
List <byte> bytes = new List <byte>();
foreach (var value in baseObject as Int64[])
{
byte[] valueBytes = BitConverter.GetBytes(value);
bytes.AddRange(valueBytes);
}
return(bytes.ToArray());
}
// UInt64
else if (baseObject is UInt64)
{
return(BitConverter.GetBytes((UInt64)baseObject));
}
else if (baseObject is UInt64[])
{
List <byte> bytes = new List <byte>();
foreach (var value in baseObject as UInt64[])
{
byte[] valueBytes = BitConverter.GetBytes(value);
bytes.AddRange(valueBytes);
}
return(bytes.ToArray());
}
// String
else if (baseObject is string)
{
Encoding encoding = EncodingFactory.Get(Encoding);
if (encoding == null)
{
throw new PSArgumentException(string.Format("Unsupported encoding type: {0}.", Encoding));
}
return(encoding.GetBytes(baseObject as string));
}
throw new PSArgumentException(string.Format("Unsupported object type: {0}", baseObject.GetType().FullName));
}
