public static int GetTaxonomyID(string tModelKey)
{
int taxonomyID;
Debug.Enter();
SqlStoredProcedureAccessor sp = new SqlStoredProcedureAccessor();
sp.ProcedureName = "UI_getTaxonomies";
sp.Parameters.Add("@tModelKey", SqlDbType.UniqueIdentifier);
sp.Parameters.SetGuidFromKey("@tModelKey", tModelKey);
SqlDataReaderAccessor reader = sp.ExecuteReader();
try
{
if (reader.Read())
{
taxonomyID = reader.GetInt("taxonomyID");
}
else
{
taxonomyID = -1;
}
}
finally
{
reader.Close();
}
Debug.Leave();
return(taxonomyID);
}
public void Get(RelationshipQualifier[] relations)
{
if (null != KeyValue)
{
//
// The request can ask for Root stuff with just the TModelKey
//
SqlDataReader rdr = GetValues(RelationType.Current);
try
{
SqlDataReaderAccessor dracc = new SqlDataReaderAccessor(rdr);
if (rdr.Read())
{
this.KeyName = dracc.GetString(KeyNameIndex);
this.IsValid = (1 == dracc.GetInt(IsValidIndex));
}
else
{
throw new UDDIException(UDDI.ErrorType.E_invalidValue, "UDDI_ERROR_INVALIDVALUE_VALUENOTFOUND");
}
}
finally
{
rdr.Close();
}
}
if (null != relations)
{
foreach (RelationshipQualifier rq in relations)
{
switch (rq)
{
case RelationshipQualifier.root:
GetRoots();
break;
case RelationshipQualifier.child:
GetChildren();
break;
case RelationshipQualifier.parent:
GetParents();
break;
}
}
}
}
public void Get()
{
Debug.Enter();
SqlStoredProcedureAccessor sp = new SqlStoredProcedureAccessor();
sp.ProcedureName = "UI_getPublisher";
sp.Parameters.Add("@PUID", SqlDbType.NVarChar, UDDI.Constants.Lengths.UserID);
sp.Parameters.SetString("@PUID", Puid);
SqlDataReaderAccessor reader = sp.ExecuteReader();
Exists = false;
try
{
if (reader.Read())
{
int flag;
IsoLangCode = reader.GetString(1);
Name = reader.GetString(2);
Email = reader.GetString(3);
Phone = reader.GetString(4);
CompanyName = reader.GetString(5);
AltPhone = reader.GetString(6);
AddressLine1 = reader.GetString(7);
AddressLine2 = reader.GetString(8);
City = reader.GetString(9);
StateProvince = reader.GetString(10);
PostalCode = reader.GetString(11);
Country = reader.GetString(12);
flag = reader.GetInt(13);
SecurityToken = reader.GetGuidString(14);
TrackPassport = (0x00 == (flag & 0x02));
Validated = (0x01 == (flag & 0x01));
Exists = true;
}
}
finally
{
reader.Close();
}
Debug.Leave();
}
public ArrayList Read(SqlDataReaderAccessor reader)
{
const int ContactIdIndex = 0;
const int UseTypeIndex = 1;
const int PersonNameIndex = 2;
ArrayList contactIds = new ArrayList();
//
// The contacts will be contained in the result set
//
while (reader.Read())
{
//
// construct a new contact from the data in this row, fully populate contact and add to collection
//
contactIds.Add(reader.GetInt(ContactIdIndex));
Add(new Contact(reader.GetString(PersonNameIndex), reader.GetString(UseTypeIndex)));
}
return(contactIds);
}
public void GetParents()
{
Parents = new CategoryValueCollection();
SqlDataReader rdr = GetValues(RelationType.Parent);
try
{
SqlDataReaderAccessor dracc = new SqlDataReaderAccessor(rdr);
while (rdr.Read())
{
Parents.Add(dracc.GetString(KeyNameIndex),
dracc.GetString(KeyValueIndex),
dracc.GetString(ParentKeyValueIndex),
(1 == dracc.GetInt(IsValidIndex)));
}
}
finally
{
rdr.Close();
}
}
protected static OperatorNodeCollection GetOperators(bool filter, int status)
{
OperatorNodeCollection operators = new OperatorNodeCollection();
SqlStoredProcedureAccessor sp = null;
SqlDataReaderAccessor data = null;
try
{
sp = new SqlStoredProcedureAccessor("UI_operatorsList_get");
if (filter && -1 != status)
{
sp.Parameters.Add("@StatusID", SqlDbType.TinyInt);
sp.Parameters.SetInt("@StatusID", status);
}
data = sp.ExecuteReader();
while (data.Read())
{
operators.Add(data.GetString("OperatorKey"), (OperatorStatus)data.GetInt("OperatorStatusID"), data.GetString("Name"), data.GetString("soapReplicationUrl"));
}
}
finally
{
if (null != data)
{
data.Close();
}
if (null != sp)
{
sp.Close();
}
}
return(operators);
}
/// ****************************************************************
/// 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);
}
public void Get(CompletionStatusType completionStatus)
{
SqlStoredProcedureAccessor sp = new SqlStoredProcedureAccessor("net_publisher_assertionStatus_get");
sp.Parameters.Add("@PUID", SqlDbType.NVarChar, UDDI.Constants.Lengths.UserID);
sp.Parameters.SetString("@PUID", Context.User.ID);
if (CompletionStatusType.Uninitialized != completionStatus)
{
//
// If the completion status was not specified get all
// of the assertions by not specifying a completionStatus value
// in the stored procedure.
//
sp.Parameters.Add("@completionStatus", SqlDbType.Int);
sp.Parameters.SetInt("@completionStatus", (int)completionStatus);
}
SqlDataReaderAccessor reader = sp.ExecuteReader();
try
{
while (reader.Read())
{
KeyedReference keyedReference = new KeyedReference(
reader.GetString("keyName"),
reader.GetString("keyValue"),
reader.GetKeyFromGuid("tModelKey"));
CompletionStatusType status =
(CompletionStatusType)reader.GetInt("flag");
string fromKey = reader.GetGuidString("fromKey");
string toKey = reader.GetGuidString("toKey");
int ownerFlag = reader.GetInt("ownerFlag");
KeysOwned keysOwned = new KeysOwned();
if (0x02 == (ownerFlag & 0x02))
{
keysOwned.FromKey = fromKey;
}
if (0x01 == (ownerFlag & 0x01))
{
keysOwned.ToKey = toKey;
}
this.Add(
new AssertionStatusItem(
status,
fromKey,
toKey,
keyedReference,
keysOwned));
}
}
finally
{
reader.Close();
}
}
static ChangeRecord CreateChangeRecord(SqlDataReaderAccessor reader)
{
ChangeRecord changeRecord = null;
XmlSerializer serializer = null;
switch ((ChangeRecordPayloadType)reader.GetShort("changeTypeID"))
{
case ChangeRecordPayloadType.ChangeRecordNull:
serializer = new XmlSerializer(typeof(ChangeRecordNull));
break;
case ChangeRecordPayloadType.ChangeRecordNewData:
serializer = new XmlSerializer(typeof(ChangeRecordNewData));
break;
case ChangeRecordPayloadType.ChangeRecordDelete:
serializer = new XmlSerializer(typeof(ChangeRecordDelete));
break;
case ChangeRecordPayloadType.ChangeRecordPublisherAssertion:
serializer = new XmlSerializer(typeof(ChangeRecordPublisherAssertion));
break;
case ChangeRecordPayloadType.ChangeRecordHide:
serializer = new XmlSerializer(typeof(ChangeRecordHide));
break;
case ChangeRecordPayloadType.ChangeRecordDeleteAssertion:
serializer = new XmlSerializer(typeof(ChangeRecordDeleteAssertion));
break;
case ChangeRecordPayloadType.ChangeRecordAcknowledgement:
serializer = new XmlSerializer(typeof(ChangeRecordAcknowledgement));
break;
case ChangeRecordPayloadType.ChangeRecordCorrection:
serializer = new XmlSerializer(typeof(ChangeRecordCorrection));
break;
}
StringReader stringReader = new StringReader(reader.GetString("changeData"));
try
{
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;
}
finally
{
stringReader.Close();
}
return(changeRecord);
}
public void Get()
{
Debug.Enter();
//
// Retrieve the taxonomy
//
SqlStoredProcedureAccessor sp = new SqlStoredProcedureAccessor("net_taxonomy_get");
sp.Parameters.Add("@tModelKey", SqlDbType.UniqueIdentifier);
sp.Parameters.Add("@flag", SqlDbType.Int, ParameterDirection.InputOutput);
sp.Parameters.SetGuidFromKey("@tModelKey", tModelKey);
sp.Parameters.SetNull("@flag");
sp.ExecuteScalar();
//
// Set the flag value
//
CategorizationSchemeFlag = sp.Parameters.GetInt("@flag");
//
// Retrieve the taxonomy values
//
CategoryValues.Clear();
SqlStoredProcedureAccessor sp2 = new SqlStoredProcedureAccessor("net_taxonomyValues_get");
sp2.Parameters.Add("@tModelKey", SqlDbType.UniqueIdentifier);
sp2.Parameters.SetGuidFromKey("@tModelKey", tModelKey);
SqlDataReaderAccessor reader = sp2.ExecuteReader();
try
{
while (reader.Read())
{
CategoryValues.Add(reader.GetString("keyName"), reader.GetString("keyValue"), reader.GetString("parentKeyValue"), ((reader.GetInt("valid") == 1) ? true : false));
}
}
finally
{
reader.Close();
}
Debug.Leave();
}
public void Get(string businessKey)
{
//
// Create a command object to invoke the stored procedure net_get_contacts
//
SqlStoredProcedureAccessor cmd = new SqlStoredProcedureAccessor("net_businessEntity_contacts_get");
//
// Input parameters
//
cmd.Parameters.Add("@businessKey", SqlDbType.UniqueIdentifier, ParameterDirection.Input);
cmd.Parameters.SetGuidFromString("@businessKey", businessKey);
//
// Run the stored procedure
//
SqlDataReaderAccessor reader = cmd.ExecuteReader();
ArrayList contactIds = null;
try
{
contactIds = Read(reader);
}
finally
{
reader.Close();
}
Populate(contactIds);
#if never
const int ContactIdIndex = 0;
const int UseTypeIndex = 1;
const int PersonNameIndex = 2;
ArrayList contactIds = new ArrayList();
//
// Create a command object to invoke the stored procedure net_get_contacts
//
SqlCommand cmd = new SqlCommand("net_businessEntity_contacts_get", ConnectionManager.GetConnection());
cmd.Transaction = ConnectionManager.GetTransaction();
cmd.CommandType = CommandType.StoredProcedure;
//
// Input parameters
//
cmd.Parameters.Add(new SqlParameter("@businessKey", SqlDbType.UniqueIdentifier)).Direction = ParameterDirection.Input;
//
// Set parameter values
//
SqlParameterAccessor populator = new SqlParameterAccessor(cmd.Parameters);
populator.SetGuidFromString("@businessKey", businessKey);
//
// Run the stored procedure
//
SqlDataReader rdr = cmd.ExecuteReader();
try
{
SqlDataReaderAccessor dracc = new SqlDataReaderAccessor(rdr);
//
// The contacts will be contained in the result set
//
while (rdr.Read())
{
//
// construct a new contact from the data in this row, fully populate contact and add to collection
//
Add(new Contact(dracc.GetString(PersonNameIndex), dracc.GetString(UseTypeIndex)));
contactIds.Add(dracc.GetInt(ContactIdIndex));
}
}
finally
{
rdr.Close();
}
int i = 0;
foreach (Contact contact in this)
{
contact.Get((int)contactIds[i++]);
}
#endif
}
