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; }