protected void VisitEntityIdentity(EntityIdentity entityIdentity, TArgType arg)
        {
            DiscriminatedEntityIdentity entityIdentity1 = entityIdentity as DiscriminatedEntityIdentity;

            if (entityIdentity1 != null)
            {
                this.VisitEntityIdentity(entityIdentity1, arg);
            }
            else
            {
                this.VisitEntityIdentity((SimpleEntityIdentity)entityIdentity, arg);
            }
        }
Example #2
0
        internal override ColumnMap Visit(
            EntityColumnMap columnMap,
            ColumnMapTranslatorTranslationDelegate translationDelegate)
        {
            EntityIdentity entityIdentity = this.VisitEntityIdentity(columnMap.EntityIdentity, translationDelegate);

            this.VisitList <ColumnMap>(columnMap.Properties, translationDelegate);
            if (entityIdentity != columnMap.EntityIdentity)
            {
                columnMap = new EntityColumnMap(columnMap.Type, columnMap.Name, columnMap.Properties, entityIdentity);
            }
            return(translationDelegate((ColumnMap)columnMap));
        }
        protected void VisitEntityIdentity(EntityIdentity entityIdentity, TArgType arg)
        {
            var dei = entityIdentity as DiscriminatedEntityIdentity;

            if (null != dei)
            {
                VisitEntityIdentity(dei, arg);
            }
            else
            {
                VisitEntityIdentity((SimpleEntityIdentity)entityIdentity, arg);
            }
        }
Example #4
0
 private static GetItemRequest CreateGetLoanOfferRequest(EntityIdentity offerId)
 => new GetItemRequest
 {
     TableName       = LoanOfferTableName,
     Key             = GetDictionaryWithIdAttribute(offerId),
     AttributesToGet = new List <string>
     {
         IdDynamoFieldName,
         PeselNumberDynamoFieldName,
         EmailAddressDynamoFieldName,
         MaxLoanAmountDynamoFieldName
     }
 };
        public void WhenAnEditorValueIsCreated_TheEditorIsTheProviderState()
        {
            var properties = PropertiesAvailableStatusFactory.CreateUIPropertyEditorPropertiesAvailableStatus(includeName: true);

            var context = IQueryExecutionContextFactory.Create();
            var id      = new EntityIdentity(key: "EditorKey", value: "bbb");
            var editor  = new ValueEditor {
                EditorType = "My.Editor.Type"
            };

            var result = (UIPropertyEditorValue)UIPropertyEditorDataProducer.CreateEditorValue(context, id, editor, properties);

            Assert.Equal(expected: editor, actual: ((IEntityValueFromProvider)result).ProviderState);
        }
        public void WhenPropertiesAreRequested_PropertyValuesAreReturned()
        {
            var properties = PropertiesAvailableStatusFactory.CreateUIPropertyEditorPropertiesAvailableStatus(includeName: true);

            var context = IQueryExecutionContextFactory.Create();
            var id      = new EntityIdentity(key: "EditorKey", value: "bbb");
            var editor  = new ValueEditor {
                EditorType = "My.Editor.Type"
            };

            var result = (UIPropertyEditorValue)UIPropertyEditorDataProducer.CreateEditorValue(context, id, editor, properties);

            Assert.Equal(expected: "My.Editor.Type", actual: result.Name);
        }
