public ConnectionCreator(Diagram diagram, Shape first, RelationshipType type)
{
this.diagram = diagram;
this.type = type;
this.first = first;
firstSelected = true;
}
public IRelationship CreateRelationship(TransactionFramework.ISoapTransactionLink transactionLink, Guid domainId, Guid rootMapId, Dictionary<ConnectionType, INode> nodes, RelationshipType relationshipType, string originalId)
{
FacadeRelationship facadeRelationship = new FacadeRelationship();
InProcess.InProcessRelationship relationship = new InProcess.InProcessRelationship(MapManager);
relationship.OriginLink = transactionLink;
relationship.Facade = facadeRelationship;
relationship.Id = Guid.NewGuid();
relationship.DomainId = domainId;
relationship.RootMapId = rootMapId;
relationship.RelationshipType = relationshipType;
relationship.OriginalId = originalId;
relationship.Status = LoadState.Full;
facadeRelationship.BaseRelationship = relationship;
foreach (KeyValuePair<ConnectionType, INode> relationshipContext in nodes)
{
ConnectionSet connection = ConnectionSetFactory.Instance.GetConnection(relationshipContext.Value, facadeRelationship, relationshipContext.Key);
INodeManager newRelationshipNodes = relationship.Nodes;
newRelationshipNodes.Load(connection);
IRelationshipManager nodeRelationships = relationshipContext.Value.Relationships;
nodeRelationships.Load(connection);
}
InProcessRelationships.Add(transactionLink, facadeRelationship);
return facadeRelationship;
}
public void ShouldHaveRelationshipType(RelationshipType expectedRelationshipType)
{
string errMessage = BaseMessage + string.Format(
"should have a RelationshipType '{0}' but is '{1}'", expectedRelationshipType, this.SingleRelationshipDef.RelationshipType);
Assert.AreEqual(expectedRelationshipType, this.SingleRelationshipDef.RelationshipType, errMessage);
}
public void AddRelationship(RelationshipType type)
{
if (type == RelationshipType.UseThis || type == RelationshipType.UsedBy)
OccurrenceCount++;
Relationships.Add(type);
}
internal Relationship(Type sourceType, string sourceMember, Type targetType, RelationshipType relationshipType, bool isOptional)
{
SourceType = sourceType;
SourceMember = sourceMember;
TargetType = targetType;
RelationshipType = relationshipType;
IsOptional = isOptional;
}
public Join(string originTable, string originColumn, string destinationTable, string destinationColumn, RelationshipType type)
{
this.OriginColumn = originColumn.ToUpper();
this.OriginTable = originTable.ToUpper();
this.DestinationColumn = destinationColumn.ToUpper();
this.DestinationTable = destinationTable.ToUpper();
this.RelationshipType = type;
}
public void AddRelationshipTypes(IEnumerable<Service.RT> serviceRelationshipTypes)
{
foreach (Service.RT serviceRelationshipType in serviceRelationshipTypes)
{
RelationshipType proxyRelationshipType = new RelationshipType();
proxyRelationshipType.LoadTypeInfo(serviceRelationshipType);
RelationshipTypes.Add(serviceRelationshipType, proxyRelationshipType);
}
}
public TypeResponse LoadTypesFromDb()
{
TypeResponse types = new TypeResponse();
SqlCommand selectTypes = new SqlCommand(SelectTypes, MapObjects.MapDbConnection.Connection);
MapObjects.MapDbConnection.Open();
SqlDataReader typesReader = selectTypes.ExecuteReader();
int count = 0;
do
{
count++;
while (typesReader.Read())
{
switch (count)
{
case 1:
NodeType nodeType = new NodeType();
nodeType.LoadSessionObject(typesReader);
types.NodeTypes[nodeType.Name] = nodeType;
break;
case 2:
RelationshipType relationshipType = new RelationshipType();
relationshipType.LoadSessionObject(typesReader);
types.RelationshipTypes[relationshipType.Name] = relationshipType;
break;
case 3:
DescriptorType descriptorType = new DescriptorType();
descriptorType.LoadSessionObject(typesReader);
types.DescriptorTypes[descriptorType.Name] = descriptorType;
break;
case 4:
MetadataType metadataType = new MetadataType();
metadataType.LoadSessionObject(typesReader);
types.MetadataTypes[metadataType.Name] = metadataType;
break;
default:
break;
}
}
}
while (typesReader.NextResult());
MapObjects.MapDbConnection.Close();
return types;
}
/// <summary>
/// Initializes a new instance of the <see cref="RelationshipSide"/> class.
/// </summary>
/// <param name="associationSetEnd">The <see cref="FromAssociationSetEnd"/> which describes this side of the relationship.</param>
/// <param name="relationshipType">The parent <see cref="RelationshipType"/>.</param>
internal RelationshipSide(AssociationSetEnd associationSetEnd, RelationshipType relationshipType)
{
this.FromAssociationSetEnd = associationSetEnd;
this.FromAssociationEnd = associationSetEnd.AssociationEnd;
this.FromEntitySet = associationSetEnd.EntitySet;
this.FromEntityType = this.FromAssociationEnd.EntityType;
this.FromDeleteBehavior = this.FromAssociationEnd.DeleteBehavior;
this.FromMultiplicity = this.FromAssociationEnd.Multiplicity;
this.FromNavigationProperty = this.FromAssociationEnd.FromNavigationProperty();
this.FromRoleName = this.FromAssociationEnd.RoleName;
this.RelationshipType = relationshipType;
}
public void DeleteRelationshipType(RelationshipType relationshipType)
{
Requires.NotNull("relationshipType", relationshipType);
_dataService.DeleteRelationshipType(relationshipType.RelationshipTypeId);
//log event
string logContent =
string.Format(Localization.GetString("RelationshipType_Deleted", Localization.GlobalResourceFile),
relationshipType.Name, relationshipType.RelationshipTypeId);
AddLog(logContent);
//clear cache
DataCache.RemoveCache(DataCache.RelationshipTypesCacheKey);
}
public override void Update(RelationshipType relationshipType, ref Soap.TransactionFramework.TransactionChain chain)
{
if (Facade != null)
{
AddRelationshipTransactionLink addRelationshipTransaction = Facade.TransactionOrigin as AddRelationshipTransactionLink;
if (addRelationshipTransaction != null)
{
if (addRelationshipTransaction.TransactionStatus == ServerStatus.ProcessingClient)
{
addRelationshipTransaction.RelationshipType = relationshipType;
return;
}
}
}
DelayedActions.Enqueue(new DelayedRelationshipAction() { Action = TransactionActionType.TypeUpdated, RelationshipType = relationshipType });
}
/// <summary>
///
/// </summary>
/// <param name="relationshipType"></param>
protected AutoMapRelationshipAttribute(RelationshipType relationshipType)
{
this.RelationshipType = relationshipType;
}
/// <summary>
/// </summary>
public AutoMapOneToManyAttribute(RelationshipType relationshipType) : base(relationshipType)
{
this.DeleteParentAction = DeleteParentAction.Prevent;
}
public CoupleOfHeroes(ICollection <Superhero> couple, RelationshipType relationship)
{
this.Relationship = relationship;
}
// Use this for initialization
void Start()
{
// get the canvas element
GameObject canvas = GameObject.FindGameObjectWithTag("Canvas");
// Lookups from string to enums!
string_enums = new Dictionary<string, RelationshipType>();
string_enums.Add("FRIEND", RelationshipType.FRIEND);
string_enums.Add("ENEMY", RelationshipType.ENEMY);
string_enums.Add("RIVAL", RelationshipType.RIVAL);
string_enums.Add("MEMBER", RelationshipType.MEMBER);
// instantiate the cast members!
gs = castLead.GetComponent<GuardScript>();
cast = new Dictionary<string, GameObject>();
for (int i = 0; i < castNames.Length; i++)
{
GameObject castMember = Instantiate(castMemberPrefab);
castMember.name = castNames[i];
// group connection
if (i == 4)
{
castMember.GetComponent<Demo3Character>().EntityType = EntityType.GROUP;
graph.AddDirectConnection(new Connection(castLead, castMember, member));
}
// direct connections
if (i < 4)
{
graph.AddDirectConnection(new Connection(castLead, castMember, friend));
}
// indirect connection
if (i > 5)
{
graph.AddConnection(castLead.GetComponent<Demo3Character>(), new Connection(cast[castNames[3]], cast[castNames[5]], rival));
}
if(i == 7)
{
graph.AddDirectConnection(new Connection(castLead, castMember, rival));
}
// connection known through group i.e. group knows so I know
if (i == 9)
{
graph.AddDirectConnection(new Connection(cast[castNames[4]], castMember, enemy));
}
// otherwise, the entities are unknown
int ypos = 250 - (i * 20);
GameObject castCheckbox = Instantiate(castMemberCheckPrefab, new Vector3(90, ypos, 0), Quaternion.identity) as GameObject;
castCheckbox.transform.SetParent(canvas.transform);
castCheckbox.GetComponentInChildren<Text>().text = castNames[i];
castCheckbox.name = castNames[i];
castCheckbox.GetComponent<Toggle>().group = GameObject.FindGameObjectWithTag("CastToggleGroup").GetComponent<ToggleGroup>();
if (i == 0)
{
castCheckbox.GetComponent<Toggle>().isOn = true;
}
// track the cast members
cast.Add(castNames[i], castMember);
}
activeRelationshipType = RelationshipType.FRIEND;
activeCastMember = cast[castNames[0]];
}
protected override void Visit(RelationshipType relationshipType)
{
base.Visit(relationshipType);
}
private static RelationshipType UpdateEntity(RelationshipType entity, RelationshipTypeUpdateModel model)
{
entity.Code = model.Code;
return(entity);
}
public override StandardExpander Add(RelationshipType type, Direction dir)
{
return(this);
}
/// <summary>
/// Copy constructor
/// </summary>
///
/// <param name="recordInfo">
/// The record info object which is to be used as the source
/// for the data.
/// </param>
///
internal HealthRecordInfo(HealthRecordInfo recordInfo)
: this(recordInfo.Connection as AuthenticatedConnection,
recordInfo.Id)
{
if (recordInfo.IsUpdated)
{
_custodian = recordInfo.IsCustodian;
_dateAuthorizationExpires = recordInfo.DateAuthorizationExpires;
_name = recordInfo.Name;
_relationshipType = recordInfo.RelationshipType;
_relationshipName = recordInfo.RelationshipName;
_displayName = recordInfo.DisplayName;
_updated = true;
}
}
public ProjectOrganizationForDiff(Models.Organization organization, RelationshipType relationshipType, string displayCssClassDeletedElement)
{
Organization = organization;
RelationshipType = relationshipType;
DisplayCssClass = displayCssClassDeletedElement;
}
/// <summary>
/// The constructor for constructing the RelationshipSet with a given name and an relationship type
/// </summary>
/// <param name="name"> The name of the RelationshipSet </param>
/// <param name="schema"> The db schema </param>
/// <param name="table"> The db table </param>
/// <param name="definingQuery"> The provider specific query that should be used to retrieve the EntitySet </param>
/// <param name="relationshipType"> The entity type of the entities that this entity set type contains </param>
/// <exception cref="System.ArgumentNullException">Thrown if the argument name or entityType is null</exception>
internal RelationshipSet(string name, string schema, string table, string definingQuery, RelationshipType relationshipType)
: base(name, schema, table, definingQuery, relationshipType)
{
}
public ConnectionCreator(ClassDiagram diagram, RelationshipType type)
{
this.diagram = diagram;
this.type = type;
}
public override string ToString()
{
StringBuilder __sb = new StringBuilder("Friend(");
bool __first = true;
if (UserInfo != null && __isset.userInfo)
{
if (!__first)
{
__sb.Append(", ");
}
__first = false;
__sb.Append("UserInfo: ");
__sb.Append(UserInfo == null ? "<null>" : UserInfo.ToString());
}
if (User != null && __isset.user)
{
if (!__first)
{
__sb.Append(", ");
}
__first = false;
__sb.Append("User: "******"<null>" : User.ToString());
}
if (AddedOn != null && __isset.addedOn)
{
if (!__first)
{
__sb.Append(", ");
}
__first = false;
__sb.Append("AddedOn: ");
__sb.Append(AddedOn);
}
if (RelationshipType != null && __isset.relationshipType)
{
if (!__first)
{
__sb.Append(", ");
}
__first = false;
__sb.Append("RelationshipType: ");
__sb.Append(RelationshipType == null ? "<null>" : RelationshipType.ToString());
}
if (__isset.isClose)
{
if (!__first)
{
__sb.Append(", ");
}
__first = false;
__sb.Append("IsClose: ");
__sb.Append(IsClose);
}
if (UserInfoPerson != null && __isset.userInfoPerson)
{
if (!__first)
{
__sb.Append(", ");
}
__first = false;
__sb.Append("UserInfoPerson: ");
__sb.Append(UserInfoPerson == null ? "<null>" : UserInfoPerson.ToString());
}
if (StatusType != null && __isset.statusType)
{
if (!__first)
{
__sb.Append(", ");
}
__first = false;
__sb.Append("StatusType: ");
__sb.Append(StatusType == null ? "<null>" : StatusType.ToString());
}
if (SettingPerson != null && __isset.settingPerson)
{
if (!__first)
{
__sb.Append(", ");
}
__first = false;
__sb.Append("SettingPerson: ");
__sb.Append(SettingPerson == null ? "<null>" : SettingPerson.ToString());
}
if (Country != null && __isset.country)
{
if (!__first)
{
__sb.Append(", ");
}
__first = false;
__sb.Append("Country: ");
__sb.Append(Country == null ? "<null>" : Country.ToString());
}
if (Industry != null && __isset.industry)
{
if (!__first)
{
__sb.Append(", ");
}
__first = false;
__sb.Append("Industry: ");
__sb.Append(Industry == null ? "<null>" : Industry.ToString());
}
if (__isset.canMessage)
{
if (!__first)
{
__sb.Append(", ");
}
__first = false;
__sb.Append("CanMessage: ");
__sb.Append(CanMessage);
}
if (__isset.dbStatusCode)
{
if (!__first)
{
__sb.Append(", ");
}
__first = false;
__sb.Append("DbStatusCode: ");
__sb.Append(DbStatusCode);
}
if (CTag != null && __isset.cTag)
{
if (!__first)
{
__sb.Append(", ");
}
__first = false;
__sb.Append("CTag: ");
__sb.Append(CTag);
}
if (__isset.friendshipStatus)
{
if (!__first)
{
__sb.Append(", ");
}
__first = false;
__sb.Append("FriendshipStatus: ");
__sb.Append(FriendshipStatus);
}
if (__isset.fromPhoneBook)
{
if (!__first)
{
__sb.Append(", ");
}
__first = false;
__sb.Append("FromPhoneBook: ");
__sb.Append(FromPhoneBook);
}
if (__isset.receiveConnectionRequest)
{
if (!__first)
{
__sb.Append(", ");
}
__first = false;
__sb.Append("ReceiveConnectionRequest: ");
__sb.Append(ReceiveConnectionRequest);
}
if (__isset.allowAddingChatGroup)
{
if (!__first)
{
__sb.Append(", ");
}
__first = false;
__sb.Append("AllowAddingChatGroup: ");
__sb.Append(AllowAddingChatGroup);
}
if (__isset.allowMsgForword)
{
if (!__first)
{
__sb.Append(", ");
}
__first = false;
__sb.Append("AllowMsgForword: ");
__sb.Append(AllowMsgForword);
}
if (__isset.dbSubStatusCode)
{
if (!__first)
{
__sb.Append(", ");
}
__first = false;
__sb.Append("DbSubStatusCode: ");
__sb.Append(DbSubStatusCode);
}
if (DbStatusMsg != null && __isset.dbStatusMsg)
{
if (!__first)
{
__sb.Append(", ");
}
__first = false;
__sb.Append("DbStatusMsg: ");
__sb.Append(DbStatusMsg);
}
if (__isset.requestId)
{
if (!__first)
{
__sb.Append(", ");
}
__first = false;
__sb.Append("RequestId: ");
__sb.Append(RequestId);
}
if (__isset.requestTypeId)
{
if (!__first)
{
__sb.Append(", ");
}
__first = false;
__sb.Append("RequestTypeId: ");
__sb.Append(RequestTypeId);
}
if (LastUpdated != null && __isset.lastUpdated)
{
if (!__first)
{
__sb.Append(", ");
}
__first = false;
__sb.Append("LastUpdated: ");
__sb.Append(LastUpdated);
}
__sb.Append(")");
return(__sb.ToString());
}
public void Write(TProtocol oprot)
{
TStruct struc = new TStruct("Friend");
oprot.WriteStructBegin(struc);
TField field = new TField();
if (UserInfo != null && __isset.userInfo)
{
field.Name = "userInfo";
field.Type = TType.Struct;
field.ID = 1;
oprot.WriteFieldBegin(field);
UserInfo.Write(oprot);
oprot.WriteFieldEnd();
}
if (User != null && __isset.user)
{
field.Name = "user";
field.Type = TType.Struct;
field.ID = 2;
oprot.WriteFieldBegin(field);
User.Write(oprot);
oprot.WriteFieldEnd();
}
if (AddedOn != null && __isset.addedOn)
{
field.Name = "addedOn";
field.Type = TType.String;
field.ID = 3;
oprot.WriteFieldBegin(field);
oprot.WriteString(AddedOn);
oprot.WriteFieldEnd();
}
if (RelationshipType != null && __isset.relationshipType)
{
field.Name = "relationshipType";
field.Type = TType.Struct;
field.ID = 4;
oprot.WriteFieldBegin(field);
RelationshipType.Write(oprot);
oprot.WriteFieldEnd();
}
if (__isset.isClose)
{
field.Name = "isClose";
field.Type = TType.Bool;
field.ID = 5;
oprot.WriteFieldBegin(field);
oprot.WriteBool(IsClose);
oprot.WriteFieldEnd();
}
if (UserInfoPerson != null && __isset.userInfoPerson)
{
field.Name = "userInfoPerson";
field.Type = TType.Struct;
field.ID = 6;
oprot.WriteFieldBegin(field);
UserInfoPerson.Write(oprot);
oprot.WriteFieldEnd();
}
if (StatusType != null && __isset.statusType)
{
field.Name = "statusType";
field.Type = TType.Struct;
field.ID = 7;
oprot.WriteFieldBegin(field);
StatusType.Write(oprot);
oprot.WriteFieldEnd();
}
if (SettingPerson != null && __isset.settingPerson)
{
field.Name = "settingPerson";
field.Type = TType.Struct;
field.ID = 8;
oprot.WriteFieldBegin(field);
SettingPerson.Write(oprot);
oprot.WriteFieldEnd();
}
if (Country != null && __isset.country)
{
field.Name = "country";
field.Type = TType.Struct;
field.ID = 9;
oprot.WriteFieldBegin(field);
Country.Write(oprot);
oprot.WriteFieldEnd();
}
if (Industry != null && __isset.industry)
{
field.Name = "industry";
field.Type = TType.Struct;
field.ID = 10;
oprot.WriteFieldBegin(field);
Industry.Write(oprot);
oprot.WriteFieldEnd();
}
if (__isset.canMessage)
{
field.Name = "canMessage";
field.Type = TType.Bool;
field.ID = 11;
oprot.WriteFieldBegin(field);
oprot.WriteBool(CanMessage);
oprot.WriteFieldEnd();
}
if (__isset.dbStatusCode)
{
field.Name = "dbStatusCode";
field.Type = TType.I32;
field.ID = 12;
oprot.WriteFieldBegin(field);
oprot.WriteI32(DbStatusCode);
oprot.WriteFieldEnd();
}
if (CTag != null && __isset.cTag)
{
field.Name = "cTag";
field.Type = TType.String;
field.ID = 13;
oprot.WriteFieldBegin(field);
oprot.WriteString(CTag);
oprot.WriteFieldEnd();
}
if (__isset.friendshipStatus)
{
field.Name = "friendshipStatus";
field.Type = TType.I32;
field.ID = 14;
oprot.WriteFieldBegin(field);
oprot.WriteI32(FriendshipStatus);
oprot.WriteFieldEnd();
}
if (__isset.fromPhoneBook)
{
field.Name = "fromPhoneBook";
field.Type = TType.Bool;
field.ID = 15;
oprot.WriteFieldBegin(field);
oprot.WriteBool(FromPhoneBook);
oprot.WriteFieldEnd();
}
if (__isset.receiveConnectionRequest)
{
field.Name = "receiveConnectionRequest";
field.Type = TType.Bool;
field.ID = 16;
oprot.WriteFieldBegin(field);
oprot.WriteBool(ReceiveConnectionRequest);
oprot.WriteFieldEnd();
}
if (__isset.allowAddingChatGroup)
{
field.Name = "allowAddingChatGroup";
field.Type = TType.Bool;
field.ID = 17;
oprot.WriteFieldBegin(field);
oprot.WriteBool(AllowAddingChatGroup);
oprot.WriteFieldEnd();
}
if (__isset.allowMsgForword)
{
field.Name = "allowMsgForword";
field.Type = TType.Bool;
field.ID = 18;
oprot.WriteFieldBegin(field);
oprot.WriteBool(AllowMsgForword);
oprot.WriteFieldEnd();
}
if (__isset.dbSubStatusCode)
{
field.Name = "dbSubStatusCode";
field.Type = TType.I32;
field.ID = 19;
oprot.WriteFieldBegin(field);
oprot.WriteI32(DbSubStatusCode);
oprot.WriteFieldEnd();
}
if (DbStatusMsg != null && __isset.dbStatusMsg)
{
field.Name = "dbStatusMsg";
field.Type = TType.String;
field.ID = 20;
oprot.WriteFieldBegin(field);
oprot.WriteString(DbStatusMsg);
oprot.WriteFieldEnd();
}
if (__isset.requestId)
{
field.Name = "requestId";
field.Type = TType.I32;
field.ID = 21;
oprot.WriteFieldBegin(field);
oprot.WriteI32(RequestId);
oprot.WriteFieldEnd();
}
if (__isset.requestTypeId)
{
field.Name = "requestTypeId";
field.Type = TType.I32;
field.ID = 22;
oprot.WriteFieldBegin(field);
oprot.WriteI32(RequestTypeId);
oprot.WriteFieldEnd();
}
if (LastUpdated != null && __isset.lastUpdated)
{
field.Name = "lastUpdated";
field.Type = TType.String;
field.ID = 23;
oprot.WriteFieldBegin(field);
oprot.WriteString(LastUpdated);
oprot.WriteFieldEnd();
}
oprot.WriteFieldStop();
oprot.WriteStructEnd();
}
/// <summary>
/// </summary>
public AutoMapManyToOneAttribute(RelationshipType relationshipType) : base(relationshipType)
{
}
public override StandardExpander add(RelationshipType type, Direction direction)
{
return(Create(type, direction));
}
public IEnumerable<IRelationship> FindRelationships(ConnectionType connectionType, RelationshipType relationshipType)
{
var output = new List<IRelationship>();
foreach (var connection in Connections)
{
if (connection.ConnectionType.Equals(connectionType))
{
if (connection.Relationship.RelationshipType.Equals(relationshipType))
{
if (output.All(q => q.Id != connection.Relationship.Id))
{
output.Add(connection.Relationship);
}
}
}
}
return output;
//IEnumerable<IRelationship> relationships = from relationshipPair in Connections
// where relationshipPair.ConnectionType == connectionType && relationshipPair.Relationship.RelationshipType == relationshipType
// select relationshipPair.Relationship;
///// TODO: This need to be replaced with a proper and more efficient fix. There are other places this needs to be fix, search for 6218535.
//return relationships.Distinct(new EqualityComparer2());
}
public UseCaseConnectionCreator(UseCaseDiagram diagram, RelationshipType type) :
base(diagram, type)
{
}
/// <summary>
/// Parses HealthRecordInfo member data from the specified XPathNavigator.
/// </summary>
///
/// <param name="navigator">
/// The XML containing the record information.
/// </param>
///
internal override void ParseXml(XPathNavigator navigator)
{
base.ParseXml(navigator);
_custodian = XPathHelper.ParseAttributeAsBoolean(navigator, "record-custodian", false);
long? relationshipNumber = null;
relationshipNumber = XPathHelper.ParseAttributeAsLong(navigator, "rel-type", 0);
if (relationshipNumber.HasValue &&
(relationshipNumber <= (int)RelationshipType.Daughter))
{
_relationshipType = (RelationshipType)relationshipNumber;
}
_relationshipName = navigator.GetAttribute("rel-name", String.Empty);
_dateAuthorizationExpires = XPathHelper.ParseAttributeAsDateTime(navigator, "auth-expires", DateTime.MinValue);
_authExpired = XPathHelper.ParseAttributeAsBoolean(navigator, "auth-expired", false);
_name = navigator.Value;
_displayName = navigator.GetAttribute("display-name", String.Empty);
_state = XPathHelper.ParseAttributeAsEnum<HealthRecordState>(navigator, "state", HealthRecordState.Unknown);
if (_state > HealthRecordState.Deleted)
{
_state = HealthRecordState.Unknown;
}
_dateCreated = XPathHelper.ParseAttributeAsDateTime(navigator, "date-created", DateTime.MinValue);
_quotaInBytes = XPathHelper.ParseAttributeAsLong(navigator, "max-size-bytes", null);
_quotaUsedInBytes = XPathHelper.ParseAttributeAsLong(navigator, "size-bytes", null);
_authorizationStatus = XPathHelper.ParseAttributeAsEnum<HealthRecordAuthorizationStatus>(
navigator,
"app-record-auth-action",
HealthRecordAuthorizationStatus.Unknown);
_applicationSpecificRecordId = navigator.GetAttribute("app-specific-record-id", String.Empty);
_updated = true;
}
public virtual MySQLConditionBuilder Or(ISqlConditionBuilder condition)
{
this.right = condition;
this.relationship = RelationshipType.Or;
return(this);
}
public override VirtualDataTable FilterData(string newDataName, string rowFilter)
{
if (rowFilter == null || rowFilter.Length == 0)
{
return(new ComplexVirtualArrayDataSource(this, FData, FColumnCaptions, newDataName)); //no need to copy the data since it is invariant.
}
RelationshipType Relationship = RelationshipType.Equals;
//on this demo we will only support filters of the type: "field = value", "field > value" or "field < value"
string[] filteredData = rowFilter.Split('=');
if (filteredData == null || filteredData.Length != 2)
{
filteredData = rowFilter.Split('<');
if (filteredData == null || filteredData.Length != 2)
{
filteredData = rowFilter.Split('>');
if (filteredData == null || filteredData.Length != 2)
{
throw new Exception("Filter \"" + rowFilter + "\" is invalid. The dataset \"" + TableName + "\" only supports filters of the type \"field =/>/< value\".");
}
else
{
Relationship = RelationshipType.BiggerThan;
}
}
else
{
Relationship = RelationshipType.LessThan;
}
}
int ColIndex = GetColumn(filteredData[0].Trim());
if (ColIndex < 0)
{
throw new Exception("Filter \"" + rowFilter + "\" is invalid. Can not find column \"" + filteredData[0].Trim() + "\"");
}
//Remember, this is only a demo to show what to do in this event. This code is not good code to use on
//a real application!. You should use some index here to find the data or this would crawl on large objects.
List <object[]> Result = new List <object[]>();
string SearchValue = filteredData[1].Trim();
double Searchfloat = 0;
if (Relationship != RelationshipType.Equals) //when relationship is not equals, we will assume columns are numbers. This is because we do not have any type definition for our columns on this simple example.
{
Searchfloat = Convert.ToDouble(filteredData[1].Trim());
}
foreach (object[] Row in Data)
{
switch (Relationship)
{
case RelationshipType.Equals:
if (Convert.ToString(Row[ColIndex]) == SearchValue)
{
Result.Add(Row); //remember, data is invariant, so we do not need to clone Row.
}
break;
case RelationshipType.LessThan:
if (Convert.ToDouble(Row[ColIndex]) < Searchfloat)
{
Result.Add(Row); //remember, data is invariant, so we do not need to clone Row.
}
break;
case RelationshipType.BiggerThan:
if (Convert.ToDouble(Row[ColIndex]) > Searchfloat)
{
Result.Add(Row); //remember, data is invariant, so we do not need to clone Row.
}
break;
}
}
return(new ComplexVirtualArrayDataSource(this, Result.ToArray(), FColumnCaptions, newDataName));
}
/// <summary>
/// Declares that the decorated property contains the ID of the specified Type of object
/// </summary>
/// <param name="cref"></param>
/// <param name="type"></param>
/// <param name="propertyName"></param>
public RelationshipAttribute(Type cref, RelationshipType type, [CallerMemberName] string propertyName = null)
{
Cref = cref;
Type = type;
PropertyName = propertyName;
}
private MultipleRelationship <ContactPersonTestBO> GetRelationship(OrganisationTestBO organisationTestBO, RelationshipType relationshipType, out BusinessObjectCollection <ContactPersonTestBO> cpCol)
{
MultipleRelationship <ContactPersonTestBO> relationship =
organisationTestBO.Relationships.GetMultiple <ContactPersonTestBO>("ContactPeople");
RelationshipDef relationshipDef = (RelationshipDef)relationship.RelationshipDef;
relationshipDef.RelationshipType = relationshipType;
cpCol = relationship.BusinessObjectCollection;
return(relationship);
}
/// <summary>
/// Initialises a new instance of the <see cref="SMEGuidProperty"/> class
/// with the specified label.
/// </summary>
/// <param name="label">The label for the property.</param>
/// <param name="relationship">Indicates the relationship of the other type
/// to this type.</param>
/// <param name="includeByDefault">Is the object included by default in the
/// feed?</param>
public SMERelationshipProperty(string label, RelationshipType relationship, bool includeByDefault)
: base(label)
{
_eRelationship = relationship;
_bIncludeByDefault = includeByDefault;
}
public TypeRelationshipInfo(RelationshipType relationshipType, PropertyDescriptor referencingProperty, PropertyDescriptor targetProperty)
{
this.RelationshipType = relationshipType;
this.ReferencingProperty = referencingProperty;
this.TargetProperty = targetProperty;
}
public override void CreateConnection(RelationshipType type)
{
connectionCreator = new ClassConnectionCreator(this, type);
base.CreateConnection(type);
}
public SMERelationshipProperty(SMERelationshipProperty copy)
{
_eRelationship = copy.Relationship;
_bIncludeByDefault = copy.IncludeByDefault;
_bCanGet = copy.CanGet;
_bCanPost = copy.CanPost;
_bCanPut = copy.CanPut;
_bCanDelete = copy.CanDelete;
_bCanPagePrevious = copy.CanPagePrevious;
_bCanPageNext = copy.CanPageNext;
_bCanPageIndex = copy.CanPageIndex;
_bIsCollection = copy.IsCollection;
}
private MultipleRelationship <ContactPersonTestBO> GetAggregationRelationship(OrganisationTestBO organisationTestBO, out BusinessObjectCollection <ContactPersonTestBO> cpCol)
{
const RelationshipType relationshipType = RelationshipType.Aggregation;
return(GetRelationship(organisationTestBO, relationshipType, out cpCol));
}
public virtual StandardExpansion <T> Including(RelationshipType type, Direction direction)
{
return(CreateNew(Expander.add(type, direction)));
}
/// <summary>
/// Dumps the specified Relation metadata instance with the specified decoration
/// </summary>
/// <param name="type">The Relation metadata to dump</param>
/// <param name="name">The decorating block name</param>
internal void Dump(RelationshipType type, string name)
{
Begin(name);
Dump(type);
End(name);
}
/// <summary>
/// Initialises a new instance of the <see cref="SMEGuidProperty"/> class
/// with the specified label.
/// </summary>
/// <param name="label">The label for the property.</param>
/// <param name="relationship">Indicates the relationship of the other type
/// to this type.</param>
/// <param name="includeByDefault">Is the object included by default in the
/// feed?</param>
public SMERelationshipProperty(string label, RelationshipType relationship)
: this(label, relationship, false)
{
}
public virtual StandardExpansion <T> Excluding(RelationshipType type)
{
return(CreateNew(Expander.remove(type)));
}
protected override void OnLoadUnhandledAttribute(XmlAttribute attribute)
{
if (attribute.NamespaceURI == Framework.Common.SME.Namespace)
{
switch (attribute.LocalName)
{
case IncludeByDefaultName:
bool.TryParse(attribute.Value, out _bIncludeByDefault);
break;
case RelationshipName:
_eRelationship = GetRelationshipType(attribute.Value);
break;
case CanGetName:
bool.TryParse(attribute.Value, out _bCanGet);
break;
case CanPostName:
bool.TryParse(attribute.Value, out _bCanPost);
break;
case CanPutName:
bool.TryParse(attribute.Value, out _bCanPut);
break;
case CanDeleteName:
bool.TryParse(attribute.Value, out _bCanDelete);
break;
case CanPagePreviousName:
bool.TryParse(attribute.Value, out _bCanPagePrevious);
break;
case CanPageNextName:
bool.TryParse(attribute.Value, out _bCanPageNext);
break;
case CanPageIndexName:
bool.TryParse(attribute.Value, out _bCanPageIndex);
break;
case IsCollectionName:
bool.TryParse(attribute.Value, out _bIsCollection);
break;
}
}
else if (attribute.NamespaceURI == Framework.Common.XS.Namespace)
{
switch (attribute.LocalName)
{
case SDataResource.XmlConstants.MinOccurs:
int.TryParse(attribute.Value, out _iMinOccurs);
break;
case SDataResource.XmlConstants.MaxOccurs:
if (attribute.Value.ToLower() == SDataResource.XmlConstants.Unbounded)
_iMaxOccurs = -1;
else
int.TryParse(attribute.Value, out _iMaxOccurs);
break;
}
}
base.OnLoadUnhandledAttribute(attribute);
}
public MapParameter AddRelationship(string callingUrl, Guid sessionId, MapParameter domainId, MapParameter rootMapId, Dictionary <DescriptorType, MapParameter> nodes, RelationshipType relationshipType, string originalId)
{
return(AddBulkRelationship(callingUrl, sessionId, Guid.Empty, domainId, rootMapId, nodes, relationshipType, originalId));
}
public void SetActiveRelationshipType()
{
// this is an EXTREMELY poor hack but will work for now
foreach(GameObject go in GameObject.FindGameObjectsWithTag("RELATIONSHIP"))
{
if(go.GetComponent<Toggle>().isOn)
{
activeRelationshipType = string_enums[go.name];
}
}
}
public MapParameter UpdateRelationship(string callingUrl, Guid sessionId, MapParameter domainId, MapParameter relationshipId, Dictionary <DescriptorType, MapParameter> nodes, RelationshipType relationshipType)
{
return(UpdateBulkRelationship(callingUrl, sessionId, Guid.Empty, domainId, relationshipId, nodes, relationshipType));
}
// ReSharper disable DoNotCallOverridableMethodsInConstructor
///<summary>
/// Constructs a single Relationship
///</summary>
///<param name="relationshipName"></param>
///<param name="relatedObjectAssemblyName"></param>
///<param name="relatedObjectClassName"></param>
///<param name="relKeyDef"></param>
///<param name="keepReferenceToRelatedObject"></param>
///<param name="deleteParentAction"></param>
///<param name="insertParentAction"><see cref="InsertParentAction"/></param>
///<param name="relationshipType"></param>
public SingleRelationshipDef(string relationshipName, string relatedObjectAssemblyName,
string relatedObjectClassName, IRelKeyDef relKeyDef,
bool keepReferenceToRelatedObject, DeleteParentAction deleteParentAction,
InsertParentAction insertParentAction, RelationshipType relationshipType)
: base(
relationshipName, relatedObjectAssemblyName, relatedObjectClassName, relKeyDef,
keepReferenceToRelatedObject, deleteParentAction, insertParentAction, relationshipType)
{
OwningBOHasForeignKey = true;
}
public MapParameter UpdateBulkRelationship(string callingUrl, Guid sessionId, Guid responseParameter, MapParameter domainId, MapParameter relationshipId, Dictionary <DescriptorType, MapParameter> nodes, RelationshipType relationshipType)
{
using (GlymaNSApp.NodeServiceClient nodeServiceClient = new GlymaNSApp.NodeServiceClient(callingUrl))
{
return(nodeServiceClient.UpdateBulkRelationship(callingUrl, sessionId, responseParameter, domainId, relationshipId, nodes, relationshipType));
}
}
/// <summary>
///
/// </summary>
/// <param name="reverseRelationshipName"></param>
/// <param name="relationshipType"></param>
protected AutoMapRelationshipAttribute(string reverseRelationshipName, RelationshipType relationshipType)
{
this.ReverseRelationshipName = reverseRelationshipName;
this.RelationshipType = relationshipType;
}
private TreeNode UpdateModDependencyGraphRecursively(TreeNode parentNode, CkanModule module, RelationshipType relationship, int depth, bool virtualProvides = false)
{
if (module == null ||
(depth > 0 && dependencyGraphRootModule == module) ||
(alreadyVisited.Contains(module)))
{
return(null);
}
alreadyVisited.Add(module);
string nodeText = module.name;
if (virtualProvides)
{
nodeText = String.Format("provided by - {0}", module.name);
}
var node = parentNode == null ? new TreeNode(nodeText) : parentNode.Nodes.Add(nodeText);
IEnumerable <RelationshipDescriptor> relationships = null;
switch (relationship)
{
case RelationshipType.Depends:
relationships = module.depends;
break;
case RelationshipType.Recommends:
relationships = module.recommends;
break;
case RelationshipType.Suggests:
relationships = module.suggests;
break;
case RelationshipType.Supports:
relationships = module.supports;
break;
}
if (relationships == null)
{
return(node);
}
foreach (RelationshipDescriptor dependency in relationships)
{
Registry registry = RegistryManager.Instance(manager.CurrentInstance).registry;
try
{
try
{
var dependencyModule = registry.LatestAvailable
(dependency.name, manager.CurrentInstance.Version());
UpdateModDependencyGraphRecursively(node, dependencyModule, relationship, depth + 1);
}
catch (ModuleNotFoundKraken)
{
List <CkanModule> dependencyModules = registry.LatestAvailableWithProvides
(dependency.name, manager.CurrentInstance.Version());
if (dependencyModules == null)
{
continue;
}
var newNode = node.Nodes.Add(dependency.name + " (virtual)");
newNode.ForeColor = Color.Gray;
foreach (var dep in dependencyModules)
{
UpdateModDependencyGraphRecursively(newNode, dep, relationship, depth + 1, true);
}
}
}
catch (Exception)
{
}
}
if (virtualProvides)
{
node.Collapse(true);
}
else
{
node.ExpandAll();
}
return(node);
}
/// <summary>
/// </summary>
public AutoMapOneToManyAttribute(string reverseRelationshipName, RelationshipType relationshipType, DeleteParentAction deleteParentAction) : base(reverseRelationshipName, relationshipType)
{
this.DeleteParentAction = deleteParentAction;
}
/// <summary>
/// Withes the type of the relatioship.
/// </summary>
/// <param name="relationshipType">Type of the relationship.</param>
/// <returns></returns>
public ReferenceMap WithRelatioshipType(RelationshipType relationshipType)
{
return(null);
}
/// <summary>
/// </summary>
public AutoMapManyToOneAttribute(string reverseRelationshipName, RelationshipType relationshipType) : base(reverseRelationshipName, relationshipType)
{
}
private TreeNode findDependencyShallow(IRegistryQuerier registry, string identifier, RelationshipType relationship, KspVersionCriteria crit)
{
try
{
CkanModule dependencyModule = registry.LatestAvailable(identifier, crit);
if (dependencyModule != null)
{
return(indexedNode(registry, dependencyModule, relationship, crit != null));
}
}
catch (ModuleNotFoundKraken)
{
// If we don't find a module by this name, look for other modules that provide it.
List <CkanModule> dependencyModules = registry.LatestAvailableWithProvides(identifier, crit);
if (dependencyModules != null && dependencyModules.Count > 0)
{
List <TreeNode> children = new List <TreeNode>();
foreach (CkanModule dep in dependencyModules)
{
children.Add(indexedNode(registry, dep, relationship, crit != null));
}
return(providesNode(identifier, relationship, children));
}
}
return(null);
}
public IEnumerable<KeyValuePair<ConnectionType, IRelationship>> FindRelationships(RelationshipType relationshipType)
{
IEnumerable<KeyValuePair<ConnectionType, IRelationship>> relationships = from relationshipPair in Connections
where relationshipPair.Relationship.RelationshipType.Equals(relationshipType)
select (new KeyValuePair<ConnectionType, IRelationship>(relationshipPair.ConnectionType, relationshipPair.Relationship));
/// TODO: This need to be replaced with a proper and more efficient fix. There are other places this needs to be fix, search for 6218535.
return relationships.Distinct(new EqualityComparer1());
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldAddRelationshipToExplicitIndex() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldAddRelationshipToExplicitIndex()
{
long relId;
using (Org.Neo4j.Graphdb.Transaction ctx = graphDb.beginTx())
{
relId = graphDb.createNode().createRelationshipTo(graphDb.createNode(), RelationshipType.withName("R")).Id;
ctx.Success();
}
using (Transaction tx = beginTransaction())
{
ExplicitIndexWrite indexWrite = tx.IndexWrite();
indexWrite.RelationshipAddToExplicitIndex(INDEX_NAME, relId, KEY, VALUE);
tx.Success();
}
// Then
using (Org.Neo4j.Graphdb.Transaction ctx = graphDb.beginTx())
{
IndexHits <Relationship> hits = graphDb.index().forRelationships(INDEX_NAME).get(KEY, VALUE);
//JAVA TO C# CONVERTER TODO TASK: Java iterators are only converted within the context of 'while' and 'for' loops:
assertThat(hits.next().Id, equalTo(relId));
hits.Close();
ctx.Success();
}
}
/// <summary>
/// Updates the <see cref="HealthRecordInfo"/> instance with data from
/// the server using the <see cref="HealthRecordAccessor.Id"/>.
/// </summary>
///
/// <remarks>
/// This method accesses the HealthVault service across the network.
/// </remarks>
///
/// <exception cref="InvalidOperationException">
/// This method is called and the
/// <see cref="HealthRecordAccessor.Connection"/>
/// object of the <see cref="HealthRecordInfo"/> is not an
/// <see cref="AuthenticatedConnection"/>.
/// </exception>
///
public void Refresh()
{
AuthenticatedConnection connection =
Connection as AuthenticatedConnection;
if (connection == null)
{
OfflineWebApplicationConnection offlineAuthConnection =
Connection as OfflineWebApplicationConnection;
Validator.ThrowInvalidIfNull(offlineAuthConnection, "ConnectionIsNeitherAuthenticatedNorOffline");
}
Collection<HealthRecordInfo> records =
HealthVaultPlatform.GetAuthorizedRecords(Connection, new Guid[] { this.Id });
if (records.Count == 0)
{
HealthServiceResponseError error = new HealthServiceResponseError();
error.Message =
ResourceRetriever.FormatResourceString(
"RecordNotFoundException",
this.Id);
HealthServiceException e =
HealthServiceExceptionHelper.GetHealthServiceException(
HealthServiceStatusCode.RecordNotFound,
error);
throw e;
}
HealthRecordInfo thisRecord = records[0];
this._custodian = thisRecord.IsCustodian;
this._name = thisRecord.Name;
this._relationshipName = thisRecord.RelationshipName;
this._relationshipType = thisRecord.RelationshipType;
this._dateAuthorizationExpires = thisRecord.DateAuthorizationExpires;
this._quotaInBytes = thisRecord.QuotaInBytes;
this._quotaUsedInBytes = thisRecord.QuotaUsedInBytes;
this._state = thisRecord.State;
this._dateCreated = thisRecord.DateCreated;
this._displayName = thisRecord.DisplayName;
this._authExpired = thisRecord.HasAuthorizationExpired;
this._updated = true;
}
private long AddRelationshipToExplicitIndex()
{
long relId;
using (Org.Neo4j.Graphdb.Transaction ctx = graphDb.beginTx())
{
Relationship rel = graphDb.createNode().createRelationshipTo(graphDb.createNode(), RelationshipType.withName("R"));
relId = rel.Id;
graphDb.index().forRelationships(INDEX_NAME).add(rel, KEY, VALUE);
ctx.Success();
}
return(relId);
}
/// <summary>
/// Adds an edge to the graph, where an edge is defined as a relationship between 2 AS's.
/// This only adds the edge in one direction, from the src node to the dest node.
/// This does not check for duplicates.
/// </summary>
public void AddEdge(UInt32 srcNodeNum, UInt32 destNodeNum, RelationshipType relationshipType)
{
// Retrieve the src and dest nodes
AsNode srcNode = GetOrCreateNode(srcNodeNum);
AsNode destNode = GetOrCreateNode(destNodeNum);
// Add the edge to the source node
srcNode.AddNeighbor(destNode, relationshipType);
EdgeCount++;
}
internal RelProperty(RelationshipType relationshipType, RelationshipEndMember fromEnd, RelationshipEndMember toEnd)
{
m_relationshipType = relationshipType;
m_fromEnd = fromEnd;
m_toEnd = toEnd;
}
