/// <summary> /// /// </summary> private void ReadConfigurationData() { var inputFolder = ConfigurationAccessManager.GetApplicationSetting("InputFolder"); if (!Directory.Exists(inputFolder)) { throw new InputFolderNotExistsException(); } this.InputFolder = inputFolder; var outputFolder = ConfigurationAccessManager.GetApplicationSetting("OutputFolder"); if (!Directory.Exists(outputFolder)) { throw new OutputFolderNotExistsException(); } this.OutputFolder = outputFolder; var referenceFile = ConfigurationAccessManager.GetApplicationSetting("ReferenceFile"); if (File.GetAttributes(referenceFile).HasFlag(FileAttributes.Directory) || !File.Exists(referenceFile)) { throw new ReferenceFileNotExistsException(); } this.ReferenceData = XmlSerializerManager.DeserializeToObject <ReferenceData>(File.ReadAllBytes(referenceFile), Encoding.UTF8); if (this.ReferenceData == null || this.ReferenceData.Factors == null) { throw new ReferenceFileSerializationException(); } }
public void XMLSerializerCanSerializeObjectToXML() { var _listMockOjbect = this.CreateMockObject(); var _xmlStringActual = XmlSerializerManager.Serialize <MockList>(_listMockOjbect); Assert.AreNotEqual(string.Empty, _xmlStringActual); Assert.AreEqual(XMLSTRING_MOCK, _xmlStringActual); }
public static CacheKeyConfig GetKeyConfigFormAssembly(Assembly assembly) { XmlDocument keysXmlConfig = new XmlDocument(); Stream stream = assembly.GetManifestResourceStream(assembly.GetName().Name + ".keyManager.config"); keysXmlConfig.Load(stream); return(XmlSerializerManager.XmlDeserialize <CacheKeyConfig>(keysXmlConfig.DocumentElement)); }
public void XMLSerializerCanDeserializationObject() { var _expectedObject = this.CreateMockObject(); var _mockObjectActual = XmlSerializerManager.Deserialize <MockList>(XMLSTRING_MOCK); Assert.AreEqual(_expectedObject.Title, _mockObjectActual.Title); Assert.AreEqual(_expectedObject.Description, _mockObjectActual.Description); Assert.AreEqual(_expectedObject.EnableContentTypes, _mockObjectActual.EnableContentTypes); }
public void TemplateManagerCanDeserializeTemplateConfig() { XMLSiteTemplateData _tc; XDocument _doc = XDocument.Load("Resources/SiteTemplates/Templates.config"); _tc = XmlSerializerManager.Deserialize <XMLSiteTemplateData>(_doc); var _templates = _tc.Templates; Assert.AreEqual(3, _templates.Count); }
public override string ToString() { // XmlSerializer serializer = new XmlSerializer( GetType() ); XmlSerializer serializer = XmlSerializerManager.GetSerializer(GetType()); UTF8EncodedStringWriter stringWriter = new UTF8EncodedStringWriter(); try { serializer.Serialize(stringWriter, this); return(stringWriter.ToString()); } finally { stringWriter.Close(); } }
private void LoadXML() { try { var _filePath = Path.Combine(this.ConnectionString.HandleEnvironmentToken(), "Templates.config"); bool _fileExists = System.IO.File.Exists(_filePath); Log.Info("Provisioning.Common.Data.Templates.Impl.XMLSiteTemplateManager.LoadXML", PCResources.XMLTemplateManager_TryRead_ConfigFile, _filePath); if (_fileExists) { XDocument _doc = XDocument.Load(_filePath); this._data = XmlSerializerManager.Deserialize <XMLSiteTemplateData>(_doc); Log.Info("Provisioning.Common.Data.Templates.Impl.XMLSiteTemplateManager.LoadXML", PCResources.XMLTemplateManager_Loaded_ConfigFile, _filePath); } else { _filePath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, this.ConnectionString, "Templates.config"); Log.Info("Provisioning.Common.Data.Templates.Impl.XMLSiteTemplateManager.LoadXML", PCResources.XMLTemplateManager_TryRead_ConfigFile, _filePath); _fileExists = System.IO.File.Exists(_filePath); if (_fileExists) { Log.Info("Provisioning.Common.Data.Templates.Impl.XMLSiteTemplateManager.LoadXML", PCResources.XMLTemplateManager_File_Found, _filePath); XDocument _doc = XDocument.Load(_filePath); this._data = XmlSerializerManager.Deserialize <XMLSiteTemplateData>(_doc); Log.Info("Provisioning.Common.Data.Templates.Impl.XMLSiteTemplateManager.LoadXML", PCResources.XMLTemplateManager_Loaded_ConfigFile, _filePath); } else { var _message = string.Format(PCResources.Exception_MasterTemplateNotFound, _filePath); Log.Error("Provisioning.Common.Data.Templates.Impl.XMLSiteTemplateManager.LoadXML", _message); throw new DataStoreException(_message); } } } catch (Exception _ex) { Log.Error("Provisioning.Common.Data.Templates.Impl.XMLSiteTemplateManager", PCResources.XMLTemplateManager_Error, _ex.Message, _ex.StackTrace); throw; } }
/// <summary> /// Writes the generated output to a file named after the input file name. /// </summary> /// <param name="fileName">The input files name.</param> /// <param name="generationOutput">The output data.</param> private void CreateOutputFile(string fileName, GenerationOutput generationOutput) { if (fileName.Contains(this.ConfigurationData.InputFolder) && fileName.ToLower().Contains(".xml")) { fileName = new FileInfo(fileName).Name.Replace(".xml", ""); } lock (this.LockObject) { using (var stream = File.Create(this.ConfigurationData.OutputFolder + fileName + ".xml")) { using (var streamWriter = new StreamWriter(stream)) { var content = XmlSerializerManager.SerializeToXmlString(generationOutput, Encoding.UTF8); streamWriter.Write(content); } } this.ItemsInProcess.Remove(fileName); } }
/// **************************************************************** /// public Get /// ---------------------------------------------------------------- /// <summary> /// </summary> /// **************************************************************** /// public ChangeRecordDetail Get() { Debug.VerifySetting("OperatorKey"); ChangeRecordDetail detail = new ChangeRecordDetail(); try { // // Get the list of known operators. // StringCollection operators = new StringCollection(); SqlStoredProcedureAccessor sp = new SqlStoredProcedureAccessor(); sp.ProcedureName = "net_operators_get"; SqlDataReaderAccessor reader = sp.ExecuteReader(); try { while (reader.Read()) { operators.Add(reader.GetGuidString("operatorKey")); } } finally { reader.Close(); } // // Set the search criteria for change records. // foreach (string operatorKey in operators) { long startUSN; long stopUSN; startUSN = 0; foreach (ChangeRecordVector mark in ChangesAlreadySeen) { if (0 == String.Compare(operatorKey, mark.NodeID, true)) { startUSN = mark.OriginatingUSN + 1; break; } } stopUSN = System.Int64.MaxValue; foreach (ChangeRecordVector mark in ResponseLimitVector) { if (0 == String.Compare(operatorKey, mark.NodeID, true)) { stopUSN = mark.OriginatingUSN; break; } } FindChangeRecords.SetRange(operatorKey, startUSN, stopUSN); } // // Retrieve the change records. // int limit = Config.GetInt("Replication.ResponseLimitCountDefault"); if (ResponseLimitCount >= 0 && ResponseLimitCount <= limit) { limit = ResponseLimitCount; } reader = FindChangeRecords.RetrieveResults(limit); try { while (reader.Read()) { XmlSerializer serializer = null; switch ((ChangeRecordPayloadType)reader.GetShort("changeTypeID")) { case ChangeRecordPayloadType.ChangeRecordNull: serializer = XmlSerializerManager.GetSerializer(typeof(ChangeRecordNull)); break; case ChangeRecordPayloadType.ChangeRecordNewData: serializer = XmlSerializerManager.GetSerializer(typeof(ChangeRecordNewData)); break; case ChangeRecordPayloadType.ChangeRecordDelete: serializer = XmlSerializerManager.GetSerializer(typeof(ChangeRecordDelete)); break; case ChangeRecordPayloadType.ChangeRecordPublisherAssertion: serializer = XmlSerializerManager.GetSerializer(typeof(ChangeRecordPublisherAssertion)); break; case ChangeRecordPayloadType.ChangeRecordHide: serializer = XmlSerializerManager.GetSerializer(typeof(ChangeRecordHide)); break; case ChangeRecordPayloadType.ChangeRecordDeleteAssertion: serializer = XmlSerializerManager.GetSerializer(typeof(ChangeRecordDeleteAssertion)); break; case ChangeRecordPayloadType.ChangeRecordAcknowledgement: serializer = XmlSerializerManager.GetSerializer(typeof(ChangeRecordAcknowledgement)); break; case ChangeRecordPayloadType.ChangeRecordCorrection: serializer = XmlSerializerManager.GetSerializer(typeof(ChangeRecordCorrection)); break; } StringReader stringReader = new StringReader(reader.GetString("changeData")); try { ChangeRecord changeRecord = new ChangeRecord(); changeRecord.AcknowledgementRequested = (reader.GetInt("flag") & (int)ChangeRecordFlags.AcknowledgementRequested) > 0; changeRecord.ChangeID.NodeID = reader.GetString("OperatorKey"); changeRecord.ChangeID.OriginatingUSN = reader.GetLong("USN"); ChangeRecordBase changeRecordBase = ( ChangeRecordBase )serializer.Deserialize(stringReader); if (changeRecordBase is ChangeRecordCorrection) { // // The query to find change records will do correction 'fixups'. That is, the changeData of this // change record will be replaced with the changeData from the correction. The problem with this is // that the original change data will now look like a correction. To distinguish these types of // change records, we look to see if the OriginatingUSN's match. If the OriginatingUSN's match, // we want they payload of the change record in this correction. This payload will contain the // corrected data that we want. // ChangeRecordCorrection changeRecordCorrection = ( ChangeRecordCorrection )changeRecordBase; if (changeRecordCorrection.ChangeRecord.ChangeID.OriginatingUSN == changeRecord.ChangeID.OriginatingUSN) { changeRecordBase = changeRecordCorrection.ChangeRecord.Payload; } } changeRecord.Payload = changeRecordBase; detail.ChangeRecords.Add(changeRecord); } finally { stringReader.Close(); } } } finally { reader.Close(); } } catch (Exception e) { Debug.OperatorMessage( SeverityType.Error, CategoryType.Replication, OperatorMessageType.None, "Could not retrieve change records:\r\n" + e.ToString()); FindChangeRecords.CleanUp(); throw; } return(detail); }
/// <summary> /// Deserializes the the xml data of the report. /// </summary> /// <param name="fileName">The input file path.</param> /// <returns>The deserialized xml data of the report.</returns> private GenerationReport GetReportData(string fileName) { return(XmlSerializerManager.DeserializeToObject <GenerationReport>(File.ReadAllBytes(fileName), Encoding.UTF8)); }
public long Log() { string changeData; // // Serialize the change data. // Type type = Payload.GetType(); //XmlSerializer serializer = new XmlSerializer( type ); XmlSerializer serializer = XmlSerializerManager.GetSerializer(type); XmlSerializerNamespaces namespaces = new XmlSerializerNamespaces(); UTF8EncodedStringWriter stringWriter = new UTF8EncodedStringWriter(); try { namespaces.Add("", "urn:uddi-org:repl"); serializer.Serialize(stringWriter, Payload, namespaces); changeData = stringWriter.ToString(); } finally { stringWriter.Close(); } // // Store the record in the change log. // SqlStoredProcedureAccessor sp = new SqlStoredProcedureAccessor("net_changeRecord_save"); sp.Parameters.Add("@USN", SqlDbType.BigInt); sp.Parameters.Add("@PUID", SqlDbType.NVarChar, UDDI.Constants.Lengths.UserID); sp.Parameters.Add("@delegatePUID", SqlDbType.NVarChar, UDDI.Constants.Lengths.UserID); sp.Parameters.Add("@operatorKey", SqlDbType.UniqueIdentifier); sp.Parameters.Add("@entityKey", SqlDbType.UniqueIdentifier); sp.Parameters.Add("@entityTypeID", SqlDbType.TinyInt); sp.Parameters.Add("@changeTypeID", SqlDbType.TinyInt); sp.Parameters.Add("@contextID", SqlDbType.UniqueIdentifier); sp.Parameters.Add("@contextTypeID", SqlDbType.TinyInt); sp.Parameters.Add("@lastChange", SqlDbType.BigInt); sp.Parameters.Add("@changeData", SqlDbType.NText); sp.Parameters.Add("@flag", SqlDbType.Int); sp.Parameters.Add("@seqNo", SqlDbType.BigInt, ParameterDirection.Output); if (Utility.StringEmpty(ChangeID.NodeID) || 0 == String.Compare(Config.GetString("OperatorKey"), ChangeID.NodeID, true)) { sp.Parameters.SetNull("@USN"); sp.Parameters.SetString("@PUID", Context.User.ID); sp.Parameters.SetString("@delegatePUID", Context.User.ImpersonatorID); sp.Parameters.SetNull("@operatorKey"); } else { sp.Parameters.SetLong("@USN", changeID.OriginatingUSN); sp.Parameters.SetNull("@PUID"); sp.Parameters.SetNull("@delegatePUID"); sp.Parameters.SetGuidFromString("@operatorKey", changeID.NodeID); } sp.Parameters.SetGuid("@contextID", Context.ContextID); sp.Parameters.SetInt("@flag", AcknowledgementRequested ? 0x1 : 0x0); sp.Parameters.SetLong("@lastChange", DateTime.UtcNow.Ticks); sp.Parameters.SetShort("@contextTypeID", (short)Context.ContextType); sp.Parameters.SetShort("@changeTypeID", (short)Payload.ChangeRecordPayloadType); if (Payload is ChangeRecordNewData) { ChangeRecordNewData payload = (ChangeRecordNewData)Payload; sp.Parameters.SetShort("@entityTypeID", (short)payload.EntityType); if (EntityType.TModel == payload.EntityType) { sp.Parameters.SetGuidFromKey("@entityKey", payload.Entity.EntityKey); } else { sp.Parameters.SetGuidFromString("@entityKey", payload.Entity.EntityKey); } } else if (Payload is ChangeRecordDelete) { ChangeRecordDelete payload = (ChangeRecordDelete)Payload; sp.Parameters.SetShort("@entityTypeID", (short)payload.EntityType); if (EntityType.TModel == payload.EntityType) { sp.Parameters.SetGuidFromKey("@entityKey", payload.EntityKey); } else { sp.Parameters.SetGuidFromString("@entityKey", payload.EntityKey); } } else if (Payload is ChangeRecordHide) { sp.Parameters.SetShort("@entityTypeID", (short)EntityType.TModel); sp.Parameters.SetGuidFromKey("@entityKey", ((ChangeRecordHide)Payload).TModelKey); } else { sp.Parameters.SetNull("@entityTypeID"); sp.Parameters.SetNull("@entityKey"); } sp.Parameters.SetString("@changeData", changeData); sp.ExecuteNonQuery(); return(sp.Parameters.GetLong("@seqNo")); }
public object Create(object parent, object configContext, XmlNode section) { return(XmlSerializerManager.XmlDeserialize <T>(section)); }
public void ProcessRequest(HttpContext ctx) { try { // // Verify the GET verb was used and that a query string is // specified. // if ("GET" != ctx.Request.RequestType.ToUpper()) { ctx.Response.AddHeader("Allow", "GET"); ctx.Response.StatusCode = 405; // Method Not Allowed return; } if (null == ctx.Request.QueryString["businessKey"]) { ctx.Response.StatusCode = 400; // Bad Request ctx.Response.Write("<h1>400 Bad Request</h1>Missing required argument 'businessKey'"); return; } // // Attempt to retrieve the business entity. // ConnectionManager.Open(false, false); string businessKey = ctx.Request.QueryString["businessKey"]; BusinessEntity be = new BusinessEntity(businessKey); be.Get(); // // Serialize the business Entity to the response stream // using UTF-8 encoding // // XmlSerializer serializer = new XmlSerializer( be.GetType() ); XmlSerializer serializer = XmlSerializerManager.GetSerializer(be.GetType()); UTF8Encoding utf8 = new UTF8Encoding(false); StreamWriter sr = new StreamWriter(ctx.Response.OutputStream, utf8); serializer.Serialize(sr, be); ctx.Response.AddHeader("Content-Type", "text/xml; charset=utf-8"); } catch (FormatException e) { // // We get a FormatException when passed a bad GUID. // ctx.Response.StatusCode = 400; // Bad Request ctx.Response.Write("<h1>400 Bad Request</h1>" + e.Message); } catch (SqlException e) { // // We get a SqlException when we could not get the data. // ctx.Response.StatusCode = 400; // Bad Request ctx.Response.Write("<h1>400 Bad Request</h1>" + e.Message); } catch (UDDIException e) { ctx.Response.StatusCode = 400; // Bad Request ctx.Response.Write("<h1>400 Bad Request</h1>" + e.Message); } catch (Exception e) { ctx.Response.StatusCode = 500; // Internal Server Error ctx.Response.Write("<h1>500 Internal Server Error</h1>"); Debug.OperatorMessage(SeverityType.Error, CategoryType.None, OperatorMessageType.None, e.ToString()); } finally { ConnectionManager.Close(); } }
public static void Throw(Exception e) { Debug.Enter(); // // If this is a UDDI exception get the error number // Otherwise map all other errors to E_fatalError // ErrorType et = ErrorType.E_fatalError; string debugMessage = ""; if (e is UDDI.UDDIException) { et = (ErrorType)((UDDIException)e).Number; } else if (e is System.Data.SqlClient.SqlException) { // // SECURITY: SqlException's include stored procedure names // This information is flowing back to the client in the SOAPFault // information. This information should be logged and not returned. // System.Data.SqlClient.SqlException se = (System.Data.SqlClient.SqlException)e; // // Build a detailed message about the exception; this text is not sent back to the user. // debugMessage = "SQL Exception in " + se.Procedure + " line " + se.LineNumber + " [severity " + se.Class + ", state " + se.State; debugMessage += ", server " + se.Server; debugMessage += "]"; // // Is this one of our custom error messages? If so, we'll masssage the // error code into one of the UDDIException error types (custom errors // are thrown as ErrorType + 50000). Otherwise, we'll simply use // E_fatalError. // if (16 == se.Class) { et = (ErrorType)(se.Number - 50000); } else { // // 739178 - See if this was a SQL deadlock issue. If it was, then return an E_serverBusy error // instead. The 1205 number is a retrieved from sysmessages table in the masters database of // SQL Server. See the SQL Books Online for more information about 1205. // if (1205 == se.Number) { // // Change the 'e' variable to a new exception; need to do this since e.Message // is read-only. Keep track of the original exception so we can log it. // Exception originalException = e; e = new UDDIException(ErrorType.E_busy, "ERROR_BUSY"); et = ErrorType.E_busy; Debug.Write(SeverityType.Info, CategoryType.Data, "A deadlock exception has been converted to an E_busy exception. The original exception was:\r\n" + originalException.ToString()); } else { et = ErrorType.E_fatalError; } } } // // Log this error message. // Debug.Write(SeverityType.Info, CategoryType.Data, "An exception occurred. Details Follow:\r\n" + e.ToString() + "\r\n\r\n" + debugMessage); // // if this is a V1.0 call, map any new V2.0 error codes to // v1.0 error codes // if (1 == Context.ApiVersionMajor) { switch (et) { case ErrorType.E_invalidValue: case ErrorType.E_valueNotAllowed: case ErrorType.E_invalidProjection: case ErrorType.E_assertionNotFound: case ErrorType.E_invalidCompletionStatus: case ErrorType.E_messageTooLarge: case ErrorType.E_transferAborted: case ErrorType.E_publisherCancelled: case ErrorType.E_requestDenied: case ErrorType.E_secretUnknown: et = ErrorType.E_fatalError; break; } } // // Construct a new instance of a disposition report // DispositionReport dr = new DispositionReport(et, e.Message); // // Serialize the disposition report to a stream and load into // a DOM. // XmlDocument doc = new XmlDocument(); MemoryStream strm = new MemoryStream(); // XmlSerializer serializer = new XmlSerializer( typeof( DispositionReport ) ); XmlSerializer serializer = XmlSerializerManager.GetSerializer(typeof(DispositionReport)); serializer.Serialize(strm, dr); strm.Position = 0; doc.Load(strm); // // Wrap the disposition report with a detail node. // XmlNode detail = doc.CreateNode( XmlNodeType.Element, SoapException.DetailElementName.Name, SoapException.DetailElementName.Namespace); detail.AppendChild(doc.FirstChild.NextSibling); // // Construct the SOAP exception using the dr XML // as details and the received Exception as the inner exception. // UDDIText uddiText = new UDDIText("ERROR_FATAL_ERROR"); throw new UDDISoapException(uddiText.GetText(), SoapException.ClientFaultCode, "", detail, e); }