Example #7
0
        public async Task <IEnumerable <IEntityValue> > RetrieveAllLaunchProfileEntitiesAsync(IQueryExecutionContext queryExecutionContext, IEntityValue parent, ILaunchProfilePropertiesAvailableStatus requestedProperties)
        {
            if (await _project.GetProjectLevelPropertyPagesCatalogAsync() is IPropertyPagesCatalog projectCatalog)
            {
                ILaunchSettings launchSettings = await _launchSettingsProvider.WaitForFirstSnapshot();

                return(createLaunchProfileValues(launchSettings));
            }

            return(Enumerable.Empty <IEntityValue>());

            IEnumerable <IEntityValue> createLaunchProfileValues(ILaunchSettings launchSettings)
            {
                Dictionary <string, Rule> debugRules = new();

                foreach (Rule rule in DebugUtilities.GetDebugChildRules(projectCatalog))
                {
                    if (rule.Metadata.TryGetValue(s_commandNameMetadataName, out object?commandNameObj) &&
                        commandNameObj is string commandName)
                    {
                        debugRules[commandName] = rule;
                    }
                }

                if (launchSettings is IVersionedLaunchSettings versionedLaunchSettings)
                {
                    queryExecutionContext.ReportInputDataVersion(_launchSettingsTracker.VersionKey, versionedLaunchSettings.Version);
                }

                IProjectState projectState = new LaunchProfileProjectState(_project, _launchSettingsProvider, _launchSettingsTracker);

                foreach ((int index, ProjectSystem.Debug.ILaunchProfile profile) in launchSettings.Profiles.WithIndices())
                {
                    if (!Strings.IsNullOrEmpty(profile.Name) &&
                        !Strings.IsNullOrEmpty(profile.CommandName) &&
                        debugRules.TryGetValue(profile.CommandName, out Rule rule))
                    {
                        QueryProjectPropertiesContext propertiesContext = new(
                            isProjectFile : true,
                            file : _project.FullPath,
                            itemType : LaunchProfileProjectItemProvider.ItemType,
                            itemName : profile.Name);

                        EntityIdentity id = CreateLaunchProfileId(parent, profile.Name);
                        IEntityValue   launchProfileValue = CreateLaunchProfileValue(queryExecutionContext, id, propertiesContext, rule, index, projectState, requestedProperties);
                        yield return(launchProfileValue);
                    }
                }
            }
        }
        public void WhenCategoryValueCreated_TheCategoryIsTheProviderState()
        {
            var properties = PropertiesAvailableStatusFactory.CreateCategoryPropertiesAvailableStatus(includeAllProperties: true);

            var entityRuntime = IEntityRuntimeModelFactory.Create();
            var id            = new EntityIdentity(key: "A", value: "B");
            var category      = new Category {
                DisplayName = "CategoryDisplayName", Name = "CategoryName"
            };
            var order = 42;

            var result = (CategoryValue)CategoryDataProducer.CreateCategoryValue(entityRuntime, id, category, order, properties);

            Assert.Equal(expected: category, actual: ((IEntityValueFromProvider)result).ProviderState);
        }
Example #9
0
        public async Task <AddRefResponse> AddRefAsync(EntityIdentity refListIdentity, int refIndex, Ref refe)
        {
            var query =
                from l in _refsContext.RefLists.Include("Refs")
                where l.Id == refListIdentity.Id
                select l;

            var storedRefList = await query.SingleAsync();

            BusinessContract.ValidateWritePermission(storedRefList.AuthorId);
            BusinessContract.ValidateRowVersion(storedRefList.RowVersion, refListIdentity.RowVersion);

            refe.RefListId = 0;
            refe.RefList   = null;

            var refs = storedRefList.Refs.OrderBy(r => r.DisplayOrder).ToList();

            refs.Insert(refIndex, refe);
            for (int i = 0; i < refs.Count; ++i)
            {
                refs[i].DisplayOrder = i;
            }

            storedRefList.Refs.Add(refe);

            /// update statistics
            if (refe.Kind == RefKind.Link)
            {
                var statisticsQuery  = _refsContext.RefListStatistics.Where(s => s.RefListId == refListIdentity.Id);
                var storedStatistics = await statisticsQuery.SingleAsync();

                storedStatistics.LinkCount = storedRefList.Refs.Count(r => r.Kind == RefKind.Link);
            }

            _refsContext.MarkAsModified(storedRefList);
            await _refsContext.SaveChangesAsync();

            SendRefListUpdated(refListIdentity.Id);

            var ret = new AddRefResponse()
            {
                RefListIdentity = new EntityIdentity(storedRefList.Id, storedRefList.RowVersion),
                RefId           = refe.Id,
            };

            return(ret);
        }
        public void WhenPropertiesAreRequested_PropertyValuesAreReturned()
        {
            var properties = PropertiesAvailableStatusFactory.CreateCategoryPropertiesAvailableStatus(includeAllProperties: true);

            var entityRuntime = IEntityRuntimeModelFactory.Create();
            var id            = new EntityIdentity(key: "A", value: "B");
            var category      = new Category {
                DisplayName = "CategoryDisplayName", Name = "CategoryName"
            };
            var order = 42;

            var result = (CategoryValue)CategoryDataProducer.CreateCategoryValue(entityRuntime, id, category, order, properties);

            Assert.Equal(expected: "CategoryDisplayName", actual: result.DisplayName);
            Assert.Equal(expected: "CategoryName", actual: result.Name);
            Assert.Equal(expected: 42, actual: result.Order);
        }
