Esempio n. 1
0
        public void StartTenantCollection()
        {
            var id      = Guid.NewGuid();
            var id2     = Guid.NewGuid();
            var tenant1 = new TenantDefault(id, "Tenant 1");
            var tenant2 = new TenantDefault(id, "Tenant 2");
            var tenant3 = new TenantDefault(id2, "Tenant 3");

            var secrets2 = new Dictionary <string, string>()
            {
                { "Secret2", "Value 1" }
            };
            var tenantSecret2 = new TenantSecret <Guid, dynamic>(id2, secrets: secrets2);

            var claims = new Dictionary <string, string>()
            {
                { "Claims1", "Value 1" }
            };
            var tenantClaims = new TenantClaims <Guid, dynamic>(id, claims: claims);

            var collection = new TenantCollection(new[] { tenant1, tenant2, tenant3 });

            Assert.AreEqual(2, collection.Count);
            var itens       = new ITenant <Guid>[] { tenant1, tenant2, tenant3, tenantClaims, _secretFirstTenant, tenantSecret2, null };
            var collection2 = new TenantCollection();

            collection2.Add(itens);
            Assert.AreEqual(3, collection2.Count);

            Assert.ThrowsException <ArgumentNullException>(() => collection2.Add((IEnumerable <ITenant <Guid> >)null));
        }
Esempio n. 2
0
        public void CheckIfTenantClaimsWithDistinctTypeAreEquals()
        {
            var defaultId     = 19;
            var tenantSecret1 = new TenantClaims <int, DateTime>(defaultId, DateTime.Today);
            var tenantSecret3 = new TenantClaims <int, int>(defaultId, 100);

            Assert.IsFalse(tenantSecret1.Equals(tenantSecret3), "O secret de outro tipo não deve ser considerado iguais mesmo que tenha o mesmo id");
        }
Esempio n. 3
0
        public void TenantClaimsComparerWithKey()
        {
            var defaultId     = 19;
            var tenantSecret1 = new TenantClaims <int, DateTime>(defaultId, DateTime.Today);
            var tenantSecret2 = new TenantClaims <int, DateTime>(defaultId, DateTime.Now);

            Assert.IsTrue(tenantSecret1.Equals(tenantSecret2), "The tenant claims not is equals by ID");

            Assert.IsFalse(tenantSecret1.Equals("Not is valid type"), "Somente ITenantSecret e ITenant podem ser iguais");
            Assert.AreEqual(defaultId.GetHashCode(), tenantSecret1.GetHashCode(), "O Tenant não está retornando o hascode do tipo do secret");
        }
Esempio n. 4
0
        public void Initialize()
        {
            _firstTenantId  = Guid.NewGuid();
            _secondTenantId = Guid.NewGuid();
            var dicSecretFirst = new Dictionary <string, object>()
            {
                { "Secret1", "Value 1" }
            };
            var dicSecretSecond = new Dictionary <string, object>()
            {
                { "Secret2", "Value 2" }
            };
            var dicClaimsFirst = new Dictionary <string, object>()
            {
                { "Claims1", "Value 1" }
            };

            _secretFirstTenant = new TenantSecret <Guid, Dictionary <string, object> >(_firstTenantId, secrets: dicSecretFirst);
            _claimsFirstTenant = new TenantClaims <Guid, Dictionary <string, object> >(_firstTenantId, claims: dicClaimsFirst);

            _secretSecondTenant = new TenantSecret <Guid, Dictionary <string, object> >(_secondTenantId, secrets: dicSecretSecond);
        }
Esempio n. 5
0
        public async Task <IActionResult> SaveClaim(ClaimsViewModel model)
        {
            string responseCode    = string.Empty;
            string responseMessage = string.Empty;

            try
            {
                if (model.ID != Guid.Empty)
                {
                    //Update
                    var getclaimbyid = await _context.TenantClaims.SingleOrDefaultAsync(d => d.ID == model.ID && d.TenantID == model.TenantID);

                    if (model.Name != getclaimbyid.ClaimName)
                    {
                        if (await _context.TenantClaims.AnyAsync(x => x.ClaimName == model.Name))
                        {
                            responseCode    = "Exists";
                            responseMessage = string.Format(AccountOptions.API_Response_Exist, "Claim");
                        }
                        else
                        {
                            getclaimbyid.ClaimName   = model.Name;
                            getclaimbyid.IsAvailable = true;
                            await _context.SaveChangesAsync();

                            responseCode    = "Success";
                            responseMessage = string.Format(AccountOptions.API_Response_Saved, "Claim");
                        }
                    }
                }
                else
                {
                    //Add
                    if (!await _context.TenantClaims.AnyAsync(x => x.ClaimName == model.Name))
                    {
                        //Doesnot exist     //Add new
                        var claim = new TenantClaims();
                        claim.ClaimName   = model.Name;
                        claim.TenantID    = model.TenantID;
                        claim.IsAvailable = true;
                        await _context.TenantClaims.AddAsync(claim);

                        await _context.SaveChangesAsync();

                        responseCode    = "Success";
                        responseMessage = string.Format(AccountOptions.API_Response_Saved, "Claim");
                    }
                    else
                    {
                        responseCode    = "Exists";
                        responseMessage = string.Format(AccountOptions.API_Response_Exist, "Claim");
                    }
                }
            }
            catch (Exception ex)
            {
                responseCode    = "Error";
                responseMessage = string.Format(AccountOptions.API_Response_Failed, ex.Message);
            }

            return(Ok(new
            {
                MessageCode = responseCode,
                MessageDetails = responseMessage
            }));
        }