private void Remove(IAttributeDefinition attribdef)
{
int index = IndexOf(attribdef);
if (index == -1)
return;
_terms.RemoveAt(index);
}
public SelectionElement(string myAlias, Select.EdgeList myEdgeList, bool myIsGroupedOrAggregated, IDChainDefinition myRelatedIDChainDefinition, IAttributeDefinition myElement = null)
: this(myAlias, myRelatedIDChainDefinition)
{
EdgeList = myEdgeList;
IsGroupedOrAggregated = myIsGroupedOrAggregated;
Element = myElement;
}
private int IndexOf(IAttributeDefinition attribdef)
{
for (int i=0;i<_terms.Count;i++)
if (_terms[i].AttributeDefinition == attribdef)
return i;
return -1;
}
public override FuncParameter ExecFunc(IAttributeDefinition myAttributeDefinition, Object myCallingObject, IVertex myDBObject, IGraphDB myGraphDB, SecurityToken mySecurityToken, TransactionToken myTransactionToken, params FuncParameter[] myParams)
{
if (myCallingObject is IHyperEdge)
{
return new FuncParameter((UInt64)((IHyperEdge)myCallingObject).GetAllEdges().Count());
}
else if (myCallingObject is ISingleEdge)
{
UInt64 count = 1;
return new FuncParameter(count);
}
else if (myCallingObject is IncomingEdgeCollection)
{
return new FuncParameter((UInt64)(myCallingObject as IncomingEdgeCollection).LongCount());
}
else if (myCallingObject is IEnumerable<long>)
{
return new FuncParameter((UInt64)(myCallingObject as IEnumerable<long>).LongCount());
}
else if (myCallingObject is IEnumerable<IVertex>)
{
return new FuncParameter((UInt64)(myCallingObject as IEnumerable<IVertex>).LongCount());
}
else
{
throw new UnknownDBException("Unexpected input for COUNT aggregate.");
}
}
public override FuncParameter ExecFunc(IAttributeDefinition myAttributeDefinition, Object myCallingObject, IVertex myDBObject, IGraphDB myGraphDB, SecurityToken mySecurityToken, TransactionToken myTransactionToken, params FuncParameter[] myParams)
{
if (!(myCallingObject is String))
{
throw new FunctionParameterTypeMismatchException(typeof(String), myCallingObject.GetType());
}
var pos = Convert.ToInt32(myParams[0].Value);
StringBuilder resString = new StringBuilder();
bool dontInsert = false;
if (pos > (myCallingObject as String).Length)
{
dontInsert = true;
resString.Append((myCallingObject as String).ToString());
}
else
{
resString.Append((myCallingObject as String).ToString().Substring(0, pos));
}
foreach (FuncParameter fp in myParams.Skip(1))
{
resString.Append(fp.Value as String);
}
if(!dontInsert)
resString.Append((myCallingObject as String).ToString().Substring(pos));
return new FuncParameter(resString.ToString());
}
/// <summary>
/// Executes the function on myCallingObject
/// </summary>
public override FuncParameter ExecFunc(IAttributeDefinition myAttributeDefinition, Object myCallingObject, IVertex myDBObject, IGraphDB myGraphDB, SecurityToken mySecurityToken, TransactionToken myTransactionToken, params FuncParameter[] myParams)
{
var currentInnerEdgeType = ((IOutgoingEdgeDefinition)myAttributeDefinition).InnerEdgeType;
if (myCallingObject is IHyperEdge && currentInnerEdgeType.HasProperty("Weight"))
{
var hyperEdge = myCallingObject as IHyperEdge;
if (currentInnerEdgeType.HasProperty("Weight"))
{
var weightProperty = currentInnerEdgeType.GetPropertyDefinition("Weight");
var maxWeight = hyperEdge.InvokeHyperEdgeFunc<Double>(singleEdges =>
{
return Convert.ToDouble(
weightProperty.GetValue(
singleEdges
.OrderByDescending(edge => weightProperty.GetValue(edge))
.First()));
});
return new FuncParameter(maxWeight);
}
}
throw new InvalidTypeException(myCallingObject.GetType().ToString(), "Weighted IHyperEdge");
}
/// <summary>
/// Clear an attribute from cache based on definition.
/// </summary>
/// <param name="attribdef">definition of attribute to clear;
/// if null, all attributes will be cleared from cache.</param>
public void ClearAttributeCache(IAttributeDefinition attribdef) {
if (attribdef == null) {
attributes.Clear();
} else {
attributes.Remove(ResolveAttributeDefinition(attribdef).Token);
}
}
private IAttributeDefinition ResolveAttribute(string token, IAttributeDefinition result) {
if(result == null && token != null) {
result = meta.GetAttributeDefinition(token);
}
return result;
}
public virtual void SetValue(IAttributeDefinition attrDef, object value)
{
Type it = this.GetType();//this.GetType().Assembly.GetType("TJVISA.Entity." + attrDef.ForObject.EntityName,false, true);
if (it == null) Debug.Assert(false, attrDef.ForObject.EntityName + " is unknown object type.");
PropertyInfo p = it.GetProperty(attrDef.Name);
if (p != null && p.CanWrite)
p.SetValue(this, value, null);
}
public virtual object GetValue(IAttributeDefinition attrDef)
{
Type it = this.GetType();//this.GetType().Assembly.GetType("TJVISA.Entity." + attrDef.ForObject.EntityName,false, true);
if (it == null) Debug.Assert(false, attrDef.ForObject.EntityName+ " is unknown object type.");
PropertyInfo p = it.GetProperty(attrDef.Name);
if (p != null && p.CanRead)
return p.GetValue(this, null);
return null;
}
private IAttributeDefinition ResolveAttributeDefinition(IAttributeDefinition attribdef) {
try {
if(AssetType.Is(attribdef.AssetType)) {
return AssetType.GetAttributeDefinition(attribdef.Name);
}
} catch (MetaException) { }
return attribdef;
}
public override FuncParameter ExecFunc(IAttributeDefinition myAttributeDefinition, Object myCallingObject, IVertex myDBObject, IGraphDB myGraphDB, SecurityToken mySecurityToken, TransactionToken myTransactionToken, params FuncParameter[] myParams)
{
if (myCallingObject != null)
{
return new FuncParameter(true);
}
else
{
return new FuncParameter(false);
}
}
public override FuncParameter ExecFunc(IAttributeDefinition myAttributeDefinition, Object myCallingObject, IVertex myDBObject, IGraphDB myGraphDB, SecurityToken mySecurityToken, Int64 myTransactionToken, params FuncParameter[] myParams)
{
if (!(myCallingObject is String))
{
throw new FunctionParameterTypeMismatchException(typeof(String), myCallingObject.GetType());
}
var substring = myCallingObject.ToString().Substring(Convert.ToInt32(myParams[0].Value), Convert.ToInt32(myParams[1].Value));
return new FuncParameter(substring);
}
public override FuncParameter ExecFunc(IAttributeDefinition myAttributeDefinition, Object myCallingObject, IVertex myDBObject, IGraphDB myGraphDB, SecurityToken mySecurityToken, Int64 myTransactionToken, params FuncParameter[] myParams)
{
if (myCallingObject is String)
{
return new FuncParameter(((String)myCallingObject).ToLower());
}
else
{
throw new FunctionParameterTypeMismatchException(typeof(String), myCallingObject.GetType());
}
}
public ServiceAttributeDefinition(IAttributeDefinition myAttributeDefinition)
{
if (myAttributeDefinition != null)
{
this.ID = myAttributeDefinition.ID;
this.Name = myAttributeDefinition.Name;
this.IsUserDefined = myAttributeDefinition.IsUserDefined;
this.Kind = (ServiceAttributeType)myAttributeDefinition.Kind;
this.RelatedType = ConvertHelper.ToServiceBaseType(myAttributeDefinition.RelatedType);
}
}
public void TestFixtureSetUp()
{
V1APIConnector dataConnector = new V1APIConnector(v1Url + dataPath, username, password);
V1APIConnector metaConnector = new V1APIConnector(v1Url + metaPath);
V1APIConnector localConnector = new V1APIConnector(v1Url + localizationPath);
localizer = new Localizer(localConnector);
metaModel = new MetaModel(metaConnector);
services = new Services(metaModel, dataConnector);
timeboxType = metaModel.GetAssetType("Timebox");
timeboxName = timeboxType.GetAttributeDefinition("Name");
timeboxID = timeboxType.GetAttributeDefinition("ID");
}
/// <summary>
/// Validate single Asset attribute. If attribute is not loaded, it is just considered invalid.
/// </summary>
/// <param name="asset">Asset to validate</param>
/// <param name="attributeDefinition">Attribute definition of validated attribute</param>
/// <returns>Validation result</returns>
// TODO create separate private method to avoid excessive GetRequiredFields() calls
public bool Validate(Asset asset, IAttributeDefinition attributeDefinition)
{
GetRequiredFields(asset.AssetType);
asset.EnsureAttribute(attributeDefinition);
Attribute attribute = asset.GetAttribute(attributeDefinition);
bool result = attribute != null && !(IsMultiValueAndUnfilled(attribute) || IsSingleValueAndUnfilled(attribute));
if (!result && attribute != null)
{
result = !attribute.HasChanged && !isAttributeUnfilledOnServer(asset, attributeDefinition);
}
return result;
}
internal OrderBy BuildOrderBy(IAssetType assetType, IAttributeDefinition defaultOrderBy) {
var order = new OrderBy();
if (OrderBy.Count > 0) {
foreach(var s in OrderBy) {
order.MinorSort(assetType.GetAttributeDefinition(ResolvePropertyName(s)), APIClient.OrderBy.Order.Ascending);
}
} else {
if(defaultOrderBy != null) {
order.MinorSort(defaultOrderBy, APIClient.OrderBy.Order.Ascending);
}
}
return order;
}
public void TestFixtureSetUp() {
var metaConnector = new V1APIConnector(V1Url + "/meta.v1/");
var dataConnector = new V1APIConnector(V1Url + "/rest-1.v1/", Username, Password);
metaModel = new MetaModel(metaConnector);
services = new Services(metaModel, dataConnector);
storyType = metaModel.GetAssetType("Story");
storyDeleteOperation = storyType.GetOperation("Delete");
nameDef = storyType.GetAttributeDefinition("Name");
scopeDef = storyType.GetAttributeDefinition("Scope");
changeDateDef = storyType.GetAttributeDefinition("ChangeDate");
momentDef = storyType.GetAttributeDefinition("Moment");
attributesToQuery = new[] {nameDef, scopeDef, changeDateDef, momentDef};
}
public override FuncParameter ExecFunc(IAttributeDefinition myAttributeDefinition, Object myCallingObject, IVertex myDBObject, IGraphDB myGraphDB, SecurityToken mySecurityToken, TransactionToken myTransactionToken, params FuncParameter[] myParams)
{
if (myCallingObject is UInt64)
{
var dtValue = Convert.ToDateTime((UInt64)myCallingObject);
return new FuncParameter((Int64)UNIXTimeConversionExtension.ToUnixTimeStamp(dtValue));
}
else if (myCallingObject is DateTime)
{
return new FuncParameter(UNIXTimeConversionExtension.ToUnixTimeStamp((DateTime)myCallingObject));
}
else
{
throw new InvalidTypeException(myCallingObject.GetType().ToString(), "DateTime");
}
}
public Query(IAssetType assetType, bool historical, IAttributeDefinition parentRelation) {
Find = null;
this.assetType = assetType;
isHistorical = historical;
oid = Oid.Null;
this.parentRelation = parentRelation;
if (this.parentRelation != null) {
if(this.parentRelation.AttributeType != AttributeType.Relation) {
throw new ApplicationException("Parent Relation must be a Relation Attribute Type");
}
if(this.parentRelation.IsMultiValue) {
throw new ApplicationException("Parent Relation cannot be multi-value");
}
}
}
public override FuncParameter ExecFunc(IAttributeDefinition myAttributeDefinition, Object myCallingObject, IVertex myDBObject, IGraphDB myGraphDB, SecurityToken mySecurityToken, Int64 myTransactionToken, params FuncParameter[] myParams)
{
if (myCallingObject != null)
{
if (myCallingObject is Int64)
{
return new FuncParameter(UNIXTimeConversionExtension.FromUnixTimeStamp((Int64)myCallingObject));
}
else
{
throw new InvalidTypeException(myCallingObject.GetType().Name, "Int64");
}
}
else
{
throw new NotImplementedException();
}
}
public override FuncParameter ExecFunc(IAttributeDefinition myAttributeDefinition, Object myCallingObject, IVertex myDBObject, IGraphDB myGraphDB, SecurityToken mySecurityToken, Int64 myTransactionToken, params FuncParameter[] myParams)
{
StringBuilder resString = new StringBuilder();
if (myCallingObject != null)
{
if (myCallingObject is string)
{
resString.Append(myCallingObject as String);
}
}
foreach (FuncParameter fp in myParams)
{
resString.Append(fp.Value.ToString());
}
return new FuncParameter(resString.ToString());
}
public static ServiceAttributeDefinition ToServiceAttributeDefinition(IAttributeDefinition myAttributeDefinition)
{
ServiceAttributeDefinition svcAttributeDef = null;
if (myAttributeDefinition != null)
{
switch (myAttributeDefinition.Kind)
{
case AttributeType.Property:
svcAttributeDef = new ServicePropertyDefinition((IPropertyDefinition)myAttributeDefinition);
break;
case AttributeType.OutgoingEdge:
svcAttributeDef = new ServiceOutgoingEdgeDefinition((IOutgoingEdgeDefinition)myAttributeDefinition);
break;
case AttributeType.IncomingEdge:
svcAttributeDef = new ServiceIncomingEdgeDefinition((IIncomingEdgeDefinition)myAttributeDefinition);
break;
case AttributeType.BinaryProperty:
svcAttributeDef = new ServiceBinaryPropertyDefinition((IBinaryPropertyDefinition)myAttributeDefinition);
break;
}
}
return svcAttributeDef;
}
public override FuncParameter ExecFunc(IAttributeDefinition myAttributeDefinition, Object myCallingObject, IVertex myDBObject, IGraphDB myGraphDB, SecurityToken mySecurityToken, TransactionToken myTransactionToken, params FuncParameter[] myParams)
{
var currentInnerEdgeType = ((IOutgoingEdgeDefinition)myAttributeDefinition).InnerEdgeType;
bool orderByWeight = false;
IPropertyDefinition weightProperty = null;
int numOfEntries = Convert.ToInt32(myParams[0].Value);
if (currentInnerEdgeType.HasProperty("Weight"))
{
orderByWeight = true;
weightProperty = currentInnerEdgeType.GetPropertyDefinition("Weight");
}
if (myCallingObject is IHyperEdge)
{
var hyperEdge = myCallingObject as IHyperEdge;
if (orderByWeight)
{
var topVertices = hyperEdge.InvokeHyperEdgeFunc<IEnumerable<IVertex>>(singleEdges =>
{
return singleEdges
.OrderByDescending(edge => weightProperty.GetValue(edge))
.Select(aOrderedEdge => aOrderedEdge.GetTargetVertex());
}).Take(numOfEntries);
return new FuncParameter(topVertices);
}
else
{
return new FuncParameter(hyperEdge.GetTargetVertices().Take(numOfEntries));
}
}
throw new InvalidTypeException(myCallingObject.GetType().ToString(), "IHyperEdge");
}
private QueryResult Query(Oid memberId, IAttributeDefinition attribute)
{
QueryResult result = null;
var query = new Query(memberId);
if (attribute != null)
{
query.Selection.Add(attribute);
}
try
{
result = _services.Retrieve(query);
}
catch (Exception e)
{
if (e is ConnectionException || e is APIException || e is OidException)
{
Console.WriteLine(e.StackTrace);
}
throw;
}
return result;
}
public override int Export()
{
IAssetType assetType = _metaAPI.GetAssetType("Test");
Query query = new Query(assetType);
IAttributeDefinition assetStateAttribute = assetType.GetAttributeDefinition("AssetState");
query.Selection.Add(assetStateAttribute);
IAttributeDefinition assetNumberAttribute = assetType.GetAttributeDefinition("Number");
query.Selection.Add(assetNumberAttribute);
IAttributeDefinition ownersAttribute = assetType.GetAttributeDefinition("Owners.ID");
query.Selection.Add(ownersAttribute);
IAttributeDefinition goalsAttribute = assetType.GetAttributeDefinition("Goals.ID");
query.Selection.Add(goalsAttribute);
IAttributeDefinition descriptionAttribute = assetType.GetAttributeDefinition("Description");
query.Selection.Add(descriptionAttribute);
IAttributeDefinition nameAttribute = assetType.GetAttributeDefinition("Name");
query.Selection.Add(nameAttribute);
IAttributeDefinition referenceAttribute = assetType.GetAttributeDefinition("Reference");
query.Selection.Add(referenceAttribute);
IAttributeDefinition toDoAttribute = assetType.GetAttributeDefinition("ToDo");
query.Selection.Add(toDoAttribute);
IAttributeDefinition detailEstimateAttribute = assetType.GetAttributeDefinition("DetailEstimate");
query.Selection.Add(detailEstimateAttribute);
IAttributeDefinition stepsAttribute = assetType.GetAttributeDefinition("Steps");
query.Selection.Add(stepsAttribute);
IAttributeDefinition inputsAttribute = assetType.GetAttributeDefinition("Inputs");
query.Selection.Add(inputsAttribute);
IAttributeDefinition setupAttribute = assetType.GetAttributeDefinition("Setup");
query.Selection.Add(setupAttribute);
IAttributeDefinition orderAttribute = assetType.GetAttributeDefinition("Order");
query.Selection.Add(orderAttribute);
IAttributeDefinition estimateAttribute = assetType.GetAttributeDefinition("Estimate");
query.Selection.Add(estimateAttribute);
IAttributeDefinition versionTestedAttribute = assetType.GetAttributeDefinition("VersionTested");
query.Selection.Add(versionTestedAttribute);
IAttributeDefinition actualResultsAttribute = assetType.GetAttributeDefinition("ActualResults");
query.Selection.Add(actualResultsAttribute);
IAttributeDefinition expectedResultsAttribute = assetType.GetAttributeDefinition("ExpectedResults");
query.Selection.Add(expectedResultsAttribute);
IAttributeDefinition statusAttribute = assetType.GetAttributeDefinition("Status");
query.Selection.Add(statusAttribute);
IAttributeDefinition categoryAttribute = assetType.GetAttributeDefinition("Category");
query.Selection.Add(categoryAttribute);
IAttributeDefinition parentAttribute = assetType.GetAttributeDefinition("Parent");
query.Selection.Add(parentAttribute);
IAttributeDefinition generatedFromAttribute = assetType.GetAttributeDefinition("GeneratedFrom");
query.Selection.Add(generatedFromAttribute);
//Filter on parent scope.
IAttributeDefinition parentScopeAttribute = assetType.GetAttributeDefinition("Scope.ParentMeAndUp");
FilterTerm term = new FilterTerm(parentScopeAttribute);
term.Equal(_config.V1SourceConnection.Project);
query.Filter = term;
string SQL = BuildTestInsertStatement();
if (_config.V1Configurations.PageSize != 0)
{
query.Paging.Start = 0;
query.Paging.PageSize = _config.V1Configurations.PageSize;
}
int assetCounter = 0;
int assetTotal = 0;
do
{
QueryResult result = _dataAPI.Retrieve(query);
assetTotal = result.TotalAvaliable;
foreach (Asset asset in result.Assets)
{
using (SqlCommand cmd = new SqlCommand())
{
//NAME NPI MASK:
object name = GetScalerValue(asset.GetAttribute(nameAttribute));
if (_config.V1Configurations.UseNPIMasking == true && name != DBNull.Value)
{
name = ExportUtils.RemoveNPI(name.ToString());
}
//DESCRIPTION NPI MASK:
object description = GetScalerValue(asset.GetAttribute(descriptionAttribute));
if (_config.V1Configurations.UseNPIMasking == true && description != DBNull.Value)
{
description = ExportUtils.RemoveNPI(description.ToString());
}
//REFERENCE NPI MASK:
object reference = GetScalerValue(asset.GetAttribute(referenceAttribute));
if (_config.V1Configurations.UseNPIMasking == true && reference != DBNull.Value)
{
reference = ExportUtils.RemoveNPI(reference.ToString());
}
//STEPS NPI MASK:
object steps = GetScalerValue(asset.GetAttribute(stepsAttribute));
if (_config.V1Configurations.UseNPIMasking == true && steps != DBNull.Value)
{
steps = ExportUtils.RemoveNPI(steps.ToString());
}
//INPUTS NPI MASK:
object inputs = GetScalerValue(asset.GetAttribute(inputsAttribute));
if (_config.V1Configurations.UseNPIMasking == true && inputs != DBNull.Value)
{
inputs = ExportUtils.RemoveNPI(inputs.ToString());
}
//SETUP NPI MASK:
object setup = GetScalerValue(asset.GetAttribute(setupAttribute));
if (_config.V1Configurations.UseNPIMasking == true && setup != DBNull.Value)
{
setup = ExportUtils.RemoveNPI(setup.ToString());
}
//VERSION TESTED NPI MASK:
object versionTested = GetScalerValue(asset.GetAttribute(versionTestedAttribute));
if (_config.V1Configurations.UseNPIMasking == true && versionTested != DBNull.Value)
{
versionTested = ExportUtils.RemoveNPI(versionTested.ToString());
}
//ACTUAL RESULTS NPI MASK:
object actualResults = GetScalerValue(asset.GetAttribute(actualResultsAttribute));
if (_config.V1Configurations.UseNPIMasking == true && actualResults != DBNull.Value)
{
actualResults = ExportUtils.RemoveNPI(actualResults.ToString());
}
//EXPECTED RESULTS NPI MASK:
object expectedResults = GetScalerValue(asset.GetAttribute(expectedResultsAttribute));
if (_config.V1Configurations.UseNPIMasking == true && expectedResults != DBNull.Value)
{
expectedResults = ExportUtils.RemoveNPI(expectedResults.ToString());
}
cmd.Connection = _sqlConn;
cmd.CommandText = SQL;
cmd.CommandType = System.Data.CommandType.Text;
cmd.Parameters.AddWithValue("@AssetOID", asset.Oid.ToString());
cmd.Parameters.AddWithValue("@AssetState", GetScalerValue(asset.GetAttribute(assetStateAttribute)));
cmd.Parameters.AddWithValue("@AssetNumber", GetScalerValue(asset.GetAttribute(assetNumberAttribute)));
cmd.Parameters.AddWithValue("@Owners", GetMultiRelationValues(asset.GetAttribute(ownersAttribute)));
cmd.Parameters.AddWithValue("@Goals", GetMultiRelationValues(asset.GetAttribute(goalsAttribute)));
cmd.Parameters.AddWithValue("@Description", description);
cmd.Parameters.AddWithValue("@Name", name);
cmd.Parameters.AddWithValue("@Reference", reference);
cmd.Parameters.AddWithValue("@ToDo", GetScalerValue(asset.GetAttribute(toDoAttribute)));
cmd.Parameters.AddWithValue("@DetailEstimate", GetScalerValue(asset.GetAttribute(detailEstimateAttribute)));
cmd.Parameters.AddWithValue("@Steps", steps);
cmd.Parameters.AddWithValue("@Inputs", inputs);
cmd.Parameters.AddWithValue("@Setup", setup);
cmd.Parameters.AddWithValue("@Order", GetScalerValue(asset.GetAttribute(orderAttribute)));
cmd.Parameters.AddWithValue("@Estimate", GetScalerValue(asset.GetAttribute(estimateAttribute)));
cmd.Parameters.AddWithValue("@VersionTested", versionTested);
cmd.Parameters.AddWithValue("@ActualResults", actualResults);
cmd.Parameters.AddWithValue("@ExpectedResults", expectedResults);
cmd.Parameters.AddWithValue("@Status", GetSingleRelationValue(asset.GetAttribute(statusAttribute)));
cmd.Parameters.AddWithValue("@Category", GetSingleRelationValue(asset.GetAttribute(categoryAttribute)));
cmd.Parameters.AddWithValue("@Parent", GetSingleRelationValue(asset.GetAttribute(parentAttribute)));
cmd.Parameters.AddWithValue("@GeneratedFrom", GetSingleRelationValue(asset.GetAttribute(generatedFromAttribute)));
cmd.ExecuteNonQuery();
}
assetCounter++;
}
query.Paging.Start = assetCounter;
} while (assetCounter != assetTotal);
DeleteEpicTests();
return(assetCounter);
}
public override int Import()
{
string customV1IDFieldName = GetV1IDCustomFieldName("Story");
_logger.Info("Custom field Config is {0}", _config.V1Configurations.CustomV1IDField);
_logger.Info("Custom Field Name is {0}", customV1IDFieldName);
SqlDataReader sdr = GetImportDataFromDBTableWithOrder("Stories");
//_logger.Info("Story Count is {0}", sdr.RecordsAffected);
int importCount = 0;
while (sdr.Read())
{
try
{
//SPECIAL CASE: No assigned scope, fail to import.
if (String.IsNullOrEmpty(sdr["Scope"].ToString()))
{
UpdateImportStatus("Stories", sdr["AssetOID"].ToString(), ImportStatuses.FAILED, "Story has no scope.");
continue;
}
IAssetType assetType = _metaAPI.GetAssetType("Story");
Asset asset = _dataAPI.New(assetType, null);
if (String.IsNullOrEmpty(customV1IDFieldName) == false)
{
IAttributeDefinition customV1IDAttribute = assetType.GetAttributeDefinition(customV1IDFieldName);
asset.SetAttributeValue(customV1IDAttribute, sdr["AssetNumber"].ToString());
}
IAttributeDefinition fullNameAttribute = assetType.GetAttributeDefinition("Name");
asset.SetAttributeValue(fullNameAttribute, AddV1IDToTitle(sdr["Name"].ToString(), sdr["AssetNumber"].ToString()));
IAttributeDefinition descAttribute = assetType.GetAttributeDefinition("Description");
asset.SetAttributeValue(descAttribute, sdr["Description"].ToString());
IAttributeDefinition iterationAttribute = assetType.GetAttributeDefinition("Timebox");
asset.SetAttributeValue(iterationAttribute, GetNewAssetOIDFromDB(sdr["Timebox"].ToString(), "Iterations"));
IAttributeDefinition customerAttribute = assetType.GetAttributeDefinition("Customer");
asset.SetAttributeValue(customerAttribute, GetNewAssetOIDFromDB(sdr["Customer"].ToString()));
if (String.IsNullOrEmpty(sdr["Owners"].ToString()) == false)
{
AddMultiValueRelation(assetType, asset, "Members", "Owners", sdr["Owners"].ToString());
}
IAttributeDefinition teamAttribute = assetType.GetAttributeDefinition("Team");
asset.SetAttributeValue(teamAttribute, GetNewAssetOIDFromDB(sdr["Team"].ToString()));
if (String.IsNullOrEmpty(sdr["Goals"].ToString()) == false)
{
AddMultiValueRelation(assetType, asset, "Goals", sdr["Goals"].ToString());
}
//TO DO: Test for V1 version number for epic conversion. Right now, assume epic.
IAttributeDefinition superAttribute = assetType.GetAttributeDefinition("Super");
asset.SetAttributeValue(superAttribute, GetNewEpicAssetOIDFromDB(sdr["Super"].ToString()));
IAttributeDefinition referenceAttribute = assetType.GetAttributeDefinition("Reference");
asset.SetAttributeValue(referenceAttribute, sdr["Reference"].ToString());
IAttributeDefinition detailEstimateAttribute = assetType.GetAttributeDefinition("DetailEstimate");
asset.SetAttributeValue(detailEstimateAttribute, sdr["DetailEstimate"].ToString());
IAttributeDefinition estimateAttribute = assetType.GetAttributeDefinition("Estimate");
asset.SetAttributeValue(estimateAttribute, sdr["Estimate"].ToString());
IAttributeDefinition toDoAttribute = assetType.GetAttributeDefinition("ToDo");
asset.SetAttributeValue(toDoAttribute, sdr["ToDo"].ToString());
IAttributeDefinition lastVersionAttribute = assetType.GetAttributeDefinition("LastVersion");
asset.SetAttributeValue(lastVersionAttribute, sdr["LastVersion"].ToString());
IAttributeDefinition originalEstimateAttribute = assetType.GetAttributeDefinition("OriginalEstimate");
asset.SetAttributeValue(originalEstimateAttribute, sdr["OriginalEstimate"].ToString());
IAttributeDefinition requestedByAttribute = assetType.GetAttributeDefinition("RequestedBy");
asset.SetAttributeValue(requestedByAttribute, sdr["RequestedBy"].ToString());
IAttributeDefinition valueAttribute = assetType.GetAttributeDefinition("Value");
asset.SetAttributeValue(valueAttribute, sdr["Value"].ToString());
IAttributeDefinition scopeAttribute = assetType.GetAttributeDefinition("Scope");
asset.SetAttributeValue(scopeAttribute, GetNewAssetOIDFromDB(sdr["Scope"].ToString(), "Projects"));
IAttributeDefinition riskAttribute = assetType.GetAttributeDefinition("Risk");
asset.SetAttributeValue(riskAttribute, GetNewListTypeAssetOIDFromDB(sdr["Risk"].ToString()));
IAttributeDefinition sourceAttribute = assetType.GetAttributeDefinition("Source");
if (String.IsNullOrEmpty(_config.V1Configurations.SourceListTypeValue) == false)
{
asset.SetAttributeValue(sourceAttribute, _config.V1Configurations.SourceListTypeValue);
}
else
{
asset.SetAttributeValue(sourceAttribute, GetNewListTypeAssetOIDFromDB(sdr["Source"].ToString()));
}
IAttributeDefinition priorityAttribute = assetType.GetAttributeDefinition("Priority");
asset.SetAttributeValue(priorityAttribute, GetNewListTypeAssetOIDFromDB(sdr["Priority"].ToString()));
IAttributeDefinition statusAttribute = assetType.GetAttributeDefinition("Status");
asset.SetAttributeValue(statusAttribute, GetNewListTypeAssetOIDFromDB(sdr["Status"].ToString()));
//HACK: For Rally import, needs to be refactored.
//asset.SetAttributeValue(statusAttribute, GetNewListTypeAssetOIDFromDB("StoryStatus", sdr["Status"].ToString()));
IAttributeDefinition categoryAttribute = assetType.GetAttributeDefinition("Category");
asset.SetAttributeValue(categoryAttribute, GetNewListTypeAssetOIDFromDB(sdr["Category"].ToString()));
//Themes
IAttributeDefinition parentAttribute = assetType.GetAttributeDefinition("Parent");
asset.SetAttributeValue(parentAttribute, GetNewAssetOIDFromDB(sdr["Parent"].ToString()));
if (String.IsNullOrEmpty(sdr["Requests"].ToString()) == false)
{
AddMultiValueRelation(assetType, asset, "Requests", sdr["Requests"].ToString());
}
if (String.IsNullOrEmpty(sdr["BlockingIssues"].ToString()) == false)
{
AddMultiValueRelation(assetType, asset, "BlockingIssues", sdr["BlockingIssues"].ToString());
//_logger.Info("Asset is {0}", assetType.DisplayName);
}
if (String.IsNullOrEmpty(sdr["Issues"].ToString()) == false)
{
AddMultiValueRelation(assetType, asset, "Issues", sdr["Issues"].ToString());
}
IAttributeDefinition benefitsAttribute = assetType.GetAttributeDefinition("Benefits");
asset.SetAttributeValue(benefitsAttribute, sdr["Benefits"].ToString());
_dataAPI.Save(asset);
if (sdr["AssetState"].ToString() == "Template")
{
ExecuteOperationInV1("Story.MakeTemplate", asset.Oid);
}
string newAssetNumber = GetAssetNumberV1("Story", asset.Oid.Momentless.ToString());
UpdateAssetRecordWithNumber("Stories", sdr["AssetOID"].ToString(), asset.Oid.Momentless.ToString(), newAssetNumber, ImportStatuses.IMPORTED, "Story imported.");
importCount++;
//_logger.Info("Story is {0} and the Count is {1}", newAssetNumber, importCount);
}
catch (Exception ex)
{
if (_config.V1Configurations.LogExceptions == true)
{
string error = ex.Message.Replace("'", ":");
UpdateImportStatus("Stories", sdr["AssetOID"].ToString(), ImportStatuses.FAILED, error);
//_logger.Info("Story is {0} ", sdr["AssetOID"].ToString());
continue;
}
else
{
throw ex;
}
}
}
sdr.Close();
SetStoryDependencies();
return(importCount);
}
public override int Import()
{
//HACK: For Rally import.
//SqlDataReader sdr = GetImportDataFromSproc("spGetAttachmentsForImport");
SqlDataReader sdr = GetImportDataFromSproc("spGetAttachmentsForRallyImport");
int importCount = 0;
while (sdr.Read())
{
try
{
//HACK: For Rally import.
//string newAssetOID = GetNewAssetOIDFromDB(sdr["Asset"].ToString());
if (String.IsNullOrEmpty(sdr["Asset"].ToString()) ||
String.IsNullOrEmpty(sdr["Content"].ToString()) ||
String.IsNullOrEmpty(sdr["ContentType"].ToString()) ||
String.IsNullOrEmpty(sdr["Filename"].ToString()) ||
String.IsNullOrEmpty(sdr["Name"].ToString()) ||
String.IsNullOrEmpty(sdr["NewAssetOID"].ToString()))
{
UpdateImportStatus("Attachments", sdr["AssetOID"].ToString(), ImportStatuses.FAILED, "Attachment missing required field.");
continue;
}
IAssetType assetType = _metaAPI.GetAssetType("Attachment");
Asset asset = _dataAPI.New(assetType, null);
IAttributeDefinition fullNameAttribute = assetType.GetAttributeDefinition("Name");
asset.SetAttributeValue(fullNameAttribute, sdr["Name"].ToString());
IAttributeDefinition descAttribute = assetType.GetAttributeDefinition("Description");
asset.SetAttributeValue(descAttribute, sdr["Description"].ToString());
IAttributeDefinition contentTypeAttribute = assetType.GetAttributeDefinition("ContentType");
asset.SetAttributeValue(contentTypeAttribute, sdr["ContentType"].ToString());
IAttributeDefinition filenameAttribute = assetType.GetAttributeDefinition("Filename");
asset.SetAttributeValue(filenameAttribute, sdr["Filename"].ToString());
IAttributeDefinition categoryAttribute = assetType.GetAttributeDefinition("Category");
asset.SetAttributeValue(categoryAttribute, GetNewListTypeAssetOIDFromDB(sdr["Category"].ToString()));
IAttributeDefinition assetAttribute = assetType.GetAttributeDefinition("Asset");
asset.SetAttributeValue(assetAttribute, sdr["NewAssetOID"].ToString());
IAttributeDefinition contentAttribute = assetType.GetAttributeDefinition("Content");
asset.SetAttributeValue(contentAttribute, String.Empty);
//Save the attachment to get the new AssetOID.
_dataAPI.Save(asset);
//Now save the binary content of the attachment.
UploadAttachmentContent(asset.Oid.Key.ToString(), (byte[])sdr["Content"], sdr["ContentType"].ToString());
UpdateNewAssetOIDAndStatus("Attachments", sdr["AssetOID"].ToString(), asset.Oid.Momentless.ToString(), ImportStatuses.IMPORTED, "Attachment imported.");
importCount++;
}
catch (Exception ex)
{
if (_config.V1Configurations.LogExceptions == true)
{
string error = ex.Message.Replace("'", ":");
UpdateImportStatus("Attachments", sdr["AssetOID"].ToString(), ImportStatuses.FAILED, error);
continue;
}
else
{
throw ex;
}
}
}
sdr.Close();
return(importCount);
}
public override int Export()
{
IAssetType assetType = _metaAPI.GetAssetType("Attachment");
Query query = new Query(assetType);
IAttributeDefinition nameAttribute = assetType.GetAttributeDefinition("Name");
query.Selection.Add(nameAttribute);
IAttributeDefinition contentAttribute = assetType.GetAttributeDefinition("Content");
query.Selection.Add(contentAttribute);
IAttributeDefinition contentTypeAttribute = assetType.GetAttributeDefinition("ContentType");
query.Selection.Add(contentTypeAttribute);
IAttributeDefinition fileNameAttribute = assetType.GetAttributeDefinition("Filename");
query.Selection.Add(fileNameAttribute);
IAttributeDefinition descriptionAttribute = assetType.GetAttributeDefinition("Description");
query.Selection.Add(descriptionAttribute);
IAttributeDefinition categoryAttribute = assetType.GetAttributeDefinition("Category");
query.Selection.Add(categoryAttribute);
IAttributeDefinition assetAttribute = assetType.GetAttributeDefinition("Asset");
query.Selection.Add(assetAttribute);
string SQL = BuildAttachmentInsertStatement();
if (_config.V1Configurations.PageSize != 0)
{
query.Paging.Start = 0;
query.Paging.PageSize = _config.V1Configurations.PageSize;
}
int assetCounter = 0;
int assetTotal = 0;
do
{
QueryResult result = _dataAPI.Retrieve(query);
assetTotal = result.TotalAvaliable;
foreach (Asset asset in result.Assets)
{
using (SqlCommand cmd = new SqlCommand())
{
//NAME NPI MASK:
object name = GetScalerValue(asset.GetAttribute(nameAttribute));
if (_config.V1Configurations.UseNPIMasking == true && name != DBNull.Value)
{
name = ExportUtils.RemoveNPI(name.ToString());
}
//DESCRIPTION NPI MASK:
object description = GetScalerValue(asset.GetAttribute(descriptionAttribute));
if (_config.V1Configurations.UseNPIMasking == true && description != DBNull.Value)
{
description = ExportUtils.RemoveNPI(description.ToString());
}
cmd.Connection = _sqlConn;
cmd.CommandText = SQL;
cmd.CommandType = System.Data.CommandType.Text;
cmd.Parameters.AddWithValue("@AssetOID", asset.Oid.ToString());
cmd.Parameters.AddWithValue("@Name", name);
cmd.Parameters.AddWithValue("@Content", GetAttachmentValue(asset.Oid.Key.ToString()));
cmd.Parameters.AddWithValue("@ContentType", GetScalerValue(asset.GetAttribute(contentTypeAttribute)));
cmd.Parameters.AddWithValue("@FileName", GetScalerValue(asset.GetAttribute(fileNameAttribute)));
cmd.Parameters.AddWithValue("@Description", description);
cmd.Parameters.AddWithValue("@Category", GetSingleRelationValue(asset.GetAttribute(categoryAttribute)));
cmd.Parameters.AddWithValue("@Asset", GetSingleRelationValue(asset.GetAttribute(assetAttribute)));
cmd.ExecuteNonQuery();
}
assetCounter++;
}
query.Paging.Start = assetCounter;
} while (assetCounter != assetTotal);
return(assetCounter);
}
public void RemoveAttributeValue(IAttributeDefinition attribdef, object value)
{
EnsureAttribute(attribdef).RemoveValue(value);
}
public void CanParseGuidAttributeDefinitionType()
{
IAttributeDefinition def = Meta.GetAttributeDefinition("Publication.Payload");
Assert.AreEqual(AttributeType.Guid, def.AttributeType);
}
public bool TryGetAttributeDefinition(string token, out IAttributeDefinition def)
{
def = null;
try { def = LookupAttributeDefinition(token); } catch (Exception) { }
return(def != null);
}
public Term(IAttributeDefinition attribdef, Order order)
{
AttributeDefinition = attribdef;
Order = order;
}
public override int Import()
{
string customV1IDFieldName = GetV1IDCustomFieldName("Task");
//SqlDataReader sdr = GetImportDataFromSproc("spGetTasksForImport");
SqlDataReader sdr = GetImportDataFromDBTableWithOrder("Tasks");
int importCount = 0;
while (sdr.Read())
{
try
{
//CHECK DATA: Task must have a name.
if (String.IsNullOrEmpty(sdr["Name"].ToString()))
{
UpdateImportStatus("Tasks", sdr["AssetOID"].ToString(), ImportStatuses.FAILED, "Task name attribute is required.");
continue;
}
//CHECK DATA: Task must have a parent.
if (String.IsNullOrEmpty(sdr["Parent"].ToString()))
{
UpdateImportStatus("Tasks", sdr["AssetOID"].ToString(), ImportStatuses.FAILED, "Task parent attribute is required.");
continue;
}
IAssetType assetType = _metaAPI.GetAssetType("Task");
Asset asset = _dataAPI.New(assetType, null);
if (String.IsNullOrEmpty(customV1IDFieldName) == false)
{
IAttributeDefinition customV1IDAttribute = assetType.GetAttributeDefinition(customV1IDFieldName);
asset.SetAttributeValue(customV1IDAttribute, sdr["AssetNumber"].ToString());
}
IAttributeDefinition fullNameAttribute = assetType.GetAttributeDefinition("Name");
asset.SetAttributeValue(fullNameAttribute, AddV1IDToTitle(sdr["Name"].ToString(), sdr["AssetNumber"].ToString()));
IAttributeDefinition descAttribute = assetType.GetAttributeDefinition("Description");
asset.SetAttributeValue(descAttribute, sdr["Description"].ToString());
//if (String.IsNullOrEmpty(sdr["Customer"].ToString()) == false)
//{
// IAttributeDefinition customerAttribute = assetType.GetAttributeDefinition("Customer");
// asset.SetAttributeValue(customerAttribute, GetNewAssetOIDFromDB(sdr["Customer"].ToString()));
//}
if (String.IsNullOrEmpty(sdr["Owners"].ToString()) == false)
{
AddMultiValueRelation(assetType, asset, "Members", "Owners", sdr["Owners"].ToString());
}
if (String.IsNullOrEmpty(sdr["Goals"].ToString()) == false)
{
AddMultiValueRelation(assetType, asset, "Goals", sdr["Goals"].ToString());
}
IAttributeDefinition referenceAttribute = assetType.GetAttributeDefinition("Reference");
asset.SetAttributeValue(referenceAttribute, sdr["Reference"].ToString());
IAttributeDefinition detailEstimateAttribute = assetType.GetAttributeDefinition("DetailEstimate");
asset.SetAttributeValue(detailEstimateAttribute, sdr["DetailEstimate"].ToString());
IAttributeDefinition toDoAttribute = assetType.GetAttributeDefinition("ToDo");
asset.SetAttributeValue(toDoAttribute, sdr["ToDo"].ToString());
IAttributeDefinition estimateAttribute = assetType.GetAttributeDefinition("Estimate");
asset.SetAttributeValue(estimateAttribute, sdr["Estimate"].ToString());
IAttributeDefinition lastVersionAttribute = assetType.GetAttributeDefinition("LastVersion");
asset.SetAttributeValue(lastVersionAttribute, sdr["LastVersion"].ToString());
if (String.IsNullOrEmpty(sdr["Category"].ToString()) == false)
{
IAttributeDefinition categoryAttribute = assetType.GetAttributeDefinition("Category");
asset.SetAttributeValue(categoryAttribute, GetNewListTypeAssetOIDFromDB(sdr["Category"].ToString()));
}
IAttributeDefinition sourceAttribute = assetType.GetAttributeDefinition("Source");
asset.SetAttributeValue(sourceAttribute, GetNewListTypeAssetOIDFromDB(sdr["Source"].ToString()));
if (String.IsNullOrEmpty(sdr["Status"].ToString()) == false)
{
IAttributeDefinition statusAttribute = assetType.GetAttributeDefinition("Status");
asset.SetAttributeValue(statusAttribute, GetNewListTypeAssetOIDFromDB(sdr["Status"].ToString()));
//HACK: For Rally import, needs to be refactored.
//asset.SetAttributeValue(statusAttribute, GetNewListTypeAssetOIDFromDB("TaskStatus", sdr["Status"].ToString()));
}
//HACK: For Rally import, needs to be refactored.
IAttributeDefinition parentAttribute = assetType.GetAttributeDefinition("Parent");
if (String.IsNullOrEmpty(sdr["ParentType"].ToString()) == true)
{
asset.SetAttributeValue(parentAttribute, GetNewAssetOIDFromDB(sdr["Parent"].ToString()));
}
else
{
string newAssetOID = null;
if (sdr["ParentType"].ToString() == "Story")
{
newAssetOID = GetNewAssetOIDFromDB(sdr["Parent"].ToString(), "Stories");
if (String.IsNullOrEmpty(newAssetOID) == false)
{
asset.SetAttributeValue(parentAttribute, newAssetOID);
}
else
{
newAssetOID = GetNewAssetOIDFromDB(sdr["Parent"].ToString(), "Epics");
if (String.IsNullOrEmpty(newAssetOID) == false)
{
asset.SetAttributeValue(parentAttribute, newAssetOID);
}
else
{
throw new Exception("Import failed. Parent could not be found.");
}
}
}
else
{
newAssetOID = GetNewAssetOIDFromDB(sdr["Parent"].ToString(), "Defects");
if (String.IsNullOrEmpty(newAssetOID) == false)
{
asset.SetAttributeValue(parentAttribute, GetNewAssetOIDFromDB(sdr["Parent"].ToString(), "Defects"));
}
else
{
throw new Exception("Import failed. Parent defect could not be found.");
}
}
}
_dataAPI.Save(asset);
string newAssetNumber = GetAssetNumberV1("Task", asset.Oid.Momentless.ToString());
UpdateAssetRecordWithNumber("Tasks", sdr["AssetOID"].ToString(), asset.Oid.Momentless.ToString(), newAssetNumber, ImportStatuses.IMPORTED, "Task imported.");
importCount++;
}
catch (Exception ex)
{
if (_config.V1Configurations.LogExceptions == true)
{
string error = ex.Message.Replace("'", ":");
UpdateImportStatus("Tasks", sdr["AssetOID"].ToString(), ImportStatuses.FAILED, error);
continue;
}
else
{
throw ex;
}
}
}
sdr.Close();
return(importCount);
}
private void SaveAttributeDefinition(IAttributeDefinition attribdef)
{
_map[attribdef.Token] = attribdef;
}
/// <summary>
/// Check whether the provided attribute is required in current VersionOne server setup.
/// </summary>
/// <param name="definition"></param>
/// <returns></returns>
public bool IsRequired(IAttributeDefinition definition)
{
GetRequiredFields(definition.AssetType);
return IsRequiredField(definition.AssetType, definition.Name);
}
public bool RunIsVisible(IAttributeDefinition item)
{
return(base.IsVisible(item));
}
public override FuncParameter ExecFunc(IAttributeDefinition myAttributeDefinition,
Object myCallingObject,
IVertex myStartVertex,
IGraphDB myGraphDB,
SecurityToken mySecurityToken,
Int64 myTransactionToken,
params FuncParameter[] myParams)
{
#region initialization
if (myStartVertex == null)
{
throw new InvalidFunctionParameterException("StartVertex", "Vertex that represents the start vertex", "null");
}
//set the start node
var currentVertex = myStartVertex;
if ((myParams[0].Value as IEnumerable <IVertex>).First() == null)
{
throw new InvalidFunctionParameterException("EndVertex", "Set of vertices that represents the target vertices", "null");
}
//set the target node
var endVertex = (myParams[0].Value as IEnumerable <IVertex>).First();
//set the maximum depth
if (myAttributeDefinition == null)
{
throw new InvalidFunctionParameterException("EdgeType ", "Edge type not found", "faild");
}
UInt64 maxDepth = Convert.ToUInt64(myParams[1].Value);
if (maxDepth < 1)
{
throw new InvalidFunctionParameterException("MaxDepth", "Max depth to low", maxDepth.ToString());
}
var myType = myGraphDB.GetVertexType <IVertexType>(
mySecurityToken,
myTransactionToken,
new sones.GraphDB.Request.RequestGetVertexType(myAttributeDefinition.RelatedType.Name),
(statistics, type) => type);
var myEdgeType = myAttributeDefinition.ID;
var hasProperty = myType.GetOutgoingEdgeDefinition(myAttributeDefinition.Name).InnerEdgeType.HasProperty("Weight");
long myPropertyID = 0;
if (hasProperty == true)
{
myPropertyID = myType.GetOutgoingEdgeDefinition(myAttributeDefinition.Name).InnerEdgeType.GetPropertyDefinition("Weight").ID;
}
Dictionary <IOutgoingEdgeDefinition, Tuple <bool, long> > edgeTypeID = new Dictionary <IOutgoingEdgeDefinition, Tuple <bool, long> >();
var edgeType = myParams[2].Value.ToString();
if (edgeType == "")
{
edgeTypeID.Add(myType.GetOutgoingEdgeDefinition(myAttributeDefinition.Name), Tuple.Create(hasProperty, myPropertyID));
}
else
{
if (edgeType.Contains("all edgeType"))
{
edgeTypeID = this.AllEdgeWithTargetVertex(myType);
}
else
{
edgeTypeID = this.StringParser(edgeType, myType);
if (!edgeTypeID.ContainsKey(myType.GetOutgoingEdgeDefinition(myAttributeDefinition.Name)))
{
edgeTypeID.Add(myType.GetOutgoingEdgeDefinition(myAttributeDefinition.Name), Tuple.Create(hasProperty, myPropertyID));
}
}
}
List <UInt64> depthBuffer = new List <UInt64>();
List <Tuple <ISingleEdge, IOutgoingEdgeDefinition> > edgeBuffer = new List <Tuple <ISingleEdge, IOutgoingEdgeDefinition> >();
List <double> distanceBuffer = new List <double>();
List <IVertex> VertexBuffer = new List <IVertex>();
BufferDijkstra buf = new BufferDijkstra();
DataDijkstra lists = new DataDijkstra();
buf.Add(myStartVertex, 0, 0);
lists.Add(currentVertex, 0, 0, null, null, currentVertex);
bool endVertexFlag = false;
#endregion
#region Dijkstra algorithm
double currentVertexDistance = 0;
ulong currentVertexDepth = 0;
double endVertexDistance = 0;
ulong endvertexDepth = 0;
Stopwatch clock = new Stopwatch();
clock.Start();
while (buf.Count != 0)
{
if (currentVertexDepth < maxDepth)
{
List <Tuple <ISingleEdge, IOutgoingEdgeDefinition> > AllsingleEdge = new List <Tuple <ISingleEdge, IOutgoingEdgeDefinition> >();
foreach (IOutgoingEdgeDefinition id in edgeTypeID.Keys)
{
var hyperEdge = currentVertex.GetOutgoingHyperEdge(id.ID);
if (hyperEdge != null)
{
var singleEdge = hyperEdge.GetAllEdges();
foreach (ISingleEdge value in singleEdge)
{
AllsingleEdge.Add(Tuple.Create(value, id));
}
}
}
if (AllsingleEdge != null)
{
for (int iCount = 0; iCount < AllsingleEdge.Count(); iCount++)
{
var elementSingleEdge = AllsingleEdge.ElementAt(iCount);
var TargetVertex = elementSingleEdge.Item1.GetTargetVertex();
double current_distance = 0;
if (edgeTypeID[elementSingleEdge.Item2].Item1 == true)
{
current_distance = Math.Abs(AllsingleEdge.ElementAt(iCount).Item1.GetProperty <double>(edgeTypeID[elementSingleEdge.Item2].Item2));
}
else
{
current_distance = 1;
}
var current_singleEdge = AllsingleEdge.ElementAt(iCount).Item1;
var TargetVertexID = lists.GetElement(TargetVertex.VertexID);
if (TargetVertexID == null)
{
if (!endVertexFlag)
{
buf.Add(TargetVertex,
current_distance + currentVertexDistance,
currentVertexDepth + 1);
lists.Add(TargetVertex,
current_distance + currentVertexDistance,
currentVertexDepth + 1,
current_singleEdge,
elementSingleEdge.Item2,
currentVertex);
}
else
if (endVertexDistance > currentVertexDistance + current_distance ||
(endVertexDistance == currentVertexDistance + current_distance &&
endvertexDepth > currentVertexDepth + 1))
{
buf.Add(TargetVertex,
current_distance + currentVertexDistance,
currentVertexDepth + 1);
lists.Add(TargetVertex,
current_distance + currentVertexDistance,
currentVertexDepth + 1,
current_singleEdge,
elementSingleEdge.Item2,
currentVertex);
}
}
else
{
if (currentVertexDistance + current_distance < TargetVertexID.Item2)
{
if (!endVertexFlag)
{
buf.Set(TargetVertexID.Item2, TargetVertex,
current_distance + currentVertexDistance,
currentVertexDepth + 1);
lists.Set(TargetVertex,
current_distance + currentVertexDistance,
currentVertexDepth + 1,
current_singleEdge,
elementSingleEdge.Item2,
currentVertex);
}
else
if (endVertexDistance > currentVertexDistance + current_distance ||
(endVertexDistance == currentVertexDistance + current_distance &&
endvertexDepth > currentVertexDepth + 1))
{
buf.Set(TargetVertexID.Item2, TargetVertex,
current_distance + currentVertexDistance,
currentVertexDepth + 1);
lists.Set(TargetVertex,
current_distance + currentVertexDistance,
currentVertexDepth + 1,
current_singleEdge,
elementSingleEdge.Item2,
currentVertex);
}
}
else if (currentVertexDistance + current_distance == TargetVertexID.Item2 && currentVertexDepth + 1 < TargetVertexID.Item3)
{
if (!endVertexFlag)
{
buf.Set(TargetVertexID.Item2, TargetVertex,
current_distance + currentVertexDistance,
currentVertexDepth + 1);
lists.Set(TargetVertex,
current_distance + currentVertexDistance,
currentVertexDepth + 1,
current_singleEdge,
elementSingleEdge.Item2,
currentVertex);
}
else
if (endVertexDistance > currentVertexDistance + current_distance ||
(endVertexDistance == currentVertexDistance + current_distance &&
endvertexDepth > currentVertexDepth + 1))
{
buf.Set(TargetVertexID.Item2, TargetVertex,
current_distance + currentVertexDistance,
currentVertexDepth + 1);
lists.Set(TargetVertex,
current_distance + currentVertexDistance,
currentVertexDepth + 1,
current_singleEdge,
elementSingleEdge.Item2,
currentVertex);
}
}
}
if (TargetVertex == endVertex)
{
endVertexFlag = true;
var endNode = lists.GetElement(endVertex.VertexID);
endVertexDistance = endNode.Item2;
endvertexDepth = endNode.Item3;
}
}
}
}
//delate from Buffer current Vertex or all
if (currentVertex == endVertex)
{
buf.Clear();
}
else
{
buf.Remove(currentVertexDistance, currentVertex.VertexID);
}
//Minimum distance from Buffer
if (buf.Count != 0)
{
var minVertex = buf.Min();
currentVertex = minVertex.Item1;
currentVertexDistance = minVertex.Item2;
currentVertexDepth = minVertex.Item3;
}
}
#endregion
clock.Stop();
#region create output
edgeBuffer.Add(null);
currentVertex = endVertex;
while (currentVertex != myStartVertex)
{
var current_tuple = lists.GetElement(currentVertex.VertexID);
if (current_tuple == null)
{
throw new InvalidFunctionParameterException("MaxDepth", "Max depth to low or end node is not with start node connected, find't end node", maxDepth);
}
VertexBuffer.Add(currentVertex);
distanceBuffer.Add(current_tuple.Item2);
depthBuffer.Add(current_tuple.Item3);
edgeBuffer.Add(current_tuple.Item4);
currentVertex = current_tuple.Item5;
}
depthBuffer.Add(0);
distanceBuffer.Add(0);
VertexBuffer.Add(myStartVertex);
edgeBuffer.Add(null);
var path = CreateVertexView(myPropertyID, VertexBuffer, distanceBuffer, edgeBuffer, depthBuffer);
#endregion
distanceBuffer = null;
VertexBuffer = null;
edgeBuffer = null;
depthBuffer = null;
buf.Clear();
lists.Clear();
buf = null;
lists = null;
return(new FuncParameter(path));
}
public override int Export()
{
IAssetType assetType = _metaAPI.GetAssetType("Goal");
Query query = new Query(assetType);
IAttributeDefinition assetStateAttribute = assetType.GetAttributeDefinition("AssetState");
query.Selection.Add(assetStateAttribute);
IAttributeDefinition assetNumberAttribute = assetType.GetAttributeDefinition("Number");
query.Selection.Add(assetNumberAttribute);
IAttributeDefinition targetedByAttribute = assetType.GetAttributeDefinition("TargetedBy.ID");
query.Selection.Add(targetedByAttribute);
IAttributeDefinition scopeAttribute = assetType.GetAttributeDefinition("Scope");
query.Selection.Add(scopeAttribute);
IAttributeDefinition descriptionAttribute = assetType.GetAttributeDefinition("Description");
query.Selection.Add(descriptionAttribute);
IAttributeDefinition nameAttribute = assetType.GetAttributeDefinition("Name");
query.Selection.Add(nameAttribute);
IAttributeDefinition priorityAttribute = assetType.GetAttributeDefinition("Priority");
query.Selection.Add(priorityAttribute);
IAttributeDefinition categoryAttribute = assetType.GetAttributeDefinition("Category");
query.Selection.Add(categoryAttribute);
//Filter on parent scope.
IAttributeDefinition parentScopeAttribute = assetType.GetAttributeDefinition("Scope.ParentMeAndUp");
FilterTerm term = new FilterTerm(parentScopeAttribute);
term.Equal(_config.V1SourceConnection.Project);
query.Filter = term;
string SQL = BuildGoalInsertStatement();
if (_config.V1Configurations.PageSize != 0)
{
query.Paging.Start = 0;
query.Paging.PageSize = _config.V1Configurations.PageSize;
}
int assetCounter = 0;
int assetTotal = 0;
do
{
QueryResult result = _dataAPI.Retrieve(query);
assetTotal = result.TotalAvaliable;
foreach (Asset asset in result.Assets)
{
using (SqlCommand cmd = new SqlCommand())
{
//NAME NPI MASK:
object name = GetScalerValue(asset.GetAttribute(nameAttribute));
if (_config.V1Configurations.UseNPIMasking == true && name != DBNull.Value)
{
name = ExportUtils.RemoveNPI(name.ToString());
}
//DESCRIPTION NPI MASK:
object description = GetScalerValue(asset.GetAttribute(descriptionAttribute));
if (_config.V1Configurations.UseNPIMasking == true && description != DBNull.Value)
{
description = ExportUtils.RemoveNPI(description.ToString());
}
cmd.Connection = _sqlConn;
cmd.CommandText = SQL;
cmd.CommandType = System.Data.CommandType.Text;
cmd.Parameters.AddWithValue("@AssetOID", asset.Oid.ToString());
cmd.Parameters.AddWithValue("@AssetState", GetScalerValue(asset.GetAttribute(assetStateAttribute)));
cmd.Parameters.AddWithValue("@AssetNumber", GetScalerValue(asset.GetAttribute(assetNumberAttribute)));
cmd.Parameters.AddWithValue("@TargetedBy", GetMultiRelationValues(asset.GetAttribute(targetedByAttribute)));
cmd.Parameters.AddWithValue("@Scope", GetSingleRelationValue(asset.GetAttribute(scopeAttribute)));
cmd.Parameters.AddWithValue("@Description", description);
cmd.Parameters.AddWithValue("@Name", name);
cmd.Parameters.AddWithValue("@Priority", GetSingleRelationValue(asset.GetAttribute(priorityAttribute)));
cmd.Parameters.AddWithValue("@Category", GetSingleRelationValue(asset.GetAttribute(categoryAttribute)));
cmd.ExecuteNonQuery();
}
assetCounter++;
}
query.Paging.Start = assetCounter;
} while (assetCounter != assetTotal);
return(assetCounter);
}
/// <summary>
/// Algorithm Dijkstra for find all shortest path from start Vertex to all others Vertices
/// </summary>
/// <param name="myAttributeDefinition"></param>
/// <param name="myCallingObject"></param>
/// <param name="myStartVertex"></param>
/// <param name="myGraphDB"></param>
/// <param name="maxDepth"></param>
/// <param name="mySecurityToken"></param>
/// <param name="myTransactionToken"></param>
/// <returns></returns>
private Tuple <IVertex, DataDijkstra> FindShortPathToAll(IAttributeDefinition myAttributeDefinition,
Object myCallingObject,
IVertex myStartVertex,
IGraphDB myGraphDB,
UInt64 maxDepth,
SecurityToken mySecurityToken,
Int64 myTransactionToken)
{
if (myStartVertex == null)
{
throw new InvalidFunctionParameterException("StartVertex", "Vertex that represents the start vertex", "null");
}
//set the start node
var currentVertex = myStartVertex;
var myType = myGraphDB.GetVertexType <IVertexType>(mySecurityToken,
myTransactionToken,
new sones.GraphDB.Request.RequestGetVertexType(myAttributeDefinition.RelatedType.Name),
(statistics, type) => type);
var myEdgeType = myAttributeDefinition.ID;
var hasProperty = myType.GetOutgoingEdgeDefinition(myAttributeDefinition.Name).InnerEdgeType.HasProperty("Weight");
long myPropertyID = 0;
if (hasProperty == true)
{
myPropertyID = myType.GetOutgoingEdgeDefinition(myAttributeDefinition.Name).InnerEdgeType.GetPropertyDefinition("Weight").ID;
}
var edgeTypeDifinition = myType.GetOutgoingEdgeDefinition(myAttributeDefinition.Name);
DataDijkstra lists = new DataDijkstra();
BufferDijkstra buffer = new BufferDijkstra();
buffer.Add(myStartVertex, 0, 0);
lists.Add(currentVertex, 0, 0, null, null, currentVertex);
double currentVertexDistance = 0;
ulong currentVertexDepth = 0;
while (buffer.Count != 0)
{
if (currentVertexDepth < maxDepth)
{
var hyperEdge = currentVertex.GetOutgoingHyperEdge(myEdgeType);
if (hyperEdge != null)
{
var singleEdge = hyperEdge.GetAllEdges();
for (int iCount = 0; iCount < singleEdge.Count(); iCount++)
{
var TargetVertex = singleEdge.ElementAt(iCount).GetTargetVertex();
double current_distance;
if (hasProperty == true)
{
current_distance = Math.Abs(singleEdge.ElementAt(iCount).GetProperty <double>(myPropertyID));
}
else
{
current_distance = 1;
}
var current_singleEdge = singleEdge.ElementAt(iCount);
var TargetVertexID = lists.GetElement(TargetVertex.VertexID);
if (TargetVertexID == null)
{
buffer.Add(TargetVertex,
current_distance + currentVertexDistance,
currentVertexDepth + 1);
lists.Add(TargetVertex,
current_distance + currentVertexDistance,
currentVertexDepth + 1,
current_singleEdge,
edgeTypeDifinition,
currentVertex);
}
else
{
if (currentVertexDistance + current_distance < TargetVertexID.Item2)
{
buffer.Set(TargetVertexID.Item2, TargetVertex,
current_distance + currentVertexDistance,
currentVertexDepth + 1);
lists.Set(TargetVertex,
current_distance + currentVertexDistance,
currentVertexDepth + 1,
current_singleEdge,
edgeTypeDifinition,
currentVertex);
}
else
if (currentVertexDistance + current_distance == TargetVertexID.Item2 && currentVertexDepth + 1 < TargetVertexID.Item3)
{
buffer.Set(TargetVertexID.Item2, TargetVertex,
current_distance + currentVertexDistance,
currentVertexDepth + 1);
lists.Set(TargetVertex,
current_distance + currentVertexDistance,
currentVertexDepth + 1,
current_singleEdge,
edgeTypeDifinition,
currentVertex);
}
}
}
//delate from Buffer Vertex and any information
}
}
buffer.Remove(currentVertexDistance, currentVertex.VertexID);
//Minimum in distance from Buffer
if (buffer.Count != 0)
{
var minVertex = buffer.Min();
currentVertex = minVertex.Item1;
currentVertexDistance = minVertex.Item2;
currentVertexDepth = minVertex.Item3;
}
}
var result = Tuple.Create(myStartVertex, lists);
buffer.Clear();
lists.Clear();
buffer = null;
lists = null;
return(result);
}
public override int Import()
{
//SqlDataReader sdr = GetImportDataFromSproc("spGetConversationsForImport");
SqlDataReader sdr = GetImportDataFromDBTable("Conversations");
int importCount = 0;
while (sdr.Read())
{
try
{
//CHECK DATA: Conversation must have an author.
if (_config.V1Configurations.MigrateUnauthoredConversationsAsAdmin == false && String.IsNullOrEmpty(sdr["Author"].ToString()))
{
UpdateImportStatus("Conversations", sdr["AssetOID"].ToString(), ImportStatuses.FAILED, "Conversation author attribute is required.");
continue;
}
if (string.IsNullOrEmpty(sdr["NewAssetOID"].ToString()) == false)
{
continue;
}
IAssetType assetType = _metaAPI.GetAssetType("Expression");
Asset asset = _dataAPI.New(assetType, null);
IAttributeDefinition authoredAtAttribute = assetType.GetAttributeDefinition("AuthoredAt");
asset.SetAttributeValue(authoredAtAttribute, sdr["AuthoredAt"].ToString());
IAttributeDefinition contentAttribute = assetType.GetAttributeDefinition("Content");
asset.SetAttributeValue(contentAttribute, sdr["Content"].ToString());
IAttributeDefinition authorAttribute = assetType.GetAttributeDefinition("Author");
if (_config.V1Configurations.MigrateUnauthoredConversationsAsAdmin == true && String.IsNullOrEmpty(sdr["Author"].ToString()))
{
asset.SetAttributeValue(authorAttribute, "Member:20");
}
else
{
//asset.SetAttributeValue(authorAttribute, GetNewAssetOIDFromDB(sdr["Author"].ToString(), "Members"));
asset.SetAttributeValue(authorAttribute, "Member:20");
}
System.Diagnostics.Trace.WriteLine(asset.GetAttribute(authoredAtAttribute).ToString());
System.Diagnostics.Trace.WriteLine(asset.GetAttribute(contentAttribute).ToString());
System.Diagnostics.Trace.WriteLine(asset.GetAttribute(authorAttribute).ToString());
////In Versions < 12, there are different names for fields
//if (string.IsNullOrEmpty(sdr["BaseAssets"].ToString()) == false)
//{
// //Mentions held Members, Base Assets held any Assets. 12 and Later They are all together in Mentions
// string mentionValue = string.Empty;
// if (string.IsNullOrEmpty(sdr["Mentions"].ToString()) == false)
// {
// mentionValue = sdr["Mentions"].ToString() + ";";
// }
// AddMultiValueRelation(assetType, asset, "Mentions", mentionValue + sdr["BaseAssets"].ToString());
//}
//else if (string.IsNullOrEmpty(sdr["Mentions"].ToString()) == false)
//{
// AddMultiValueRelation(assetType, asset, "Mentions", sdr["Mentions"].ToString());
//}
//NOTE: Need to switch on V1 version. Right now handles 11.3 to 11.4+. Used to be BaseAssets, is now Mentions.
//HACK: Modified to support Rally migration, needs refactoring.
//if (String.IsNullOrEmpty(sdr["BaseAssets"].ToString()) == false)
//{
// AddMultiValueRelation(assetType, asset, "Mentions", sdr["BaseAssets"].ToString());
// //AddRallyMentionsValue(assetType, asset, sdr["BaseAssetType"].ToString(), sdr["Mentions"].ToString());
//}
_dataAPI.Save(asset);
UpdateNewAssetOIDInDB("Conversations", sdr["AssetOID"].ToString(), asset.Oid.Momentless.ToString());
UpdateImportStatus("Conversations", sdr["AssetOID"].ToString(), ImportStatuses.IMPORTED, "Conversation imported.");
importCount++;
}
catch (Exception ex)
{
if (_config.V1Configurations.LogExceptions == true)
{
UpdateImportStatus("Conversations", sdr["AssetOID"].ToString(), ImportStatuses.FAILED, ex.Message);
continue;
}
else
{
throw ex;
}
}
}
sdr.Close();
SetConversationDependencies();
return(importCount);
}
public void CoerceAssetStateNull()
{
IAttributeDefinition def = Meta.GetAttributeDefinition("Story.AssetState");
Assert.IsNull(def.Coerce(null));
}
public void MinorSort(IAttributeDefinition attribdef, Order order)
{
Remove(attribdef);
_terms.Add(new Term(attribdef, order));
}
public override int Export()
{
IAssetType assetType = _metaAPI.GetAssetType("Timebox");
Query query = new Query(assetType);
IAttributeDefinition assetStateAttribute = assetType.GetAttributeDefinition("AssetState");
query.Selection.Add(assetStateAttribute);
IAttributeDefinition ownerAttribute = assetType.GetAttributeDefinition("Owner");
query.Selection.Add(ownerAttribute);
IAttributeDefinition scheduleAttribute = assetType.GetAttributeDefinition("Schedule");
query.Selection.Add(scheduleAttribute);
IAttributeDefinition descriptionAttribute = assetType.GetAttributeDefinition("Description");
query.Selection.Add(descriptionAttribute);
IAttributeDefinition nameAttribute = assetType.GetAttributeDefinition("Name");
query.Selection.Add(nameAttribute);
IAttributeDefinition targetEstimateAttribute = assetType.GetAttributeDefinition("TargetEstimate");
query.Selection.Add(targetEstimateAttribute);
IAttributeDefinition endDateAttribute = assetType.GetAttributeDefinition("EndDate");
query.Selection.Add(endDateAttribute);
IAttributeDefinition beginDateAttribute = assetType.GetAttributeDefinition("BeginDate");
query.Selection.Add(beginDateAttribute);
IAttributeDefinition stateAttribute = assetType.GetAttributeDefinition("State");
query.Selection.Add(stateAttribute);
string SQL = BuildIterationInsertStatement();
if (_config.V1Configurations.PageSize != 0)
{
query.Paging.Start = 0;
query.Paging.PageSize = _config.V1Configurations.PageSize;
}
int assetCounter = 0;
int assetTotal = 0;
do
{
QueryResult result = _dataAPI.Retrieve(query);
assetTotal = result.TotalAvaliable;
foreach (Asset asset in result.Assets)
{
using (SqlCommand cmd = new SqlCommand())
{
//NAME NPI MASK:
object name = GetScalerValue(asset.GetAttribute(nameAttribute));
if (_config.V1Configurations.UseNPIMasking == true && name != DBNull.Value)
{
name = ExportUtils.RemoveNPI(name.ToString());
}
//DESCRIPTION NPI MASK:
object description = GetScalerValue(asset.GetAttribute(descriptionAttribute));
if (_config.V1Configurations.UseNPIMasking == true && description != DBNull.Value)
{
description = ExportUtils.RemoveNPI(description.ToString());
}
cmd.Connection = _sqlConn;
cmd.CommandText = SQL;
cmd.CommandType = System.Data.CommandType.Text;
cmd.Parameters.AddWithValue("@AssetOID", asset.Oid.ToString());
cmd.Parameters.AddWithValue("@AssetState", GetScalerValue(asset.GetAttribute(assetStateAttribute)));
cmd.Parameters.AddWithValue("@Owner", GetSingleRelationValue(asset.GetAttribute(ownerAttribute)));
cmd.Parameters.AddWithValue("@Schedule", GetSingleRelationValue(asset.GetAttribute(scheduleAttribute)));
cmd.Parameters.AddWithValue("@Description", description);
cmd.Parameters.AddWithValue("@Name", name);
cmd.Parameters.AddWithValue("@TargetEstimate", GetScalerValue(asset.GetAttribute(targetEstimateAttribute)));
cmd.Parameters.AddWithValue("@EndDate", GetScalerValue(asset.GetAttribute(endDateAttribute)));
cmd.Parameters.AddWithValue("@BeginDate", GetScalerValue(asset.GetAttribute(beginDateAttribute)));
cmd.Parameters.AddWithValue("@State", GetStateRelationValue(asset.GetAttribute(stateAttribute)));
cmd.ExecuteNonQuery();
}
assetCounter++;
}
query.Paging.Start = assetCounter;
} while (assetCounter != assetTotal);
return(assetCounter);
}
public void MajorSort(IAttributeDefinition attribdef, Order order)
{
Remove(attribdef);
_terms.Insert(0, new Term(attribdef, order));
}
public bool Equals(IAttributeDefinition myOther)
{
return(myOther != null &&
myOther.ID == ID);
}
public void CreateDefect(V1Connector CurrentV1Connection, List <Message> CurrentEmails)
{
V1XMLHelper V1XML = new V1XMLHelper();
V1Logging Logs = new V1Logging();
string ProjectScope = "Something for Testing";
string EmailBody;
MessagePart MessageParts;
SMTPResponse V1Response = new SMTPResponse();
MailChecker MailCheck = new MailChecker();
IServices services = new Services(CurrentV1Connection);
try
{
foreach (Message MailItem in CurrentEmails)
{
for (int ToCtr = 0; ToCtr < MailItem.Headers.To.Count; ToCtr++)
{
ProjectScope = V1XML.GetProjectScope(MailItem.Headers.To[ToCtr].Address);
if (ProjectScope != null)
{
Oid projectId = services.GetOid(ProjectScope);
IAssetType defectType = services.Meta.GetAssetType("Defect");
Asset NewDefect = services.New(defectType, projectId);
IAttributeDefinition nameAttribute = defectType.GetAttributeDefinition("Name");
NewDefect.SetAttributeValue(nameAttribute, MailItem.Headers.Subject.ToString());
MessageParts = MailItem.FindFirstHtmlVersion();
if (MessageParts == null)
{
MessageParts = MailItem.FindFirstPlainTextVersion();
}
EmailBody = MessageParts.GetBodyAsText();
Logs.LogEvent("Operation - Creating Defect for " + MailItem.Headers.To[ToCtr].Address);
IAttributeDefinition descriptionAttribute = defectType.GetAttributeDefinition("Description");
NewDefect.SetAttributeValue(descriptionAttribute, EmailBody);
IAttributeDefinition FoundByAttribute = defectType.GetAttributeDefinition("FoundBy");
NewDefect.SetAttributeValue(FoundByAttribute, MailItem.Headers.From.ToString());
services.Save(NewDefect);
IAttributeDefinition DefectIDAttribute = defectType.GetAttributeDefinition("Number");
Query IDQuery = new Query(NewDefect.Oid);
IDQuery.Selection.Add(DefectIDAttribute);
QueryResult ResultID = services.Retrieve(IDQuery);
Asset defect = ResultID.Assets[0];
//NewDefect.GetAttribute(DefectIDAttribute).Value
Logs.LogEvent("Operation - Sending Response to Defect Sender.");
//Commented out the Response back to the Sender per John Waedekin
//V1Response.SendResponse(MailItem, defect.GetAttribute(DefectIDAttribute).Value + " " + NewDefect.GetAttribute(nameAttribute).Value, ProjectScope);
MailCheck.DeleteMessagesOnServer(MailItem, ProjectScope);
}
}
}
}
catch (Exception ex)
{
Logs.LogEvent("ERROR - Creating Defect - " + ex.InnerException.Message);
}
}
private static void ProcessStructuredProperty(GQLPluginManager myPluginManager,
IGraphDB myGraphDB,
SecurityToken mySecurityToken,
Int64 myTransactionToken,
IVertexType vertexType,
AAttributeAssignOrUpdate aAttributeDefinition,
ref RequestInsertVertex result)
{
#region AttributeAssignOrUpdateValue
if (aAttributeDefinition is AttributeAssignOrUpdateValue)
{
var value = aAttributeDefinition as AttributeAssignOrUpdateValue;
result.AddUnknownProperty(value.AttributeIDChain.ContentString, value.Value);
return;
}
#endregion
#region AttributeAssignOrUpdateList
if (aAttributeDefinition is AttributeAssignOrUpdateList)
{
var value = aAttributeDefinition as AttributeAssignOrUpdateList;
switch (value.CollectionDefinition.CollectionType)
{
case CollectionType.Set:
#region set
if (!vertexType.HasAttribute(aAttributeDefinition.AttributeIDChain.ContentString))
{
throw new InvalidVertexAttributeException(String.Format("The vertex type {0} has no attribute named {1}.",
vertexType.Name,
aAttributeDefinition.AttributeIDChain.ContentString));
}
IAttributeDefinition attribute = vertexType.GetAttributeDefinition(aAttributeDefinition
.AttributeIDChain
.ContentString);
EdgePredefinition edgeDefinition = new EdgePredefinition(value.AttributeIDChain.ContentString);
foreach (var aTupleElement in (TupleDefinition)value.CollectionDefinition.TupleDefinition)
{
if (aTupleElement.Value is BinaryExpressionDefinition)
{
#region BinaryExpressionDefinition
var targetVertexType = ((IOutgoingEdgeDefinition)attribute).TargetVertexType;
foreach (var aVertex in ProcessBinaryExpression(
(BinaryExpressionDefinition)aTupleElement.Value,
myPluginManager, myGraphDB, mySecurityToken, myTransactionToken, targetVertexType))
{
var inneredge = new EdgePredefinition().AddVertexID(aVertex.VertexTypeID, aVertex.VertexID);
foreach (var aStructuredProperty in aTupleElement.Parameters)
{
inneredge.AddUnknownProperty(aStructuredProperty.Key, aStructuredProperty.Value);
}
edgeDefinition.AddEdge(inneredge);
}
#endregion
}
else
{
throw new NotImplementedQLException("TODO");
}
}
result.AddEdge(edgeDefinition);
#endregion )
return;
case CollectionType.List:
#region list
//has to be list of comparables
ListCollectionWrapper listWrapper = new ListCollectionWrapper();
Type myRequestedType;
if (vertexType.HasProperty(aAttributeDefinition.AttributeIDChain.ContentString))
{
myRequestedType = ((IPropertyDefinition)vertexType
.GetAttributeDefinition(aAttributeDefinition.AttributeIDChain.ContentString)).BaseType;
}
else
{
myRequestedType = typeof(String);
}
foreach (var aTupleElement in (TupleDefinition)value.CollectionDefinition.TupleDefinition)
{
listWrapper.Add(((ValueDefinition)aTupleElement.Value).Value.ConvertToIComparable(myRequestedType));
}
result.AddStructuredProperty(aAttributeDefinition.AttributeIDChain.ContentString, listWrapper);
#endregion )
return;
case CollectionType.SetOfUUIDs:
#region SetOfUUIDs
EdgePredefinition anotheredgeDefinition = new EdgePredefinition(value.AttributeIDChain.ContentString);
foreach (var aTupleElement in ((VertexTypeVertexIDCollectionNode)value.CollectionDefinition.TupleDefinition).Elements)
{
foreach (var aVertexIDTuple in aTupleElement.VertexIDs)
{
var innerEdge = new EdgePredefinition();
foreach (var aStructuredProperty in aVertexIDTuple.Item2)
{
innerEdge.AddUnknownProperty(aStructuredProperty.Key, aStructuredProperty.Value);
}
innerEdge.AddVertexID(aTupleElement.ReferencedVertexTypeName, aVertexIDTuple.Item1);
anotheredgeDefinition.AddEdge(innerEdge);
}
}
result.AddEdge(anotheredgeDefinition);
#endregion
return;
default:
return;
}
}
#endregion
#region SetRefNode
if (aAttributeDefinition is AttributeAssignOrUpdateSetRef)
{
var value = aAttributeDefinition as AttributeAssignOrUpdateSetRef;
var edgeDefinition = new EdgePredefinition(value.AttributeIDChain.ContentString);
if (value.SetRefDefinition.IsREFUUID)
{
#region direct vertex ids
foreach (var aTupleElement in value.SetRefDefinition.TupleDefinition)
{
if (aTupleElement.Value is ValueDefinition)
{
#region ValueDefinition
foreach (var aProperty in aTupleElement.Parameters)
{
edgeDefinition.AddUnknownProperty(aProperty.Key, aProperty.Value);
}
edgeDefinition.AddVertexID(value.SetRefDefinition.ReferencedVertexType,
Convert.ToInt64(((ValueDefinition)aTupleElement.Value).Value));
#endregion
}
else
{
throw new NotImplementedQLException("TODO");
}
}
#endregion
}
else
{
#region expression
if (!vertexType.HasAttribute(aAttributeDefinition.AttributeIDChain.ContentString))
{
throw new InvalidVertexAttributeException(String.Format("The vertex type {0} has no attribute named {1}.",
vertexType.Name,
aAttributeDefinition.AttributeIDChain.ContentString));
}
IAttributeDefinition attribute = vertexType.GetAttributeDefinition(aAttributeDefinition.AttributeIDChain.ContentString);
foreach (var aTupleElement in value.SetRefDefinition.TupleDefinition)
{
if (aTupleElement.Value is BinaryExpressionDefinition)
{
#region BinaryExpressionDefinition
var targetVertexType = ((IOutgoingEdgeDefinition)attribute).TargetVertexType;
var vertexIDs = ProcessBinaryExpression(
(BinaryExpressionDefinition)aTupleElement.Value,
myPluginManager, myGraphDB, mySecurityToken, myTransactionToken, targetVertexType).ToList();
if (vertexIDs.Count > 1)
{
throw new ReferenceAssignmentExpectedException(String.Format("It is not possible to create a single edge pointing to {0} vertices",
vertexIDs.Count));
}
var inneredge = new EdgePredefinition();
foreach (var aStructuredProperty in aTupleElement.Parameters)
{
edgeDefinition.AddUnknownProperty(aStructuredProperty.Key, aStructuredProperty.Value);
}
edgeDefinition.AddVertexID(vertexIDs.FirstOrDefault().VertexTypeID, vertexIDs.FirstOrDefault().VertexID);
#endregion
}
else
{
throw new NotImplementedQLException("");
}
}
#endregion
}
result.AddEdge(edgeDefinition);
return;
}
#endregion
}
public override int Import()
{
SqlDataReader sdr = GetImportDataFromDBTable("Actuals");
int importCount = 0;
while (sdr.Read())
{
try
{
if (String.IsNullOrEmpty(sdr["Value"].ToString()) ||
String.IsNullOrEmpty(sdr["Date"].ToString()) ||
String.IsNullOrEmpty(sdr["Scope"].ToString()) ||
String.IsNullOrEmpty(sdr["Member"].ToString()) ||
String.IsNullOrEmpty(sdr["Workitem"].ToString()) ||
String.IsNullOrEmpty(GetNewAssetOIDFromDB(sdr["Workitem"].ToString())))
{
UpdateImportStatus("Actuals", sdr["AssetOID"].ToString(), ImportStatuses.FAILED, "Actual missing required field.");
continue;
}
IAssetType assetType = _metaAPI.GetAssetType("Actual");
Asset asset = _dataAPI.New(assetType, null);
IAttributeDefinition valueAttribute = assetType.GetAttributeDefinition("Value");
asset.SetAttributeValue(valueAttribute, sdr["Value"].ToString());
IAttributeDefinition dateAttribute = assetType.GetAttributeDefinition("Date");
asset.SetAttributeValue(dateAttribute, sdr["Date"].ToString());
IAttributeDefinition timeboxAttribute = assetType.GetAttributeDefinition("Timebox");
asset.SetAttributeValue(timeboxAttribute, GetNewAssetOIDFromDB(sdr["Timebox"].ToString()));
IAttributeDefinition scopeAttribute = assetType.GetAttributeDefinition("Scope");
asset.SetAttributeValue(scopeAttribute, GetNewAssetOIDFromDB(sdr["Scope"].ToString()));
IAttributeDefinition memberAttribute = assetType.GetAttributeDefinition("Member");
asset.SetAttributeValue(memberAttribute, GetNewAssetOIDFromDB(sdr["Member"].ToString()));
IAttributeDefinition workitemAttribute = assetType.GetAttributeDefinition("Workitem");
asset.SetAttributeValue(workitemAttribute, GetNewAssetOIDFromDB(sdr["Workitem"].ToString()));
IAttributeDefinition teamAttribute = assetType.GetAttributeDefinition("Team");
asset.SetAttributeValue(teamAttribute, GetNewAssetOIDFromDB(sdr["Team"].ToString()));
_dataAPI.Save(asset);
UpdateNewAssetOIDAndStatus("Actuals", sdr["AssetOID"].ToString(), asset.Oid.Momentless.ToString(), ImportStatuses.IMPORTED, "Actual imported.");
importCount++;
}
catch (Exception ex)
{
if (_config.V1Configurations.LogExceptions == true)
{
UpdateImportStatus("Actuals", sdr["AssetOID"].ToString(), ImportStatuses.FAILED, ex.Message);
continue;
}
else
{
throw ex;
}
}
}
sdr.Close();
return(importCount);
}
public void AddAttributeValue(IAttributeDefinition attribdef, object value)
{
EnsureAttribute(attribdef).AddValue(value);
}
private static void ParseAttributeNode(Asset asset, IAttributeDefinition attribdef, XmlElement element)
{
var type = element.LocalName;
asset.EnsureAttribute(attribdef);
if (type == "Relation")
{
if (attribdef.IsMultiValue)
{
foreach (XmlElement child in element.ChildNodes)
{
var add = child.HasAttribute("act") && child.GetAttribute("act") == "add";
var token = child.GetAttribute("idref");
if (add)
{
asset.AddAttributeValue(attribdef, token);
}
else
{
asset.LoadAttributeValue(attribdef, token);
}
}
}
else
{
var token = Oid.Null.Token;
if (element.HasChildNodes)
{
token = ((XmlElement)element.ChildNodes.Item(0)).GetAttribute("idref");
}
var force = element.HasAttribute("act") && element.GetAttribute("act") == "set";
if (force)
{
asset.ForceAttributeValue(attribdef, token);
}
else
{
asset.LoadAttributeValue(attribdef, token);
}
}
}
else
{
if (attribdef.IsMultiValue)
{
foreach (XmlElement child in element.ChildNodes)
{
var add = child.HasAttribute("act") && child.GetAttribute("act") == "add";
if (add)
{
asset.AddAttributeValue(attribdef, child.InnerText);
}
else
{
asset.LoadAttributeValue(attribdef, child.InnerText);
}
}
}
else
{
object v = null;
if (!string.IsNullOrEmpty(element.InnerText))
{
v = element.InnerText;
}
var force = element.HasAttribute("act") && element.GetAttribute("act") == "set";
if (force)
{
asset.ForceAttributeValue(attribdef, v);
}
else
{
asset.LoadAttributeValue(attribdef, v);
}
}
}
}
public override int Export()
{
IAssetType assetType = _metaAPI.GetAssetType("Scope");
Query query = new Query(assetType);
IAttributeDefinition assetStateAttribute = assetType.GetAttributeDefinition("AssetState");
query.Selection.Add(assetStateAttribute);
IAttributeDefinition scheduleAttribute = assetType.GetAttributeDefinition("Schedule");
query.Selection.Add(scheduleAttribute);
IAttributeDefinition parentAttribute = assetType.GetAttributeDefinition("Parent");
query.Selection.Add(parentAttribute);
IAttributeDefinition ownerAttribute = assetType.GetAttributeDefinition("Owner");
query.Selection.Add(ownerAttribute);
IAttributeDefinition descriptionAttribute = assetType.GetAttributeDefinition("Description");
query.Selection.Add(descriptionAttribute);
IAttributeDefinition nameAttribute = assetType.GetAttributeDefinition("Name");
query.Selection.Add(nameAttribute);
IAttributeDefinition endDateAttribute = assetType.GetAttributeDefinition("EndDate");
query.Selection.Add(endDateAttribute);
IAttributeDefinition beginDateAttribute = assetType.GetAttributeDefinition("BeginDate");
query.Selection.Add(beginDateAttribute);
IAttributeDefinition statusAttribute = assetType.GetAttributeDefinition("Status");
query.Selection.Add(statusAttribute);
IAttributeDefinition membersAttribute = null;
if (_config.V1Configurations.MigrateProjectMembership == true)
{
membersAttribute = assetType.GetAttributeDefinition("Members.ID");
query.Selection.Add(membersAttribute);
}
IAttributeDefinition schemeAttribute = assetType.GetAttributeDefinition("Scheme");
query.Selection.Add(schemeAttribute);
//SPECIAL CASE: Reference attribute only exists in V1 12 and later.
IAttributeDefinition referenceAttribute = null;
if (_metaAPI.Version.Major > 11)
{
referenceAttribute = assetType.GetAttributeDefinition("Reference");
query.Selection.Add(referenceAttribute);
}
//Filter on parent scope.
IAttributeDefinition parentScopeAttribute = assetType.GetAttributeDefinition("ParentMeAndUp");
FilterTerm term = new FilterTerm(parentScopeAttribute);
term.Equal(_config.V1SourceConnection.Project);
query.Filter = term;
string SQL = BuildProjectInsertStatement();
if (_config.V1Configurations.PageSize != 0)
{
query.Paging.Start = 0;
query.Paging.PageSize = _config.V1Configurations.PageSize;
}
int assetCounter = 0;
int assetTotal = 0;
do
{
QueryResult result = _dataAPI.Retrieve(query);
assetTotal = result.TotalAvaliable;
_logger.Info("assetTotal is {0} ", assetTotal);
foreach (Asset asset in result.Assets)
{
using (SqlCommand cmd = new SqlCommand())
{
//NAME NPI MASK:
object name = GetScalerValue(asset.GetAttribute(nameAttribute));
if (_config.V1Configurations.UseNPIMasking == true && name != DBNull.Value)
{
name = ExportUtils.RemoveNPI(name.ToString());
}
//DESCRIPTION NPI MASK:
object description = GetScalerValue(asset.GetAttribute(descriptionAttribute));
if (_config.V1Configurations.UseNPIMasking == true && description != DBNull.Value)
{
description = ExportUtils.RemoveNPI(description.ToString());
}
cmd.Connection = _sqlConn;
cmd.CommandText = SQL;
cmd.CommandType = System.Data.CommandType.Text;
cmd.Parameters.AddWithValue("@AssetOID", asset.Oid.ToString());
cmd.Parameters.AddWithValue("@AssetState", GetScalerValue(asset.GetAttribute(assetStateAttribute)));
cmd.Parameters.AddWithValue("@Schedule", GetSingleRelationValue(asset.GetAttribute(scheduleAttribute)));
cmd.Parameters.AddWithValue("@Parent", GetSingleRelationValue(asset.GetAttribute(parentAttribute)));
cmd.Parameters.AddWithValue("@Owner", GetSingleRelationValue(asset.GetAttribute(ownerAttribute)));
cmd.Parameters.AddWithValue("@Description", description);
cmd.Parameters.AddWithValue("@Name", name);
cmd.Parameters.AddWithValue("@EndDate", GetScalerValue(asset.GetAttribute(endDateAttribute)));
cmd.Parameters.AddWithValue("@BeginDate", GetScalerValue(asset.GetAttribute(beginDateAttribute)));
cmd.Parameters.AddWithValue("@Status", GetSingleRelationValue(asset.GetAttribute(statusAttribute)));
cmd.Parameters.AddWithValue("@Members", membersAttribute == null ? DBNull.Value : GetMultiRelationValues(asset.GetAttribute(membersAttribute)));
cmd.Parameters.AddWithValue("@Reference", referenceAttribute == null ? DBNull.Value : GetScalerValue(asset.GetAttribute(referenceAttribute)));
cmd.ExecuteNonQuery();
}
assetCounter++;
}
query.Paging.Start = assetCounter;
} while (assetCounter != assetTotal);
return(assetCounter);
}
public override int Import()
{
SqlDataReader sdr = GetImportDataFromDBTableWithOrder("RegressionTests");
int importCount = 0;
while (sdr.Read())
{
try
{
//CHECK DATA: RegressionTest must have a name.
if (String.IsNullOrEmpty(sdr["Name"].ToString()))
{
UpdateImportStatus("RegressionTests", sdr["AssetOID"].ToString(), ImportStatuses.FAILED, "RegressionTest name attribute is required.");
continue;
}
//CHECK DATA: RegressionTest must have a scope.
if (String.IsNullOrEmpty(sdr["Scope"].ToString()))
{
UpdateImportStatus("RegressionTests", sdr["AssetOID"].ToString(), ImportStatuses.FAILED, "RegressionTest scope attribute is required.");
continue;
}
IAssetType assetType = _metaAPI.GetAssetType("RegressionTest");
Asset asset = _dataAPI.New(assetType, null);
IAttributeDefinition fullNameAttribute = assetType.GetAttributeDefinition("Name");
asset.SetAttributeValue(fullNameAttribute, AddV1IDToTitle(sdr["Name"].ToString(), sdr["AssetNumber"].ToString()));
IAttributeDefinition descAttribute = assetType.GetAttributeDefinition("Description");
asset.SetAttributeValue(descAttribute, sdr["Description"].ToString());
IAttributeDefinition scopeAttribute = assetType.GetAttributeDefinition("Scope");
asset.SetAttributeValue(scopeAttribute, GetNewAssetOIDFromDB(sdr["Scope"].ToString(), "Projects"));
if (String.IsNullOrEmpty(sdr["Owners"].ToString()) == false)
{
AddMultiValueRelation(assetType, asset, "Members", "Owners", sdr["Owners"].ToString());
}
IAttributeDefinition referenceAttribute = assetType.GetAttributeDefinition("Reference");
asset.SetAttributeValue(referenceAttribute, sdr["Reference"].ToString());
IAttributeDefinition stepsAttribute = assetType.GetAttributeDefinition("Steps");
asset.SetAttributeValue(stepsAttribute, sdr["Steps"].ToString());
IAttributeDefinition inputAttribute = assetType.GetAttributeDefinition("Inputs");
asset.SetAttributeValue(inputAttribute, sdr["Inputs"].ToString());
IAttributeDefinition setupAttribute = assetType.GetAttributeDefinition("Setup");
asset.SetAttributeValue(setupAttribute, sdr["Setup"].ToString());
IAttributeDefinition expectedResultsAttribute = assetType.GetAttributeDefinition("ExpectedResults");
asset.SetAttributeValue(expectedResultsAttribute, sdr["ExpectedResults"].ToString());
//HACK: For Rally import, needs to be refactored.
IAttributeDefinition statusAttribute = assetType.GetAttributeDefinition("Status");
//asset.SetAttributeValue(statusAttribute, GetNewListTypeAssetOIDFromDB(sdr["Status"].ToString()));
asset.SetAttributeValue(statusAttribute, GetNewListTypeAssetOIDFromDB("RegressionTestStatus", sdr["Status"].ToString()));
//HACK: For Rally import, needs to be refactored.
IAttributeDefinition categoryAttribute = assetType.GetAttributeDefinition("Category");
//asset.SetAttributeValue(categoryAttribute, GetNewListTypeAssetOIDFromDB(sdr["Category"].ToString()));
asset.SetAttributeValue(categoryAttribute, GetNewListTypeAssetOIDFromDB("TestCategory", sdr["Category"].ToString()));
_dataAPI.Save(asset);
string newAssetNumber = GetAssetNumberV1("RegressionTest", asset.Oid.Momentless.ToString());
UpdateNewAssetOIDAndNumberInDB("RegressionTests", sdr["AssetOID"].ToString(), asset.Oid.Momentless.ToString(), newAssetNumber);
UpdateImportStatus("RegressionTests", sdr["AssetOID"].ToString(), ImportStatuses.IMPORTED, "RegressionTest imported.");
importCount++;
}
catch (Exception ex)
{
if (_config.V1Configurations.LogExceptions == true)
{
UpdateImportStatus("RegressionTests", sdr["AssetOID"].ToString(), ImportStatuses.FAILED, ex.Message);
continue;
}
else
{
throw ex;
}
}
}
sdr.Close();
return(importCount);
}
internal void SaveAttributeDefinition(IAttributeDefinition attribdef)
{
var key = new Pair<IAssetType, string>(this, attribdef.Name);
map[key] = attribdef;
}
public override int Export()
{
IAssetType assetType = _metaAPI.GetAssetType("Request");
Query query = new Query(assetType);
IAttributeDefinition assetStateAttribute = assetType.GetAttributeDefinition("AssetState");
query.Selection.Add(assetStateAttribute);
IAttributeDefinition assetNumberAttribute = assetType.GetAttributeDefinition("Number");
query.Selection.Add(assetNumberAttribute);
IAttributeDefinition ownerAttribute = assetType.GetAttributeDefinition("Owner");
query.Selection.Add(ownerAttribute);
IAttributeDefinition scopeAttribute = assetType.GetAttributeDefinition("Scope");
query.Selection.Add(scopeAttribute);
IAttributeDefinition epicsAttribute = null;
if (_metaAPI.Version.Major > 11)
{
epicsAttribute = assetType.GetAttributeDefinition("Epics.ID");
query.Selection.Add(epicsAttribute);
}
IAttributeDefinition descriptionAttribute = assetType.GetAttributeDefinition("Description");
query.Selection.Add(descriptionAttribute);
IAttributeDefinition nameAttribute = assetType.GetAttributeDefinition("Name");
query.Selection.Add(nameAttribute);
IAttributeDefinition orderAttribute = assetType.GetAttributeDefinition("Order");
query.Selection.Add(orderAttribute);
IAttributeDefinition resolutionAttribute = assetType.GetAttributeDefinition("Resolution");
query.Selection.Add(resolutionAttribute);
IAttributeDefinition referenceAttribute = assetType.GetAttributeDefinition("Reference");
query.Selection.Add(referenceAttribute);
IAttributeDefinition requestedByAttribute = assetType.GetAttributeDefinition("RequestedBy");
query.Selection.Add(requestedByAttribute);
IAttributeDefinition resolutionReasonAttribute = assetType.GetAttributeDefinition("ResolutionReason");
query.Selection.Add(resolutionReasonAttribute);
IAttributeDefinition sourceAttribute = assetType.GetAttributeDefinition("Source");
query.Selection.Add(sourceAttribute);
IAttributeDefinition priorityAttribute = assetType.GetAttributeDefinition("Priority");
query.Selection.Add(priorityAttribute);
IAttributeDefinition statusAttribute = assetType.GetAttributeDefinition("Status");
query.Selection.Add(statusAttribute);
IAttributeDefinition categoryAttribute = assetType.GetAttributeDefinition("Category");
query.Selection.Add(categoryAttribute);
//Filter on parent scope.
IAttributeDefinition parentScopeAttribute = assetType.GetAttributeDefinition("Scope.ParentMeAndUp");
FilterTerm term = new FilterTerm(parentScopeAttribute);
term.Equal(_config.V1SourceConnection.Project);
query.Filter = term;
string SQL = BuildRequestInsertStatement();
if (_config.V1Configurations.PageSize != 0)
{
query.Paging.Start = 0;
query.Paging.PageSize = _config.V1Configurations.PageSize;
}
int assetCounter = 0;
int assetTotal = 0;
do
{
QueryResult result = _dataAPI.Retrieve(query);
assetTotal = result.TotalAvaliable;
foreach (Asset asset in result.Assets)
{
using (SqlCommand cmd = new SqlCommand())
{
//NAME NPI MASK:
object name = GetScalerValue(asset.GetAttribute(nameAttribute));
if (_config.V1Configurations.UseNPIMasking == true && name != DBNull.Value)
{
name = ExportUtils.RemoveNPI(name.ToString());
}
//DESCRIPTION NPI MASK:
object description = GetScalerValue(asset.GetAttribute(descriptionAttribute));
if (_config.V1Configurations.UseNPIMasking == true && description != DBNull.Value)
{
description = ExportUtils.RemoveNPI(description.ToString());
}
//REFERENCE NPI MASK:
object reference = GetScalerValue(asset.GetAttribute(referenceAttribute));
if (_config.V1Configurations.UseNPIMasking == true && reference != DBNull.Value)
{
reference = ExportUtils.RemoveNPI(reference.ToString());
}
//REQUESTED BY NPI MASK:
object requestedBy = GetScalerValue(asset.GetAttribute(requestedByAttribute));
if (_config.V1Configurations.UseNPIMasking == true && requestedBy != DBNull.Value)
{
requestedBy = ExportUtils.RemoveNPI(requestedBy.ToString());
}
//RESOLUTION NPI MASK:
object resolution = GetScalerValue(asset.GetAttribute(resolutionAttribute));
if (_config.V1Configurations.UseNPIMasking == true && resolution != DBNull.Value)
{
resolution = ExportUtils.RemoveNPI(resolution.ToString());
}
cmd.Connection = _sqlConn;
cmd.CommandText = SQL;
cmd.CommandType = System.Data.CommandType.Text;
cmd.Parameters.AddWithValue("@AssetOID", asset.Oid.ToString());
cmd.Parameters.AddWithValue("@AssetState", GetScalerValue(asset.GetAttribute(assetStateAttribute)));
cmd.Parameters.AddWithValue("@AssetNumber", GetScalerValue(asset.GetAttribute(assetNumberAttribute)));
cmd.Parameters.AddWithValue("@Owner", GetSingleRelationValue(asset.GetAttribute(ownerAttribute)));
cmd.Parameters.AddWithValue("@Scope", GetSingleRelationValue(asset.GetAttribute(scopeAttribute)));
cmd.Parameters.AddWithValue("@Epics", epicsAttribute == null ? DBNull.Value : GetMultiRelationValues(asset.GetAttribute(epicsAttribute)));
cmd.Parameters.AddWithValue("@Description", description);
cmd.Parameters.AddWithValue("@Name", name);
cmd.Parameters.AddWithValue("@Order", GetScalerValue(asset.GetAttribute(orderAttribute)));
cmd.Parameters.AddWithValue("@Resolution", resolution);
cmd.Parameters.AddWithValue("@Reference", reference);
cmd.Parameters.AddWithValue("@RequestedBy", requestedBy);
cmd.Parameters.AddWithValue("@ResolutionReason", GetSingleRelationValue(asset.GetAttribute(resolutionReasonAttribute)));
cmd.Parameters.AddWithValue("@Source", GetSingleRelationValue(asset.GetAttribute(sourceAttribute)));
cmd.Parameters.AddWithValue("@Priority", GetSingleRelationValue(asset.GetAttribute(priorityAttribute)));
cmd.Parameters.AddWithValue("@Status", GetSingleRelationValue(asset.GetAttribute(statusAttribute)));
cmd.Parameters.AddWithValue("@Category", GetSingleRelationValue(asset.GetAttribute(categoryAttribute)));
cmd.ExecuteNonQuery();
}
assetCounter++;
}
query.Paging.Start = assetCounter;
} while (assetCounter != assetTotal);
return(assetCounter);
}
private bool isAttributeUnfilledOnServer(Asset asset, IAttributeDefinition attributeDefinition)
{
if (asset.Oid == Oid.Null)
{
return true;
}
Query query = new Query(asset.Oid);
query.Selection.Add(attributeDefinition);
QueryResult result = null;
try
{
result = services.Retrieve(query);
}
catch (Exception)
{
//do nothing
}
if (result != null)
{
Attribute attr = result.Assets[0].GetAttribute(attributeDefinition);
try
{
return IsSingleValueAndUnfilled(attr) && IsMultiValueAndUnfilled(attr);
}
catch (APIException)
{
// do nothing
}
}
return true; // there is no data on the server.
}
internal MultiValueAttribute(IAttributeDefinition def, Asset asset) : base(def, asset)
{
}
internal MultiValueAttribute(IAttributeDefinition def, Asset asset) : base(def, asset) { }
/// <summary>
/// Searches shortest, all shortest or all paths starting from "myStart" to "myEnd".
/// </summary>
/// <param name="myTypeAttribute">The Attribute representing the edge to follow (p.e. "Friends")</param>
/// <param name="myTypeManager">The TypeManager for the Node type</param>
/// <param name="myDBObjectCache">The Object Cache for faster object lookup</param>
/// <param name="myStart">The start node</param>
/// <param name="myEnd">The end node</param>
/// <param name="shortestOnly">true, if only shortest path shall be found</param>
/// <param name="findAll">if true and shortestOnly is true, all shortest paths will be found. if true, and shortest only is false, all paths will be searched</param>
/// <param name="myMaxDepth">The maximum depth to search</param>
/// <param name="myMaxPathLength">The maximum path length which shall be analyzed</param>
/// <returns>A HashSet which contains all found paths. Every path is represented by a List of ObjectUUIDs</returns>
public HashSet <List <Tuple <long, long> > > Find(IAttributeDefinition myTypeAttribute,
IVertexType myVertexType,
IVertex myStart,
IVertex myEnd,
bool shortestOnly,
bool findAll,
UInt64 myMaxDepth,
UInt64 myMaxPathLength)
{
#region data
//queue for BFS
Queue <IVertex> queue = new Queue <IVertex>();
//Dictionary to store visited TreeNodes
Dictionary <Tuple <long, long>, Node> visitedNodes = new Dictionary <Tuple <long, long>, Node>();
HashSet <Tuple <long, long> > visitedVertices = new HashSet <Tuple <long, long> >();
//current depth
UInt64 depth = 1;
//first node in path tree, the start of the select
Node root = new Node(myStart.VertexTypeID, myStart.VertexID);
//target node, the target of the select
Node target = new Node(myEnd.VertexTypeID, myEnd.VertexID);
//dummy node to check in which level the BFS is
IVertex dummy = null;
//if the maxDepth is greater then maxPathLength, then set maxDepth to maxPathLength
if (myMaxDepth > myMaxPathLength)
{
myMaxDepth = myMaxPathLength;
}
else if (myMaxPathLength > myMaxDepth)
{
myMaxPathLength = myMaxDepth;
}
//enqueue first node to start the BFS
queue.Enqueue(myStart);
queue.Enqueue(dummy);
//add root to visitedNodes
visitedNodes.Add(root.Key, root);
//search the type on which the attribute is defined
IVertexType currentType = myVertexType;
List <IVertexType> tempList = new List <IVertexType>();
tempList.Add(currentType);
bool foundDefinedType = false;
while (currentType.HasParentType && !foundDefinedType)
{
if (currentType.ParentVertexType.HasAttribute(myTypeAttribute.Name))
{
foundDefinedType = true;
}
currentType = currentType.ParentVertexType;
tempList.Add(currentType);
}
if (foundDefinedType)
{
_Types = tempList;
}
else
{
_Types.Add(myVertexType);
}
#endregion
#region BFS
//check that the start node has the outgoing edge and the target has incoming vertices
if (!myStart.HasOutgoingEdge(myTypeAttribute.ID) && !HasIncomingVertices(myEnd, myTypeAttribute.ID))
{
return(null);
}
//if there is more than one object in the queue and the actual depth is less than MaxDepth
while ((queue.Count > 0) && (depth < myMaxDepth))
{
//get the first Object of the queue
IVertex currentVertex = queue.Dequeue();
//dummy
if (currentVertex == null || visitedVertices.Contains(new Tuple <long, long>(currentVertex.VertexTypeID, currentVertex.VertexID)))
{
continue;
}
Tuple <long, long> current = new Tuple <long, long>(currentVertex.VertexTypeID, currentVertex.VertexID);
Node currentNode;
visitedVertices.Add(current);
if (visitedNodes.ContainsKey(current))
{
currentNode = visitedNodes[current];
}
else
{
currentNode = new Node(current);
}
if (currentVertex.HasOutgoingEdge(myTypeAttribute.ID))
{
var vertices = currentVertex.GetOutgoingEdge(myTypeAttribute.ID).GetTargetVertices();
Node nextNode;
Tuple <long, long> next;
foreach (var vertex in vertices)
{
//create a new node and set currentNode = parent, nextNode = child
next = new Tuple <long, long>(vertex.VertexTypeID, vertex.VertexID);
nextNode = new Node(next, currentNode);
currentNode.addChild(nextNode);
//if the child is the target
if (nextNode.Equals(target))
{
//node points on the target
target.Parents.Add(currentNode);
//if shortestOnly == true we are finished here
if (shortestOnly)
{
if (findAll)
{
if (Convert.ToUInt64(depth + 1) <= myMaxPathLength)
{
//continue searching the current depth if there are any other shortest paths
myMaxDepth = Convert.ToUInt64(depth + 1);
myMaxPathLength = Convert.ToUInt64(depth + 1);
}
}
else
{
//got the shortest, finished
return(new TargetAnalyzer(root, target, myMaxPathLength, shortestOnly, findAll).GetPaths());
}
}
}
else
{
//been there before
if (visitedNodes.ContainsKey(nextNode.Key))
{
//node has more then one parent
visitedNodes[nextNode.Key].Parents.Add(currentNode);
}
//never seen before
else
{
//mark the node as visited
visitedNodes.Add(nextNode.Key, nextNode);
}
//and look what comes on the next level of depth
queue.Enqueue(vertex);
}
}
}
//if a new depth is reached
if (queue.First() == null)
{
//enqueue the dummy at the end of to mark the next depth
queue.Enqueue(queue.Dequeue());
//one step deeper in the dungen
depth++;
}
}
#endregion
//analyze paths
return(new TargetAnalyzer(root, target, myMaxPathLength, shortestOnly, findAll).GetPaths());
}