Example #11
0
        public Service(IHttpContextAccessor httpContextAccessor, IMongoRepository <TIdentifiable> repository) : base(repository)
        {
            _httpContext = httpContextAccessor.HttpContext;

            // Get user logged in.
            var user = GetBeAuthIdentity();

            // Create Entity Identity.
            _identity = new EntityIdentity
            {
                CreatedBy = user.FindFirst(SubscriptionClaimTypes.User).Value,
                OwnedBy   = user.FindFirst(SubscriptionClaimTypes.Owner).Value
            };

            // Check Owner
            _isOwner = _identity.CreatedBy == _identity.OwnedBy;
        }
Example #12
0
        public async Task RemoveTagUsesAsync(EntityIdentity identity)
        {
            SystemContract.RequireEntityIdentity(identity);

            var query = _refsContext.TagUses.Include("RefLists").
                        Where(t => t.Id == identity.Id);

            var storedTagUse = await query.SingleAsync();

            BusinessContract.ValidateRowVersion(storedTagUse.RowVersion, identity.RowVersion);
            BusinessContract.ValidateWritePermission(storedTagUse.OwnerId);

            storedTagUse.RefLists.Clear();
            _refsContext.TagUses.Remove(storedTagUse);

            await _refsContext.SaveChangesAsync();
        }
Example #13
0
        public async Task <EntityIdentity> UpdateRefAsync(EntityIdentity identity, Ref updatedRef)
        {
            var query =
                from r in _refsContext.Refs.Include("RefList")
                where r.Id == updatedRef.Id
                select r;

            var storedRef = await query.SingleAsync();

            if (storedRef.RefListId != identity.Id)
            {
                throw new ArgumentException("リストのIdが正しくありません");
            }
            BusinessContract.ValidateWritePermission(storedRef.RefList.AuthorId);
            BusinessContract.ValidateRowVersion(storedRef.RefList.RowVersion, identity.RowVersion);

            switch (updatedRef.Kind)
            {
            case RefKind.Link:
                storedRef.Uri     = updatedRef.Uri;
                storedRef.Title   = updatedRef.Title;
                storedRef.Comment = updatedRef.Comment;
                break;

            case RefKind.Heading:
                storedRef.Title = updatedRef.Title;
                break;

            case RefKind.Text:
                storedRef.Comment = updatedRef.Comment;
                break;
            }

            if (_refsContext.IsModified(storedRef))
            {
                _refsContext.MarkAsModified(storedRef.RefList);
            }
            await _refsContext.SaveChangesAsync();

            SendRefListUpdated(identity.Id);

            identity.RowVersion = storedRef.RefList.RowVersion;
            return(identity);
        }
        public async Task <ILoanOffer> GetAsync(EntityIdentity offerId)
        {
            var request  = CreateGetLoanOfferRequest(offerId);
            var response = await _dynamoDbClient.GetItemAsync(request);

            if (response.HttpStatusCode != HttpStatusCode.OK)
            {
                throw new FailedToGetLoanOfferFromDynamoDbException(response.HttpStatusCode);
            }

            var item = response.Item;

            return(_loanOfferFactory.Create(
                       item[IdDynamoFieldName].S,
                       item[PeselNumberDynamoFieldName].S,
                       item[EmailAddressDynamoFieldName].S,
                       Int32.Parse(item[MaxLoanAmountDynamoFieldName].N)
                       ));
        }
Example #15
0
        private RefColumnMap CreateRefColumnMap(TypeInfo typeInfo, string name)
        {
            SimpleColumnMap entitySetIdColumnMap = (SimpleColumnMap)null;

            if (typeInfo.HasEntitySetIdProperty)
            {
                entitySetIdColumnMap = this.CreateSimpleColumnMap(Helper.GetModelTypeUsage((EdmMember)typeInfo.EntitySetIdProperty), "__EntitySetId");
            }
            EntityType elementType = (EntityType)TypeHelpers.GetEdmType <RefType>(typeInfo.Type).ElementType;

            SimpleColumnMap[] keyColumnMaps = new SimpleColumnMap[elementType.KeyMembers.Count];
            for (int index = 0; index < keyColumnMaps.Length; ++index)
            {
                EdmMember keyMember = elementType.KeyMembers[index];
                keyColumnMaps[index] = this.CreateSimpleColumnMap(Helper.GetModelTypeUsage(keyMember), keyMember.Name);
            }
            EntityIdentity entityIdentity = this.CreateEntityIdentity(elementType, entitySetIdColumnMap, keyColumnMaps);

            return(new RefColumnMap(typeInfo.Type, name, entityIdentity));
        }
