public void NormalizedKeyDefaultsToKey()
        {
            var key = "key";
            var rec = new ApplicationUserRecord("provider", "key", "userId");

            Assert.AreEqual(key, rec.NormalizedKey);
        }
        public void SettingDifferentAttributeDoesMakeDirty()
        {
            var provider              = "someProvider";
            var key                   = "someKey";
            var normalizedKey         = "someKey normalized";
            var userId                = "someUserId";
            var lastUpdated           = DateTime.UtcNow;
            var boolAttribute         = "someFalseAttribute";
            var stringAttribute       = "someStringAttribute";
            var stringAttributeValue  = "some value for string attribute";
            var applicationUserRecord = new ApplicationUserRecord(
                provider,
                key,
                userId,
                normalizedKey,
                lastUpdated,
                new Dictionary <string, string> {
                { stringAttribute, stringAttributeValue }
            },
                new Dictionary <string, bool> {
                { boolAttribute, false }
            }
                );

            Assert.IsFalse(applicationUserRecord.IsDirty);

            applicationUserRecord.SetStringAttribute(stringAttribute, stringAttributeValue + "x");
            Assert.IsTrue(applicationUserRecord.IsDirty);
        }
        public void CanCreateCleanVersionOfApplicationUserRecord()
        {
            var provider             = "someProvider";
            var key                  = "someKey";
            var normalizedKey        = "someKey normalized";
            var userId               = "someUserId";
            var boolAttribute        = "someFalseAttribute";
            var stringAttribute      = "someStringAttribute";
            var stringAttributeValue = "some value for string attribute";

            var applicationUserRecord = new ApplicationUserRecord(provider, key, userId);

            applicationUserRecord.NormalizedKey = normalizedKey;
            applicationUserRecord.SetBoolAttribute(boolAttribute, false);
            applicationUserRecord.SetStringAttribute(stringAttribute, stringAttributeValue);
            Assert.IsTrue(applicationUserRecord.IsDirty);

            var lastUpdated = DateTime.UtcNow;
            var cleanApplicationUserRecord = ApplicationUserRecord.CreateCleanRecord(applicationUserRecord, lastUpdated);

            Assert.IsFalse(cleanApplicationUserRecord.IsDirty);
            Assert.AreEqual(lastUpdated, cleanApplicationUserRecord.LastUpdated);
            Assert.AreEqual(applicationUserRecord.Provider, cleanApplicationUserRecord.Provider);
            Assert.AreEqual(applicationUserRecord.Key, cleanApplicationUserRecord.Key);
            Assert.AreEqual(applicationUserRecord.NormalizedKey, cleanApplicationUserRecord.NormalizedKey);
            Assert.AreEqual(applicationUserRecord.BoolAttributes[boolAttribute], cleanApplicationUserRecord.BoolAttributes[boolAttribute]);
            Assert.AreEqual(applicationUserRecord.StringAttributes[stringAttribute], cleanApplicationUserRecord.StringAttributes[stringAttribute]);
        }
        public async Task <ApplicationUserRecord> DeleteAsync(ApplicationUserRecord applicationUserRecord, CancellationToken cancellationToken = default)
        {
            var document = FromApplicationUserRecord(applicationUserRecord);

            _ = await _table.DeleteItemAsync(document, cancellationToken);

            return(ToApplicationUserRecord(document.ToAttributeMap()));
        }
        public void LastUpdated()
        {
            var userId      = "someUserId";
            var email       = "someEmail@local";
            var lastUpdated = DateTime.UtcNow;
            var idRecord    = new ApplicationUserRecord(ApplicationUserRecord.RECORD_TYPE_ID, userId, userId, userId, lastUpdated.AddDays(-1));
            var emailRecord = new ApplicationUserRecord(ApplicationUserRecord.RECORD_TYPE_EMAILPROVIDER, email, userId, email, lastUpdated);
            var user        = new ApplicationUser(new[] { idRecord, emailRecord });

            Assert.IsFalse(idRecord.IsDirty);
            Assert.AreEqual(lastUpdated, user.LastUpdated);
        }
        public void ModifiedObjectDirty()
        {
            var userId      = "someUserId";
            var lastUpdated = DateTime.UtcNow;
            var idRecord    = new ApplicationUserRecord(ApplicationUserRecord.RECORD_TYPE_ID, userId, userId, userId, lastUpdated);
            var user        = new ApplicationUser(new[] { idRecord });

            user.IsAdministrator = true;

            Assert.IsTrue(user.IsAdministrator);
            Assert.IsTrue(idRecord.IsDirty);
        }
        public void CanCreateFromRecords()
        {
            var userId  = "someUserId";
            var records = new ApplicationUserRecord[]
            {
                new ApplicationUserRecord("provider1", "key1", userId),
                new ApplicationUserRecord("provider2", "key2", userId),
                new ApplicationUserRecord(ApplicationUserRecord.RECORD_TYPE_ID, userId, userId)
            };
            var user = new ApplicationUser(records);

            Assert.AreEqual(userId, user.UserId);
        }
        public void LoadedObjectNotDirty()
        {
            var userId           = "someUserId";
            var lastUpdated      = DateTime.UtcNow;
            var stringAttributes = new Dictionary <string, string>();
            var boolAttributes   = new Dictionary <string, bool>();

            boolAttributes[ApplicationUser.FIELD_ISADMINISTRATOR] = true;
            var idRecord = new ApplicationUserRecord(ApplicationUserRecord.RECORD_TYPE_ID, userId, userId, userId, lastUpdated, stringAttributes, boolAttributes);
            var user     = new ApplicationUser(new[] { idRecord });

            Assert.IsTrue(user.IsAdministrator);
            Assert.IsFalse(idRecord.IsDirty);
        }
        public void CannotReadLastUpdatedForDirtyUser()
        {
            var userId      = "someUserId";
            var lastUpdated = DateTime.UtcNow;
            var idRecord    = new ApplicationUserRecord(ApplicationUserRecord.RECORD_TYPE_ID, userId, userId, userId, lastUpdated);
            var user        = new ApplicationUser(new[] { idRecord });

            user.IsAdministrator = true;

            Assert.IsTrue(idRecord.IsDirty);
            Assert.Throws(Is.TypeOf <InvalidOperationException>(),
                          delegate
            {
                var d = user.LastUpdated;
            }
                          );
        }
        private static Document FromApplicationUserRecord(ApplicationUserRecord userRecord)
        {
            var document = new Document
            {
                [PROVIDER]       = userRecord.Provider,
                [KEY]            = userRecord.Key,
                [NORMALIZED_KEY] = userRecord.NormalizedKey,
                [USER_ID]        = userRecord.UserId,
                [LAST_UPDATED]   = DateTime.UtcNow.ToString("O")
            };

            foreach (var attr in userRecord.StringAttributes.Keys)
            {
                document[attr] = userRecord.StringAttributes[attr];
            }
            foreach (var attr in userRecord.BoolAttributes.Keys)
            {
                document[attr] = new DynamoDBBool(userRecord.BoolAttributes[attr]);
            }
            return(document);
        }
        private ApplicationUserRecord ToApplicationUserRecord(Dictionary <string, AttributeValue> attributeMap)
        {
            string provider      = string.Empty;
            string key           = string.Empty;
            string normalizedKey = string.Empty;
            string userId        = string.Empty;
            Dictionary <string, string> stringAttributes = new Dictionary <string, string>();
            Dictionary <string, bool>   boolAttributes   = new Dictionary <string, bool>();
            DateTime lastUpdated = DateTime.MinValue;

            foreach (var attr in attributeMap.Keys)
            {
                _logger.LogDebug("Reading {0}", attr);
                switch (attr)
                {
                case PROVIDER:
                    provider = attributeMap[attr].S;
                    break;

                case KEY:
                    key = attributeMap[attr].S;
                    break;

                case NORMALIZED_KEY:
                    normalizedKey = attributeMap[attr].S;
                    break;

                case USER_ID:
                    userId = attributeMap[attr].S;
                    break;

                case LAST_UPDATED:
                    DateTime.TryParse(attributeMap[attr].S, out lastUpdated);
                    break;

                default:
                    if (attributeMap[attr].IsBOOLSet)
                    {
                        boolAttributes[attr] = attributeMap[attr].BOOL;
                    }
                    else if (attributeMap[attr].S != null)
                    {
                        stringAttributes[attr] = attributeMap[attr].S;
                    }
                    break;
                }
            }

            _logger.LogDebug("Creating ApplicationUserRecord: provider={0} key={1} userId={2} normalizedKey={3} lastUpdated={4}", provider, key, userId, normalizedKey, lastUpdated);

            var record = new ApplicationUserRecord(
                provider,
                key,
                userId,
                normalizedKey,
                lastUpdated,
                stringAttributes,
                boolAttributes
                );

            return(record);
        }