public ResultsApiService( HttpClient httpClient, ISerialiser serialiser) { this.httpClient = httpClient; this.serialiser = serialiser; }
public ReplySendChannelBuilder( MessageSender messageSender, ISerialiser serialiser, ISystemTime systemTime, ITaskRepeater taskRepeater, MessageCacheFactory messageCacheFactory, MessageAcknowledgementHandler acknowledgementHandler, ITaskScheduler taskScheduler, ReplyAuthenticationSessionAttacherFactory authenticationSessionAttacherFactory, ReplyCorrelationLookup correlationLookup) { Contract.Requires(messageSender != null); Contract.Requires(serialiser != null); Contract.Requires(systemTime != null); Contract.Requires(taskRepeater != null); Contract.Requires(messageCacheFactory != null); Contract.Requires(acknowledgementHandler != null); Contract.Requires(taskScheduler != null); Contract.Requires(authenticationSessionAttacherFactory != null); Contract.Requires(correlationLookup != null); this.messageSender = messageSender; this.serialiser = serialiser; this.systemTime = systemTime; this.taskRepeater = taskRepeater; this.messageCacheFactory = messageCacheFactory; this.acknowledgementHandler = acknowledgementHandler; this.taskScheduler = taskScheduler; this.authenticationSessionAttacherFactory = authenticationSessionAttacherFactory; this.correlationLookup = correlationLookup; }
public HttpMessagingServer(ISerialiser serialiser, params IMessagingServerHandler[] handlers) { Contract.Requires(serialiser != null); this.serialiser = serialiser; this.handlers = handlers; }
protected void Application_Start() { GlobalConfiguration.Configure(WebApiConfig.Register); // URL Postfix Extension: Update the configuration to recognise postfix extensions and map known // extensions to MIME Types. Additional changes to WebApiConfig.cs are required to fully enable this // feature. GlobalConfiguration.Configuration.Formatters.JsonFormatter.AddUriPathExtensionMapping("json", "application/json"); GlobalConfiguration.Configuration.Formatters.XmlFormatter.AddUriPathExtensionMapping("xml", "text/xml"); // XML Serialisation: Define the specific XML serialiser to use to ensure that SIF Data Model Objects (as // defined by the SIF Specification with XML Schema Definitions (XSDs)) are serialised correctly. XmlMediaTypeFormatter formatter = GlobalConfiguration.Configuration.Formatters.XmlFormatter; formatter.UseXmlSerializer = true; // XML Serialisation: For each SIF Data Model Object used by each SIF Provider, the following entries are // required to define the root element for each collection object. XmlRootAttribute studentPersonalsXmlRootAttribute = new XmlRootAttribute("StudentPersonals") { Namespace = SettingsManager.ProviderSettings.DataModelNamespace, IsNullable = false }; ISerialiser <List <StudentPersonal> > studentPersonalsSerialiser = SerialiserFactory.GetXmlSerialiser <List <StudentPersonal> >(studentPersonalsXmlRootAttribute); formatter.SetSerializer <List <StudentPersonal> >((XmlSerializer)studentPersonalsSerialiser); // Configure global exception loggers for unexpected errors. GlobalConfiguration.Configuration.Services.Add(typeof(IExceptionLogger), new TraceExceptionLogger()); // Configure a global exception handler for unexpected errors. GlobalConfiguration.Configuration.Services.Replace(typeof(IExceptionHandler), new GlobalUnexpectedExceptionHandler()); Trace.TraceInformation("********** Application_Start **********"); Register(); }
public void SequentialUpgradeTest() { Vault testVault = VaultTests.CreateRandomVault(_rng); IEnumerable <FormatVersionAttribute> vaultSerialisers = FormatVersions.Instance.VersionSerialisers.Keys.Where(fva => fva.ObjectType == typeof(Vault)).OrderBy(fva => double.Parse(fva.Version)); FormatVersionAttribute[] filteredOrderedSerialisers = vaultSerialisers.ToArray(); object curSerialised = null; Vault curVault = null; string lastVersion = String.Empty; for (int curVersion = 0; curVersion < filteredOrderedSerialisers.Length; curVersion++) { if (curSerialised != null) { FormatVersionAttribute prevSerialiserAttrib = filteredOrderedSerialisers[curVersion - 1]; ISerialiser prevSerialiser = FormatVersions.Instance.GetSerialiser(prevSerialiserAttrib.Version, typeof(Vault)); curVault = (Vault)prevSerialiser.Read(curSerialised, String.Empty); } else { curVault = testVault; } FormatVersionAttribute nextSerialiserAttrib = filteredOrderedSerialisers[curVersion]; lastVersion = nextSerialiserAttrib.Version; ISerialiser nextSerialiser = FormatVersions.Instance.GetSerialiser(nextSerialiserAttrib.Version, typeof(Vault)); curSerialised = nextSerialiser.Write(curVault, String.Empty); } Assert.IsTrue(lastVersion == Framework.Serialisers.JSON.Common.LATEST_VAULT_VERSION); ISerialiser latestSerialiser = FormatVersions.GetLatestSerialiser(typeof(Vault)); curVault = (Vault)latestSerialiser.Read(curSerialised, String.Empty); Assert.IsTrue(curVault.CompareTo(testVault) == 0); }
public async Task <GenericResult <Common.LoadResult, Vault> > Load( ISerialiser serialiser, string masterPassphrase, params KeyValuePair <string, string>[] parameters) { bool exists = await Native.Native.FileHandler.Exists(FullPath); if (exists) { Byte[] encrypted = await Native.Native.FileHandler.ReadAsync(FullPath); Vault vault = (Vault)serialiser.Read(encrypted, masterPassphrase, parameters); Common.LoadResult result = vault != null ? Common.LoadResult.Success : Common.LoadResult.UnknownError; if (result == Common.LoadResult.Success) { vault.SetSaveParams(serialiser, FullPath, masterPassphrase, false); vault.SetLoaded(); } return(new GenericResult <Common.LoadResult, Vault>(result, vault)); } else { return(new GenericResult <Common.LoadResult, Vault>(Common.LoadResult.FileNotFound, null)); } }
public PublisherChannelBuilder( IPublisherRegistry publisherRegistry, ISerialiser serialiser, ITaskRepeater taskRepeater, MessageCacheFactory messageCacheFactory, ISubscriberSendChannelBuilder subscriberChannelBuilder, ISystemTime systemTime, ChangeStore changeStore, ICheckpointStrategy checkPointStrategy) { Contract.Requires(publisherRegistry != null); Contract.Requires(serialiser != null); Contract.Requires(taskRepeater != null); Contract.Requires(messageCacheFactory != null); Contract.Requires(subscriberChannelBuilder != null); Contract.Requires(systemTime != null); Contract.Requires(changeStore != null); Contract.Requires(checkPointStrategy != null); this.publisherRegistry = publisherRegistry; this.serialiser = serialiser; this.taskRepeater = taskRepeater; this.messageCacheFactory = messageCacheFactory; this.subscriberChannelBuilder = subscriberChannelBuilder; this.systemTime = systemTime; this.changeStore = changeStore; this.checkPointStrategy = checkPointStrategy; }
internal PointToPointReceiveChannelBuilder( MessageReceiver messageReceiver, ISerialiser serialiser, AcknowledgementSender acknowledgementSender, MessageHandlerRouter messageHandlerRouter, MessageCacheFactory messageCacheFactory, ISystemTime systemTime, ITaskRepeater taskRepeater, ServerAddressRegistry serverAddressRegistry, AuthenticationSessionCache authenticationSessionCache, AuthenticatedServerRegistry authenticatedServerRegistry) { Contract.Requires(messageReceiver != null); Contract.Requires(serialiser != null); Contract.Requires(acknowledgementSender != null); Contract.Requires(messageHandlerRouter != null); Contract.Requires(messageCacheFactory != null); Contract.Requires(systemTime != null); Contract.Requires(taskRepeater != null); Contract.Requires(serverAddressRegistry != null); Contract.Requires(authenticationSessionCache != null); Contract.Requires(authenticatedServerRegistry != null); this.messageReceiver = messageReceiver; this.serialiser = serialiser; this.acknowledgementSender = acknowledgementSender; this.messageHandlerRouter = messageHandlerRouter; this.messageCacheFactory = messageCacheFactory; this.systemTime = systemTime; this.taskRepeater = taskRepeater; this.serverAddressRegistry = serverAddressRegistry; this.authenticationSessionCache = authenticationSessionCache; this.authenticatedServerRegistry = authenticatedServerRegistry; }
public async Task <Common.SaveResult> SaveAs( ISerialiser serialiser, String fullPath, String masterPassphrase, Boolean overwrite, params KeyValuePair <string, string>[] parameters) { bool exists = await Native.Native.FileHandler.Exists(fullPath); if (!exists || (exists && overwrite)) { AddAuditEntry( AuditLogEntry.EntryType.Saved, new KeyValuePair <String, String>("Version", AssemblyVersion().ToString())); Byte[] serialised = (Byte[])serialiser.Write(this, masterPassphrase, parameters); await Native.Native.FileHandler.WriteAsync( fullPath, serialised); SetSaveParams( serialiser, fullPath, masterPassphrase, false); return(Common.SaveResult.Success); } return(Common.SaveResult.UnknownError); }
public SubscriberSendChannelBuilder( MessageSender messageSender, MessageCacheFactory messageCacheFactory, ISystemTime systemTime, ITaskRepeater taskRepeater, MessageAcknowledgementHandler acknowledgementHandler, ISerialiser serialiser, ITaskScheduler taskScheduler, SenderAuthenticationSessionAttacherFactory authenticationSessionAttacherFactory) { Contract.Requires(messageSender != null); Contract.Requires(messageCacheFactory != null); Contract.Requires(systemTime != null); Contract.Requires(taskRepeater != null); Contract.Requires(acknowledgementHandler != null); Contract.Requires(serialiser != null); Contract.Requires(taskScheduler != null); Contract.Requires(authenticationSessionAttacherFactory != null); this.messageSender = messageSender; this.messageCacheFactory = messageCacheFactory; this.systemTime = systemTime; this.taskRepeater = taskRepeater; this.acknowledgementHandler = acknowledgementHandler; this.serialiser = serialiser; this.taskScheduler = taskScheduler; this.authenticationSessionAttacherFactory = authenticationSessionAttacherFactory; }
protected void Application_Start() { log4net.Config.XmlConfigurator.Configure(); GlobalConfiguration.Configure(WebApiConfig.Register); GlobalConfiguration.Configuration.Formatters.JsonFormatter.AddUriPathExtensionMapping("json", "application/json"); GlobalConfiguration.Configuration.Formatters.XmlFormatter.AddUriPathExtensionMapping("xml", "text/xml"); // Add a text/plain formatter (WebApiContrib also contains CSV and other formaters) GlobalConfiguration.Configuration.Formatters.Add(new PlainTextFormatter()); XmlMediaTypeFormatter formatter = GlobalConfiguration.Configuration.Formatters.XmlFormatter; formatter.UseXmlSerializer = true; // Set up serializer configuration for data object: XmlRootAttribute studentPersonalsXmlRootAttribute = new XmlRootAttribute("LearnerPersonals") { Namespace = SettingsManager.ProviderSettings.DataModelNamespace, IsNullable = false }; ISerialiser <List <LearnerPersonal> > studentPersonalsSerialiser = SerialiserFactory.GetXmlSerialiser <List <LearnerPersonal> >(studentPersonalsXmlRootAttribute); formatter.SetSerializer <List <LearnerPersonal> >((XmlSerializer)studentPersonalsSerialiser); // Configure global exception loggers for unexpected errors. GlobalConfiguration.Configuration.Services.Add(typeof(IExceptionLogger), new TraceExceptionLogger()); // Configure a global exception handler for unexpected errors. GlobalConfiguration.Configuration.Services.Replace(typeof(IExceptionHandler), new GlobalUnexpectedExceptionHandler()); Trace.TraceInformation("********** Application_Start **********"); log.Info("********** Application_Start **********"); Register(); }
/// <summary> /// Write an object to a target stream using a certain serialiser. /// All related objects along the object graph are properly stored using the <see cref="ISerialisationNotifier"/> contract. /// </summary> /// <param name="obj">The object.</param> /// <param name="target">The target stream.</param> /// <param name="serialiser">The serialiser.</param> /// <param name="autoClose">Optionally indicate if the stream should be automatically closed.</param> /// <param name="verbose">Optionally indicate where the log messages should written to (verbose = Info, otherwise Debug).</param> /// <returns>The number of bytes written (if exposed by the used target stream).</returns> public static long Write(object obj, Stream target, ISerialiser serialiser, bool autoClose = true, bool verbose = true) { if (obj == null) { throw new ArgumentNullException(nameof(obj)); } if (target == null) { throw new ArgumentNullException(nameof(target)); } if (serialiser == null) { throw new ArgumentNullException(nameof(serialiser)); } LoggingUtils.Log(verbose ? Level.Info : Level.Debug, $"Writing {obj.GetType().Name} {obj} of type {obj.GetType()} to target stream {target} using serialiser {serialiser}...", ClazzLogger); Stopwatch stopwatch = Stopwatch.StartNew(); long beforePosition = target.Position; TraverseObjectGraph(obj, new HashSet <object>(), (p, f, o) => (o as ISerialisationNotifier)?.OnSerialising()); serialiser.Write(obj, target); TraverseObjectGraph(obj, new HashSet <object>(), (p, f, o) => (o as ISerialisationNotifier)?.OnSerialised()); target.Flush(); long bytesWritten = target.Position - beforePosition; target.Close(); LoggingUtils.Log(verbose ? Level.Info : Level.Debug, $"Done writing {obj.GetType().Name} {obj} to target stream {target} using serialiser {serialiser}, " + $"wrote {(bytesWritten / 1024.0):#.#}kB, took {stopwatch.ElapsedMilliseconds}ms.", ClazzLogger); return(bytesWritten); }
public object Read( object data, string masterPassphrase, params KeyValuePair <string, string>[] parameters) { FormatVersionAttribute formatVersion = FormatVersionAttribute.GetAttributeFromType(this.GetType()); DLoggerManager.Instance.Logger.Log(DFramework.Logging.Interfaces.LoggerMessageType.VerboseHigh | DFramework.Logging.Interfaces.LoggerMessageType.Information, "Writing Credential from JSON using serialiser '{0}'.", formatVersion); JObject dataJSON = (JObject)data; String id = JSONHelpers.ReadString(dataJSON, "ID"); String glyphKey = JSONHelpers.ReadString(dataJSON, "GlyphKey"); String glyphColour = JSONHelpers.ReadString(dataJSON, "GlyphColour"); String name = JSONHelpers.ReadString(dataJSON, "Name"); String description = JSONHelpers.ReadString(dataJSON, "Description"); String website = JSONHelpers.ReadString(dataJSON, "Website"); DateTime createdAt = JSONHelpers.ReadDateTime(dataJSON, "CreatedAt"); DateTime lastUpdatedAt = JSONHelpers.ReadDateTime(dataJSON, "LastUpdatedAt"); DateTime passwordLastModifiedAt = JSONHelpers.ReadDateTime(dataJSON, "PasswordLastModifiedAt", createdAt); String username = JSONHelpers.ReadString(dataJSON, "Username"); String password = JSONHelpers.ReadString(dataJSON, "Password"); JArray tagsArray = JSONHelpers.ReadJArray(dataJSON, "Tags", true);; List <String> tags = new List <String>(); foreach (JValue curValue in tagsArray) { tags.Add(curValue.Value <String>()); } String notes = JSONHelpers.ReadString(dataJSON, "Notes"); List <AuditLogEntry> auditLogEntriesList = new List <AuditLogEntry>(); if (dataJSON.ContainsKey("AuditLogEntries")) { ISerialiser auditLogEntrySerialiser = FormatVersions.Instance.GetSerialiser(formatVersion.Version, typeof(AuditLogEntry)); JArray auditLogEntries = JSONHelpers.ReadJArray(dataJSON, "AuditLogEntries", true); foreach (JObject curEntry in auditLogEntries) { AuditLogEntry entry = (AuditLogEntry)auditLogEntrySerialiser.Read(curEntry, String.Empty); auditLogEntriesList.Add(entry); } if (auditLogEntriesList.Count > 0) { auditLogEntriesList = auditLogEntriesList.OrderByDescending(ale => ale.DateTime).ToList(); } } return(new Credential(id, glyphKey, glyphColour, name, description, website, createdAt, lastUpdatedAt, passwordLastModifiedAt, username, password, tags.ToArray(), notes, auditLogEntriesList.ToArray())); }
protected void Application_Start() { GlobalConfiguration.Configure(WebApiConfig.Register); GlobalConfiguration.Configuration.Formatters.JsonFormatter .AddUriPathExtensionMapping("json", "application/json"); GlobalConfiguration.Configuration.Formatters.XmlFormatter.AddUriPathExtensionMapping("xml", "text/xml"); XmlMediaTypeFormatter formatter = GlobalConfiguration.Configuration.Formatters.XmlFormatter; formatter.UseXmlSerializer = true; var studentsXmlRootAttribute = new XmlRootAttribute("xStudents") { Namespace = SettingsManager.ProviderSettings.DataModelNamespace, IsNullable = false }; ISerialiser <List <xStudent> > studentsSerialiser = SerialiserFactory.GetXmlSerialiser <List <xStudent> >(studentsXmlRootAttribute); formatter.SetSerializer <List <xStudent> >((XmlSerializer)studentsSerialiser); // Configure global exception loggers for unexpected errors. GlobalConfiguration.Configuration.Services.Add(typeof(IExceptionLogger), new TraceExceptionLogger()); // Configure a global exception handler for unexpected errors. GlobalConfiguration.Configuration.Services .Replace(typeof(IExceptionHandler), new GlobalUnexpectedExceptionHandler()); Trace.TraceInformation("********** Application_Start **********"); Register(); }
public ServiceBusClientFixture() { this.bus = new FakeServiceBus(); this.connectionString = "ConnectionString"; this.queueName = "queuename"; this.serialiser = A.Fake <ISerialiser>(); }
public ServiceBusListenerFixture() { this.bus = new FakeServiceBus(); this.connectionString = "ConnectionString"; this.queueName = "queuename"; this.serialiser = A.Fake<ISerialiser>(); }
public static ISerialiser GetLatestSerialiser(Type objectType) { ISerialiser serialiser = FormatVersions.Instance.GetSerialiser( Common.LATEST_VAULT_VERSION, objectType); return(serialiser); }
public RequestSenderBuilder(ISerialiser serialser, RequestSender requestSender) { Contract.Requires(serialser != null); Contract.Requires(requestSender != null); this.serialser = serialser; this.requestSender = requestSender; }
protected ChangeStore(ISerialiser serialiser, ChangeUpcasterRunner upcasterRunner) { Contract.Requires(serialiser != null); Contract.Requires(upcasterRunner != null); this.serialiser = serialiser; this.upcasterRunner = upcasterRunner; }
public CustomerCapturer(ICsvWriter csvWriter, ISerialiser serialiser, IDataCleaner dataCleaner) { if (csvWriter == null) throw new ArgumentNullException(nameof(csvWriter)); if (serialiser == null) throw new ArgumentNullException(nameof(serialiser)); _csvWriter = csvWriter; _serialiser = serialiser; _dataCleaner = dataCleaner; }
public MessageTransporter(IInProcessMessageServer messageServer, ISerialiser serialiser) { Contract.Requires(messageServer != null); Contract.Requires(serialiser != null); this.messageServer = messageServer; this.serialiser = serialiser; }
public MemoryAggregateRootEventStorage(ILoggerFactory loggerFactory , ISerialiser serialiser , IEventToAggregateEventMapper eventToAggregateEventMapper) { _serialiser = serialiser; _eventToAggregateEventMapper = eventToAggregateEventMapper; logger = loggerFactory.Create(); }
public EsentChangeStore( IFileSystem fileSystem, ISerialiser serialiser, ChangeUpcasterRunner changeUpcasterRunner) : base(serialiser, changeUpcasterRunner) { Contract.Requires(fileSystem != null); this.fileSystem = fileSystem; }
public void SetSaveParams(ISerialiser serialiser, String fullPath, String masterPassphrase, Boolean isDirty) { _serialiser = serialiser; _fullPath = fullPath; _masterPassphrase = masterPassphrase; _isDirty = isDirty; }
public NHibAggregateRootEventStorage(ILoggerFactory loggerFactory , IEventToAggregateEventMapper eventToAggregateEventMapper , ISerialiser serialiser , IGenericEntityService genericEntityService) { _eventToAggregateEventMapper = eventToAggregateEventMapper; _serialiser = serialiser; _genericEntityService = genericEntityService; _logger = loggerFactory.Create(); }
public RequestReceiverBuilder(MessageReceiver messageReceiver, MessageHandlerRouter messageHandlerRouter, ISerialiser serialiser) { Contract.Requires(messageReceiver != null); Contract.Requires(messageHandlerRouter != null); Contract.Requires(serialiser != null); this.messageReceiver = messageReceiver; this.messageHandlerRouter = messageHandlerRouter; this.serialiser = serialiser; }
public ResultsApiServiceTests() { serialiser = new NewtonsoftSerialiser(); httpMessageHandler = new MockHttpMessageHandler(); httpClient = httpMessageHandler.ToHttpClient(); httpClient.BaseAddress = new Uri("https://localhost/resultsapi"); resultsApiService = new ResultsApiService(httpClient, serialiser); }
protected void Application_Start() { GlobalConfiguration.Configure(WebApiConfig.Register); GlobalConfiguration.Configuration.Formatters.JsonFormatter.AddUriPathExtensionMapping("json", "application/json"); GlobalConfiguration.Configuration.Formatters.XmlFormatter.AddUriPathExtensionMapping("xml", "text/xml"); XmlMediaTypeFormatter formatter = GlobalConfiguration.Configuration.Formatters.XmlFormatter; formatter.UseXmlSerializer = true; XmlRootAttribute studentPersonalsXmlRootAttribute = new XmlRootAttribute("StudentPersonals") { Namespace = SettingsManager.ProviderSettings.DataModelNamespace, IsNullable = false }; ISerialiser <List <StudentPersonal> > studentPersonalsSerialiser = SerialiserFactory.GetXmlSerialiser <List <StudentPersonal> >(studentPersonalsXmlRootAttribute); formatter.SetSerializer <List <StudentPersonal> >((XmlSerializer)studentPersonalsSerialiser); XmlRootAttribute schoolInfosXmlRootAttribute = new XmlRootAttribute("SchoolInfos") { Namespace = SettingsManager.ProviderSettings.DataModelNamespace, IsNullable = false }; ISerialiser <List <SchoolInfo> > schoolInfosSerialiser = SerialiserFactory.GetXmlSerialiser <List <SchoolInfo> >(schoolInfosXmlRootAttribute); formatter.SetSerializer <List <SchoolInfo> >((XmlSerializer)schoolInfosSerialiser); XmlRootAttribute studentSchoolEnrollmentsXmlRootAttribute = new XmlRootAttribute("StudentSchoolEnrollments") { Namespace = SettingsManager.ProviderSettings.DataModelNamespace, IsNullable = false }; ISerialiser <List <StudentSchoolEnrollment> > studentSchoolEnrollmentsSerialiser = SerialiserFactory.GetXmlSerialiser <List <StudentSchoolEnrollment> >(studentSchoolEnrollmentsXmlRootAttribute); formatter.SetSerializer <List <StudentSchoolEnrollment> >((XmlSerializer)studentSchoolEnrollmentsSerialiser); // Alternative 1. //XmlRootAttribute xmlRootAttribute = new XmlRootAttribute("StudentPersonals") { Namespace = SettingsManager.ProviderSettings.DataModelNamespace, IsNullable = false }; //formatter.SetSerializer<List<StudentPersonal>>(new XmlSerializer(typeof(List<StudentPersonal>), xmlRootAttribute)); // Alternative 2. //XmlAttributes attributes = new XmlAttributes(); //attributes.XmlRoot = new XmlRootAttribute("StudentPersonals") { Namespace = SettingsManager.ProviderSettings.DataModelNamespace, IsNullable = false }; //XmlAttributeOverrides overrides = new XmlAttributeOverrides(); //overrides.Add(typeof(List<StudentPersonal>), attributes); //formatter.SetSerializer<List<StudentPersonal>>(new XmlSerializer(typeof(List<StudentPersonal>), overrides)); // Configure global exception loggers for unexpected errors. GlobalConfiguration.Configuration.Services.Add(typeof(IExceptionLogger), new TraceExceptionLogger()); // Configure a global exception handler for unexpected errors. GlobalConfiguration.Configuration.Services.Replace(typeof(IExceptionHandler), new GlobalUnexpectedExceptionHandler()); Trace.TraceInformation("********** Application_Start **********"); Register(); }
public AssessmentApiService( HttpClient httpClient, ISerialiser serialiser, IDataProcessor <GetQuestionResponse> getQuestionResponseDataProcessor, IDataProcessor <GetAssessmentResponse> getAssessmentResponseDataProcessor) { this.httpClient = httpClient; this.serialiser = serialiser; this.getQuestionResponseDataProcessor = getQuestionResponseDataProcessor; this.getAssessmentResponseDataProcessor = getAssessmentResponseDataProcessor; }
private void checkBoxExt_CheckedChanged(object sender, EventArgs e) { if (checkBoxExt.Checked) { serialiser = serialiserDict["xml"]; } else { serialiser = serialiserDict["json"]; } }
public DapperAggregateRootEventStorage(ILoggerFactory loggerFactory , ISerialiser serialiser , IConnectionStringProvider connectionStringProvider , IEventToAggregateEventMapper eventToAggregateEventMapper) { _serialiser = serialiser; _eventToAggregateEventMapper = eventToAggregateEventMapper; logger = loggerFactory.Create(); _connectionString = connectionStringProvider.Get("events"); }
/// <summary> /// Initializes a new instance of the <see cref="EventStoreContext" /> class. /// </summary> /// <param name="eventStoreConnectionSettings">The event store connection settings.</param> /// <param name="connectionResolver">The connection resolver.</param> public EventStoreContext(EventStoreConnectionSettings eventStoreConnectionSettings, Func <EventStoreConnectionSettings, IEventStoreConnection> connectionResolver, ISerialiser serialiser) { Guard.ThrowIfNull(eventStoreConnectionSettings, nameof(eventStoreConnectionSettings)); // Cache the settings this.EventStoreConnectionSettings = eventStoreConnectionSettings; this.ConnectionResolver = connectionResolver; this.Serialiser = serialiser; // Create a set of Cached User Credentials this.UserCredentials = new UserCredentials(eventStoreConnectionSettings.UserName, eventStoreConnectionSettings.Password); }
public void Setup() { this.serialiser = (ISerialiser)Activator.CreateInstance(this.SerialiserType); var fixture = new Fixture(); this.simple = fixture.Create <SimpleObject>(); this.complex = fixture.Create <ComplexObject>(); this.serialisedSimple = this.serialiser.Serialise(this.simple); this.serialisedComplex = this.serialiser.Serialise(this.complex); }
public AssessmentApiServiceTests() { serialiser = new NewtonsoftSerialiser(); getQuestionResponseDataProcessor = A.Fake <IDataProcessor <GetQuestionResponse> >(); getAssessmentResponseDataProcessor = A.Fake <IDataProcessor <GetAssessmentResponse> >(); httpMessageHandler = new MockHttpMessageHandler(); httpClient = httpMessageHandler.ToHttpClient(); httpClient.BaseAddress = new Uri("https://localhost"); assessmentApiService = new AssessmentApiService(httpClient, serialiser, getQuestionResponseDataProcessor, getAssessmentResponseDataProcessor); }
public AcknowledgementRecieveChannelBuilder( MessageReceiver messageReceiver, MessageAcknowledgementHandler handler, ISerialiser serialiser) { Contract.Requires(messageReceiver != null); Contract.Requires(handler != null); Contract.Requires(serialiser != null); this.messageReceiver = messageReceiver; this.handler = handler; this.serialiser = serialiser; }
public HttpServerTransportBuilder( IHttpServerBuilder httpServerBuilder, ISerialiser serialiser, MessageReceiver messageReceiver) { Contract.Requires(httpServerBuilder != null); Contract.Requires(serialiser != null); Contract.Requires(messageReceiver != null); this.httpServerBuilder = httpServerBuilder; this.serialiser = serialiser; this.messageReceiver = messageReceiver; }
public object Read( object data, string masterPassphrase, params KeyValuePair <string, string>[] parameters) { FormatVersionAttribute formatVersion = FormatVersionAttribute.GetAttributeFromType(this.GetType()); DLoggerManager.Instance.Logger.Log(DFramework.Logging.Interfaces.LoggerMessageType.VerboseHigh | DFramework.Logging.Interfaces.LoggerMessageType.Information, "Reading Vault from JSON using serialiser '{0}'.", formatVersion); JObject dataJSON = (JObject)data; String id = JSONHelpers.ReadString(dataJSON, "ID"); String name = JSONHelpers.ReadString(dataJSON, "Name"); String description = JSONHelpers.ReadString(dataJSON, "Description"); DateTime createdAt = JSONHelpers.ReadDateTime(dataJSON, "CreatedAt"); DateTime lastUpdatedAt = JSONHelpers.ReadDateTime(dataJSON, "LastUpdatedAt"); List <Credential> credentialList = new List <Credential>(); ISerialiser credentialSerialiser = FormatVersions.Instance.GetSerialiser(formatVersion.Version, typeof(Credential)); JArray credentials = JSONHelpers.ReadJArray(dataJSON, "Credentials", true); foreach (JObject curCredential in credentials) { Credential credential = (Credential)credentialSerialiser.Read(curCredential, String.Empty); credentialList.Add(credential); } List <AuditLogEntry> auditLogEntriesList = new List <AuditLogEntry>(); if (dataJSON.ContainsKey("AuditLogEntries")) { ISerialiser auditLogEntrySerialiser = FormatVersions.Instance.GetSerialiser(formatVersion.Version, typeof(AuditLogEntry)); JArray auditLogEntries = JSONHelpers.ReadJArray(dataJSON, "AuditLogEntries", true); foreach (JObject curEntry in auditLogEntries) { AuditLogEntry entry = (AuditLogEntry)auditLogEntrySerialiser.Read(curEntry, String.Empty); auditLogEntriesList.Add(entry); } if (auditLogEntriesList.Count > 0) { auditLogEntriesList = auditLogEntriesList.OrderByDescending(ale => ale.DateTime).ToList(); } } return(new Vault(id, name, description, createdAt, lastUpdatedAt, credentialList.ToArray(), auditLogEntriesList.ToArray())); }
public object Write( object data, string masterPassphrase, params KeyValuePair <string, string>[] parameters) { DLoggerManager.Instance.Logger.Log(DFramework.Logging.Interfaces.LoggerMessageType.VerboseHigh | DFramework.Logging.Interfaces.LoggerMessageType.Information, "Writing JObject to Vault."); ISerialiser serialiser = FormatVersions.Instance.GetSerialiser(Common.LATEST_VAULT_VERSION, typeof(Vault)); return(serialiser.Write( data, masterPassphrase, parameters)); }
public CustomerCapturer(ICsvWriter csvWriter, ISerialiser serialiser, IDataCleaner dataCleaner) { if (csvWriter == null) { throw new ArgumentNullException(nameof(csvWriter)); } if (serialiser == null) { throw new ArgumentNullException(nameof(serialiser)); } _csvWriter = csvWriter; _serialiser = serialiser; _dataCleaner = dataCleaner; }
public HttpRemoteServerBuilder( IHttpServerBuilder httpServerBuilder, ISystemTime systemTime, ISerialiser serialiser, ServerAddressRegistry serverAddressRegistry) { Contract.Requires(httpServerBuilder != null); Contract.Requires(systemTime != null); Contract.Requires(serialiser != null); Contract.Requires(serverAddressRegistry != null); this.httpServerBuilder = httpServerBuilder; this.systemTime = systemTime; this.serialiser = serialiser; this.serverAddressRegistry = serverAddressRegistry; }
public ReplyReceiverBuilder( MessageReceiver messageReceiver, ISerialiser serialiser, IMainThreadMarshaller mainThreadMarshaller, MessageHandlerRouter router) { Contract.Requires(messageReceiver != null); Contract.Requires(serialiser != null); Contract.Requires(mainThreadMarshaller != null); Contract.Requires(router != null); this.messageReceiver = messageReceiver; this.serialiser = serialiser; this.mainThreadMarshaller = mainThreadMarshaller; this.router = router; }
public object Read( object data, string masterPassphrase, params KeyValuePair <string, string>[] parameters) { DLoggerManager.Instance.Logger.Log(DFramework.Logging.Interfaces.LoggerMessageType.VerboseHigh | DFramework.Logging.Interfaces.LoggerMessageType.Information, "Reading Vault from JObject."); JObject dataJSON = (JObject)data; JObject header = JSONHelpers.ReadJObject(dataJSON, "Header", true); string formatVersion = header["FormatVersion"].Value <String>(); ISerialiser serialiser = FormatVersions.Instance.GetSerialiser(formatVersion, typeof(Vault)); return(serialiser.Read( data, masterPassphrase, parameters)); }
public object Write( object data, string masterPassphrase, params KeyValuePair <string, string>[] parameters) { FormatVersionAttribute formatVersion = FormatVersionAttribute.GetAttributeFromType(this.GetType()); DLoggerManager.Instance.Logger.Log(DFramework.Logging.Interfaces.LoggerMessageType.VerboseHigh | DFramework.Logging.Interfaces.LoggerMessageType.Information, "Writing Vault to JSON using serialiser '{0}'.", formatVersion); Dictionary <string, string> parametersDict = parameters.ToDictionary(x => x.Key, x => x.Value); Vault vault = (Vault)data; JObject json = new JObject(); JObject header = new JObject(); header.Add("FormatVersion", new JValue(formatVersion.Version)); json.Add("Header", header); json.Add("ID", new JValue(vault.ID)); json.Add("Name", new JValue(vault.Name)); json.Add("Description", new JValue(vault.Description)); json.Add("CreatedAt", new JValue(vault.CreatedAt.ToString(Common.DATETIMESERIALISATIONFORMAT))); json.Add("LastUpdatedAt", new JValue(vault.LastUpdatedAt.ToString(Common.DATETIMESERIALISATIONFORMAT))); ISerialiser credentialSerialiser = FormatVersions.Instance.GetSerialiser(formatVersion.Version, typeof(Credential)); JArray credentialJSON = new JArray(); foreach (Credential curCredential in vault.Credentials) { credentialJSON.Add(credentialSerialiser.Write(curCredential, String.Empty)); } json.Add("Credentials", credentialJSON); ISerialiser auditLogEntrySerialiser = FormatVersions.Instance.GetSerialiser(formatVersion.Version, typeof(AuditLogEntry)); JArray auditLogEntries = new JArray(); foreach (AuditLogEntry curEntry in vault.AuditLogEntries) { auditLogEntries.Add(auditLogEntrySerialiser.Write(curEntry, String.Empty)); } json.Add("AuditLogEntries", auditLogEntries); return(json); }
public LongPoller( IWebRequestor requestor, ISerialiser formatter, ITaskScheduler scheduler, MessageReceiver receiver, ITaskStarter starter) { Contract.Requires(requestor != null); Contract.Requires(formatter != null); Contract.Requires(scheduler != null); Contract.Requires(receiver != null); Contract.Requires(starter != null); this.requestor = requestor; this.formatter = formatter; this.scheduler = scheduler; this.receiver = receiver; this.starter = starter; }
/// <summary> /// Serialize method. /// </summary> public void Serialize <T>(T obj, string path) { ISerialiser serialiser = (ISerialiser)Serialiser; if (CheckISerialize) { if (obj is MarkerISerialize.ISerialize) { serialiser.Serialize(obj, path); } else { throw new System.InvalidCastException(); } } else { serialiser.Serialize(obj, path); } }
/// <summary> /// Deserialize method. /// </summary> public T Deserialize <T>(string path) { ISerialiser deserialize = (ISerialiser)Serialiser; var deserializeObj = deserialize.Deserialize <T>(path); if (CheckVersion) { Version version = (Version)deserializeObj.GetType().GetProperty("Version").GetValue(deserializeObj, null); if (!Version.Equals(version)) { throw new System.ArgumentException("Version do not equal"); } return(deserializeObj); } else { return(deserializeObj); } }
public void SendBroadcastMessage(BroadcastMessageType msgType, ISerialiser <AutoDiscoveryMessage, byte[]> serialiser, Int32 multicastPort) { if (msgType == BroadcastMessageType.None) { throw new InvalidOperationException("The specified BroadcastMessageType is not valid"); } if (serialiser == null) { throw new ArgumentException("The specified serialiser is not valid"); } // Create and prepare the arguments byte[] temp = serialiser.Serialise(new AutoDiscoveryMessage(_socket.LocalEndPoint, msgType)); byte[] data = BitConverter.GetBytes(temp.Length).Merge(temp); // send the data UdpClient cli = new UdpClient(); cli.Send(data, data.Length, new IPEndPoint(IPAddress.Broadcast, Port)); }
internal RequestRecieveChannelBuilder( ReplyAddressLookup replyAddressLookup, ISerialiser serialiser, MessageHandlerRouter messageHandlerRouter, AcknowledgementSender acknowledgementSender, MessageCacheFactory messageCacheFactory, ISystemTime systemTime, ITaskRepeater taskRepeater, ServerAddressRegistry serverAddressRegistry, IMainThreadMarshaller mainThreadMarshaller, AuthenticationSessionCache authenticationSessionCache, AuthenticatedServerRegistry authenticatedServerRegistry, ReplyCorrelationLookup correlationLookup) { Contract.Requires(replyAddressLookup != null); Contract.Requires(serialiser != null); Contract.Requires(messageHandlerRouter != null); Contract.Requires(acknowledgementSender != null); Contract.Requires(messageCacheFactory != null); Contract.Requires(systemTime != null); Contract.Requires(taskRepeater != null); Contract.Requires(serverAddressRegistry != null); Contract.Requires(mainThreadMarshaller != null); Contract.Requires(authenticationSessionCache != null); Contract.Requires(authenticatedServerRegistry != null); Contract.Requires(correlationLookup != null); this.replyAddressLookup = replyAddressLookup; this.serialiser = serialiser; this.messageHandlerRouter = messageHandlerRouter; this.acknowledgementSender = acknowledgementSender; this.messageCacheFactory = messageCacheFactory; this.systemTime = systemTime; this.taskRepeater = taskRepeater; this.serverAddressRegistry = serverAddressRegistry; this.mainThreadMarshaller = mainThreadMarshaller; this.authenticationSessionCache = authenticationSessionCache; this.authenticatedServerRegistry = authenticatedServerRegistry; this.correlationLookup = correlationLookup; }
internal MessageBodyService(IRestClient restClient, ISerialiser serialiser) : base(restClient, serialiser) { }
/// <summary> /// Initializes a new instance of the <see cref="FavouriteHandler"/> class. /// </summary> private FavouriteHandler() { this._Serializer = new XmlSerialiser<List<Favourite>>(); this._Favourites = new List<Favourite>(); }
/// <summary> /// Initializes a new instance of the <see cref="FavouriteHandler"/> class. /// </summary> /// <param name="filePath">The file path.</param> private FavouriteHandler(String filePath) { this._Serializer = new XmlSerialiser<List<Favourite>>(filePath); this._Favourites = new List<Favourite>(); }
/// <summary> /// Constructs a new instance of the service bus listener /// </summary> /// <param name="subscribers">Collection of subscribers</param> /// <param name="serialiser">Serialiser to use (defaults to SimpleJson)</param> /// <param name="serviceBus">Raw service bus (defaults to "real" service bus)</param> public ServiceBusListener(IEnumerable<ISubscriber> subscribers, ISerialiser serialiser = null, IServiceBus serviceBus = null) { this.subscribers = subscribers.ToArray(); this.serialiser = serialiser ?? new SimpleJsonSerialiser(); this.serviceBus = serviceBus ?? new ServiceBus.ServiceBus(); }
private HistoryHandler() { this._Serializer = new XmlSerialiser<History>(); this._History = new History(); }
public MessagePayloadCopier(ISerialiser serialiser) { Contract.Requires(serialiser != null); this.serialiser = serialiser; }
private HistoryHandler(String filePath) { this._Serializer = new XmlSerialiser<History>(filePath); this._History = new History(); }
InMemoryChangeStore(ISerialiser serialiser) : base(serialiser, new ChangeUpcasterRunner(new ApplicationTypeActivator())) { this.serialiser = serialiser; changes = new ConcurrentDictionary<int, ChangeContainer>(); }
internal SessionService(IRestClient restClient, ISerialiser serialiser) : base(restClient, serialiser) { }
internal GroupService(IRestClient restClient, ISerialiser serialiser) : base(restClient, serialiser) { }
private static CustomerCapturer CreateCustomerCapturer(ICsvWriter csvWriter = null, ISerialiser serialiser = null, IDataCleaner dataCleaner = null) { csvWriter = csvWriter ?? Substitute.For<ICsvWriter>(); serialiser = serialiser ?? Substitute.For<ISerialiser>(); dataCleaner = dataCleaner ?? new DataCleaner(); return new CustomerCapturer(csvWriter, serialiser, dataCleaner); }
internal ContactService(IRestClient restClient, ISerialiser serialiser) : base(restClient, serialiser) { }