Example #16
0
        //public async Task<RefList> CreateUnfiledRefListAsync(long userId)
        //{
        //    var user = await _userHandler.GetUserAsync(userId);
        //    _refsContext.Users.Attach(user);

        //    var refList = new RefList()
        //    {
        //        Kind = RefListKind.Unfiled,
        //        Author = user,
        //        Title = "unfiled",
        //        Comment = "",
        //        PublishingStatus = PublishingStatusKind.Private,
        //        Refs = new Ref[0],
        //        Statistics = null,
        //    };
        //    _refsContext.RefLists.Add(refList);
        //    await _refsContext.SaveChangesAsync();

        //    return refList;
        //}

        public async Task RemoveRefListAsync(EntityIdentity refListIdentity)
        {
            var query         = _refsContext.RefLists.Include("TagUses").Where(l => l.Id == refListIdentity.Id);
            var storedRefList = await query.SingleAsync();

            BusinessContract.ValidateWritePermission(storedRefList.AuthorId);
            BusinessContract.ValidateRowVersion(storedRefList.RowVersion, refListIdentity.RowVersion);

            storedRefList.TagUses.Clear();
            foreach (var fav in storedRefList.FavoringFavorites.ToArray())
            {
                _refsContext.Favorites.Remove(fav);
            }
            _refsContext.RefListStatistics.Remove(storedRefList.Statistics);
            _refsContext.RefLists.Remove(storedRefList);

            await _refsContext.SaveChangesAsync();

            SendRefListUpdated(refListIdentity.Id);
        }
Example #17
0
        public async Task <EntityIdentity> RemoveRefAsync(EntityIdentity refListIdentity, int refIndex)
        {
            var query =
                from l in _refsContext.RefLists.Include("Refs")
                where l.Id == refListIdentity.Id
                select l;

            var storedRefList = await query.SingleOrDefaultAsync();

            BusinessContract.ValidateWritePermission(storedRefList.AuthorId);
            BusinessContract.ValidateRowVersion(storedRefList.RowVersion, refListIdentity.RowVersion);

            var refs     = storedRefList.Refs.OrderBy(r => r.DisplayOrder).ToList();
            var removing = refs[refIndex];

            refs.RemoveAt(refIndex);

            for (int i = 0; i < refs.Count; ++i)
            {
                refs[i].DisplayOrder = i;
            }

            _refsContext.Refs.Remove(removing);

            /// update statistics
            if (removing.Kind == RefKind.Link)
            {
                var statisticsQuery  = _refsContext.RefListStatistics.Where(s => s.RefListId == refListIdentity.Id);
                var storedStatistics = await statisticsQuery.SingleAsync();

                storedStatistics.LinkCount = storedRefList.Refs.Count(r => r.Kind == RefKind.Link);
            }

            _refsContext.MarkAsModified(storedRefList);
            await _refsContext.SaveChangesAsync();

            SendRefListUpdated(refListIdentity.Id);

            refListIdentity.RowVersion = storedRefList.RowVersion;
            return(refListIdentity);
        }
        public void StartNewGame(IGame game, EntityIdentity characterId, ICharacter character)
        {
            var personalAccountName = "Wallet";
            var currencyType        = new LookupItem <long> {
                Key = 1, Value = "GBP"
            };
            var assetType = new LookupItem {
                Key = 1, Value = "Computer"
            };

            "Given I have opened a game".x(async() => game = await this.OpenGame());

            "And I have a created character".x(() => characterId = new EntityIdentity(new StateIdentity(1, Guid.NewGuid().ToString())));

            "When I join the game"
            .x(async() => await this.JoinGameAsPlayer(game, characterId));

            "Then I am notified my character has joined a game"
            .x(() => this.AmNotifiedOfEvent <PlayerHasJoinedGameEvent>());

            "And a new Personal Account has opened called {personalAccountName} with a total funds of 0 creits"
            .x(() => this.AmNotifiedOfEvent <NewPersonalAccountOpenedEvent>((l) => this.AssertNewPersonalAccountOpened(l, personalAccountName, 0, currencyType)));

            "And I am notified of funds into my account of 100 credits"
            .x(() => this.AmNotifiedOfEvent <FundsAddedToAccount>((l) => this.AssertFundsAddedToAccount(l, personalAccountName, 100, currencyType)));

            "And I am notified of Assets received of the type {assetType}"
            .x(() => this.AmNotifiedOfEvent <AssetsReceived>((l) => this.AssertAssetReceived(l, assetType)));

            "And I am notified my current Net Worth has increased to 200C"
            .x(() => this.AmNotifiedOfEvent <NetWorthIncreased>((l) => this.AssertCharactersNetWorth(l, characterId, 200, currencyType)));

            "And I can view my character"
            .x(async() => await this.ICanViewMyCharacter(characterId));

            "And I can view my characters Assets"
            .x(async() => await this.ICanViewMyAssets(character, game.GameType));

            "And I can view my characters accounts"
            .x(async() => await this.ICanViewMyAccount(character));
        }
Example #19
0
        public void WhenTheEntityIsCreated_TheProviderStateIsTheExpectedType()
        {
            var properties = PropertiesAvailableStatusFactory.CreateUIPropertyPropertiesAvailableStatus();

            var runtimeModel = IEntityRuntimeModelFactory.Create();
            var id           = new EntityIdentity(key: "PropertyName", value: "A");
            var cache        = IPropertyPageQueryCacheFactory.Create();
            var property     = new TestProperty
            {
                Name = "A"
            };
            var rule = new Rule();

            rule.BeginInit();
            rule.Properties.Add(property);
            rule.EndInit();

            var result = (UIPropertyValue)UIPropertyDataProducer.CreateUIPropertyValue(runtimeModel, id, cache, property, order: 42, properties);

            Assert.IsType <PropertyProviderState>(((IEntityValueFromProvider)result).ProviderState);
        }
Example #20
0
        public void WhenTheEntityIsCreated_TheProviderStateIsTheExpectedType()
        {
            var properties = PropertiesAvailableStatusFactory.CreateUIPropertyPropertiesAvailableStatus();

            var context  = IQueryExecutionContextFactory.Create();
            var id       = new EntityIdentity(key: "PropertyName", value: "A");
            var cache    = IProjectStateFactory.Create();
            var property = new TestProperty
            {
                Name = "A"
            };
            var rule = new Rule();

            rule.BeginInit();
            rule.Properties.Add(property);
            rule.EndInit();

            var result = (UIPropertyValue)UIPropertyDataProducer.CreateUIPropertyValue(context, id, cache, QueryProjectPropertiesContext.ProjectFile, property, order: 42, requestedProperties: properties);

            Assert.IsType <PropertyProviderState>(((IEntityValueFromProvider)result).ProviderState);
        }
        public async Task WhenThePropertyIsAnIIntProperty_ThenTheEvaluatedValueIsAnInt()
        {
            var properties = PropertiesAvailableStatusFactory.CreateUIPropertyValuePropertiesAvailableStatus(includeEvaluatedValue: true);

            var mockIntProperty = new Mock <IIntProperty>();

            mockIntProperty.Setup(m => m.GetValueAsIntAsync()).ReturnsAsync(42);
            var property = mockIntProperty.Object;

            var entityRuntime = IEntityRuntimeModelFactory.Create();
            var id            = new EntityIdentity(key: "A", value: "B");
            var configuration = ProjectConfigurationFactory.Create(configuration: "Alpha|Beta|Gamma");

            var result = (UIPropertyValueValue)await UIPropertyValueDataProducer.CreateUIPropertyValueValueAsync(
                entityRuntime,
                id,
                configuration,
                property,
                properties);

            Assert.Equal(expected: 42, actual: result.EvaluatedValue);
        }
        private void Append(string prefix, EntityIdentity entityIdentity)
        {
            this.Append(prefix);
            this.Append("[");
            this.Append(",K", (IEnumerable <ColumnMap>)entityIdentity.Keys);
            SimpleEntityIdentity simpleEntityIdentity = entityIdentity as SimpleEntityIdentity;

            if (simpleEntityIdentity != null)
            {
                this.Append(",", simpleEntityIdentity.EntitySet);
            }
            else
            {
                DiscriminatedEntityIdentity discriminatedEntityIdentity = (DiscriminatedEntityIdentity)entityIdentity;
                this.Append("CM", (ColumnMap)discriminatedEntityIdentity.EntitySetColumnMap);
                foreach (EntitySet entitySet in discriminatedEntityIdentity.EntitySetMap)
                {
                    this.Append(",E", entitySet);
                }
            }
            this.Append("]");
        }
Example #23
0
        protected EntityIdentity GetIdByConvention <T>(T entity)
            where T : class
        {
            var entityType = typeof(TEntity);
            var name       = entityType.Name;
            var possibles  = new[] { "id", "key", $"{name}id", $"{name}key", $"{name}_id", $"{name}_key" };
            var properties = entityType.GetProperties();
            var property   = properties.FirstOrDefault(p => possibles.Contains(p.Name.ToLowerInvariant()));

            var identiy = new EntityIdentity
            {
                Name = "Id"
            };

            if (property != null)
            {
                identiy.Name  = property.Name;
                identiy.Value = property.GetValue(entity);
            }

            return(identiy);
        }
        public async Task WhenPropertyIsAnIEvaluatedProperty_GetUnevaluatedValueAsyncIsCalled()
        {
            var properties = PropertiesAvailableStatusFactory.CreateUIPropertyValuePropertiesAvailableStatus(includeUnevaluatedValue: true);

            var mockEvaluatedProperty = new Mock <IEvaluatedProperty>();

            mockEvaluatedProperty.Setup(m => m.GetUnevaluatedValueAsync()).ReturnsAsync("unevaluated value");
            var property = mockEvaluatedProperty.Object;

            var entityRuntime = IEntityRuntimeModelFactory.Create();
            var id            = new EntityIdentity(key: "A", value: "B");
            var configuration = ProjectConfigurationFactory.Create(configuration: "Alpha|Beta|Gamma");

            var result = (UIPropertyValueValue)await UIPropertyValueDataProducer.CreateUIPropertyValueValueAsync(
                entityRuntime,
                id,
                configuration,
                property,
                properties);

            Assert.Equal(expected: "unevaluated value", actual: result.UnevaluatedValue);
            mockEvaluatedProperty.Verify(m => m.GetUnevaluatedValueAsync());
        }
Example #25
0
        protected override Task <IEntityValue?> TryCreateEntityOrNullAsync(IQueryExecutionContext queryExecutionContext, EntityIdentity id)
        {
            if (id.KeysCount == 4 &&
                id.TryGetValue(ProjectModelIdentityKeys.ProjectPath, out string projectPath) &&
                id.TryGetValue(ProjectModelIdentityKeys.PropertyPageName, out string propertyPageName) &&
                id.TryGetValue(ProjectModelIdentityKeys.UIPropertyName, out string propertyName) &&
                id.TryGetValue(ProjectModelIdentityKeys.EditorName, out string editorName))
            {
                return(UIPropertyEditorDataProducer.CreateEditorValueAsync(
                           queryExecutionContext,
                           id,
                           _projectService,
                           projectPath,
                           propertyPageName,
                           propertyName,
                           editorName,
                           _properties));
            }

            return(NullEntityValue);
        }
Example #26
0
 public async Task <Character> Get(EntityIdentity identity)
 {
     return(await this.innerRepository.Get(identity));
 }
Example #27
0
 public async Task <GameType> Get(EntityIdentity identity)
 {
     return(await this.inMemoryEntityRepository.Get(identity));
 }
 public NewMembershipEvent(EntityIdentity membership)
 {
     this.Membership = membership;
 }
Example #29
0
 public LoanOffer(EntityIdentity id, PeselNumber peselNumber, EmailAddress emailAddress, LoanAmount maxLoanAmount) : this(id, peselNumber, emailAddress)
 {
     MaxLoanAmount = maxLoanAmount;
 }
Example #30
0
 public LoanOffer(EntityIdentity id, PeselNumber peselNumber, EmailAddress emailAddress)
 {
     Id           = id;
     PeselNumber  = peselNumber;
     EmailAddress = emailAddress;
 }