public async Task <Response> ValidarAccesos(Credenciales credenciales) { Response response = new Response(); OauthAccess oauth = new OauthAccess(); try { List <DetalleUsuario> list = await _unitOfWork.Security.ValidarAccesos(credenciales); if (list != null) { var secret = _config.GetSection("AppSettings").GetSection("Secret").Value; string token = TokenGenerator.GenerateToken(list[0], secret); oauth.token = token; oauth.UserAccess = list; response.Status = Constant.Status; response.Message = Constant.Ok; response.Data = oauth; } else { response.Status = Constant.Error400; response.Message = Constant.Consult; } } catch (Exception e) { response.Status = Constant.Error500; response.Message = e.Message; } return(response); }
//////////////////////////////////////////////////////////////////////////////////////////////// /*--------------------------------------------------------------------------------------------*/ public static OauthAccess FromCreateFabOauthAccess(CreateFabOauthAccess pApi) { var dom = new OauthAccess(); FromCreateFabOauthAccess(dom, pApi); return(dom); }
/*--------------------------------------------------------------------------------------------*/ private static void FromCreateFabOauthAccess(OauthAccess pDomain, CreateFabOauthAccess pApi) { FromCreateFabVertex(pDomain, pApi); pDomain.Token = pApi.Token; pDomain.Refresh = pApi.Refresh; pDomain.Expires = pApi.Expires; }
//////////////////////////////////////////////////////////////////////////////////////////////// /*--------------------------------------------------------------------------------------------*/ public FabOauthAccess AddAccess(IOperationContext pOpCtx, CreateOauthAccessOperation pCreateOp, long pMemberId, bool pClientMode = false) { ClearOldTokens(pOpCtx, pMemberId); const int expireSec = 3600; bool needsActiveMem = (pOpCtx.Auth.ActiveMemberId == null); CreateFabOauthAccess coa = new CreateFabOauthAccess(); coa.Token = pOpCtx.Code32; coa.Refresh = (pClientMode ? null : pOpCtx.Code32); coa.Expires = pOpCtx.UtcNow.AddSeconds(expireSec).Ticks; coa.AuthenticatesMemberId = pMemberId; if (needsActiveMem) { pOpCtx.Auth.SetFabricActiveMember(); } OauthAccess result = pCreateOp.Execute(pOpCtx, new CreateOperationBuilder(), new CreateOperationTasks(), coa); if (needsActiveMem) { pOpCtx.Auth.RemoveFabricActiveMember(); } return(new FabOauthAccess { AccessToken = result.Token, RefreshToken = result.Refresh, ExpiresIn = expireSec, TokenType = "bearer" }); }
//////////////////////////////////////////////////////////////////////////////////////////////// /*--------------------------------------------------------------------------------------------*/ public FabOauthLogout Execute(IOperationContext pOpCtx, IOauthLogoutTasks pTasks, string pToken) { OauthAccess oa = pTasks.GetAccessToken(pOpCtx.Data, pToken); pTasks.DoLogout(pOpCtx, oa); return(new FabOauthLogout { Success = 1, AccessToken = pToken }); }
public string SendOauthRequest() { string token = ""; AuthenticationApi authApi = new AuthenticationApi("https://account-d.docusign.com"); OauthAccess oAuth = authApi.GetOAuthToken(); token = oAuth.AccessToken; return(token); }
/*--------------------------------------------------------------------------------------------*/ public virtual void AddOauthAccessAuthenticatesMember(ICreateOperationBuilder pCreCtx, OauthAccess pNewDom, CreateFabOauthAccess pNewCre, IWeaverVarAlias <OauthAccess> pAlias) { var a = AddEdge <OauthAccess, OauthAccessAuthenticatesMember, Member>( pCreCtx, pAlias, pNewCre.AuthenticatesMemberId); var maboaEdge = new MemberAuthenticatedByOauthAccess(); maboaEdge.Timestamp = pNewDom.Timestamp; AddReverseEdge(pCreCtx, a, maboaEdge, pAlias); }
/*--------------------------------------------------------------------------------------------*/ public void DoLogout(IOperationContext pOpCtx, OauthAccess pAccess) { try { //OPTIMIZE: don't make a query to get Member (ClearOldTokens does the reverse) IWeaverQuery q = Weave.Inst.Graph .V.ExactIndex <OauthAccess>(x => x.VertexId, pAccess.VertexId) .AuthenticatesMember.ToMember .ToQuery(); Member m = pOpCtx.Data.Get <Member>(q, "OauthLogout-GetMember"); OauthAccessTasks.ClearOldTokens(pOpCtx, m.VertexId); } catch (Exception) { throw NewFault(LogoutErrors.logout_failure, LogoutErrorDescs.LogoutFailed); } }
public void Success() { var oa = new OauthAccess(); vMockTasks .Setup(x => x.GetAccessToken(vMockData.Object, vToken)) .Returns(oa); vMockTasks .Setup(x => x.DoLogout(vMockOpCtx.Object, oa)); DoExecute(); Assert.NotNull(vExecuteResult, "Result should be filled."); Assert.AreEqual(vToken, vExecuteResult.AccessToken, "Incorrect AccessToken."); Assert.AreEqual(1, vExecuteResult.Success, "Incorrect Success."); }
/*--------------------------------------------------------------------------------------------*/ private void AddAccess(OauthAccessId pId, SetupMemberId pMemId, string pToken, int pMins, string pRefresh = null) { var oa = new OauthAccess(); oa.Expires = new DateTime(Data.NowTimestamp).AddMinutes(pMins).Ticks; oa.Token = pToken; oa.Refresh = (pRefresh ?? DataUtil.Code32); AddVertex(oa, (SetupVertexId)(long)pId); Member mem = Data.GetVertex <Member>((long)pMemId); var mao = new MemberAuthenticatedByOauthAccess(); mao.Timestamp = oa.Timestamp; AddEdge(oa, new OauthAccessAuthenticatesMember(), mem); AddEdge(mem, mao, oa); }
//////////////////////////////////////////////////////////////////////////////////////////////// /*--------------------------------------------------------------------------------------------*/ public OauthAccess GetAccessToken(IOperationData pData, string pToken) { if (pToken == null || pToken.Length != 32) { throw NewFault(LogoutErrors.invalid_request, LogoutErrorDescs.BadToken); } IWeaverQuery q = Weave.Inst.Graph .V.ExactIndex <OauthAccess>(x => x.Token, pToken) .ToQuery(); OauthAccess oa = pData.Get <OauthAccess>(q, "OauthLogout-GetAccessToken"); if (oa == null) { throw NewFault(LogoutErrors.invalid_request, LogoutErrorDescs.NoTokenMatch); } return(oa); }
public void GetAccessTokenSuccess() { const string token = "12345678901234567890123456789012"; var oa = new OauthAccess(); const string expectScript = "g.V('" + DbName.Vert.OauthAccess.Token + "',_P);"; var expectParams = new List <object> { token }; vMockData .Setup(x => x.Get <OauthAccess>(It.IsAny <IWeaverQuery>(), "OauthLogout-GetAccessToken")) .Callback((IWeaverScript q, string n) => TestUtil.CheckWeaverScript(q, expectScript, "_P", expectParams)) .Returns(oa); OauthAccess result = vTasks.GetAccessToken(vMockData.Object, token); Assert.AreEqual(oa, result, "Incorrect result."); }
public void DoLogoutSuccess() { var oa = new OauthAccess { VertexId = 12352532 }; var mem = new Member { VertexId = 98736455 }; const string expectScript = "g.V('" + DbName.Vert.Vertex.VertexId + "',_P)" + ".outE('" + DbName.Edge.OauthAccessAuthenticatesMemberName + "').inV;"; var expectParams = new List <object> { oa.VertexId }; vMockData .Setup(x => x.Get <Member>(It.IsAny <IWeaverQuery>(), "OauthLogout-GetMember")) .Callback((IWeaverScript q, string n) => TestUtil.CheckWeaverScript(q, expectScript, "_P", expectParams)) .Returns(mem); vMockData .Setup(x => x.Execute(It.IsAny <IWeaverQuery>(), "OauthAccess-ClearOldTokens")) .Returns((IDataResult)null); var mockMemCache = new Mock <IMemCache>(MockBehavior.Strict); mockMemCache.Setup(x => x.RemoveOauthMembers(mem.VertexId)); var mockCacheMan = new Mock <ICacheManager>(MockBehavior.Strict); mockCacheMan.SetupGet(x => x.Memory).Returns(mockMemCache.Object); vMockOpCtx.SetupGet(x => x.Cache).Returns(mockCacheMan.Object); vTasks.DoLogout(vMockOpCtx.Object, oa); mockMemCache.Verify(x => x.RemoveOauthMembers(mem.VertexId), Times.Once); }
public void AddOauthAccessAuthenticatesMember() { var dom = new OauthAccess { Timestamp = 9439439349 }; var cre = new CreateFabOauthAccess { AuthenticatesMemberId = 7272727 }; TestAddEdge( x => vTasks.AddOauthAccessAuthenticatesMember( x, dom, cre, GetAddVertexAlias <OauthAccess>()), cre.AuthenticatesMemberId, DbName.Edge.OauthAccessAuthenticatesMemberName, DbName.Edge.MemberAuthenticatedByOauthAccessName, new[] { DbName.Edge.MemberAuthenticatedByOauthAccess.Timestamp }, new object[] { dom.Timestamp } ); }
public void AddAccess(bool pClientMode, bool pHasActiveMem) { const long memId = 763462332; const string code0 = "12351252sadfasdf"; const string code1 = "362343fsdfsdfasd"; const long utcNowTicks = 6423156122345252; const long utcExpireTicks = utcNowTicks + 3600 * TimeSpan.TicksPerSecond; var mockAuth = new Mock <IOperationAuth>(MockBehavior.Strict); mockAuth.SetupGet(x => x.ActiveMemberId).Returns(pHasActiveMem ? 1234 : (long?)null); if (!pHasActiveMem) { mockAuth.Setup(x => x.SetFabricActiveMember()); mockAuth.Setup(x => x.RemoveFabricActiveMember()); } vMockOpCtx.SetupGet(x => x.Auth).Returns(mockAuth.Object); var codeQueue = new Queue <string>(); codeQueue.Enqueue(code0); codeQueue.Enqueue(code1); var oa = new OauthAccess(); oa.Token = "6512361236134fvaslkdjfds"; oa.Refresh = "94856928345ksdljlsdkfuasd"; vMockData .Setup(x => x.Execute(It.IsAny <IWeaverQuery>(), "OauthAccess-ClearOldTokens")) .Returns((IDataResult)null); vMockData .Setup(x => x.Build(null, true, true)) .Returns(new DataAccess()); vMockOpCtx .SetupGet(x => x.Code32) .Returns(codeQueue.Dequeue); vMockOpCtx .SetupGet(x => x.UtcNow) .Returns(new DateTime(utcNowTicks)); var mockMemCache = new Mock <IMemCache>(MockBehavior.Strict); mockMemCache.Setup(x => x.RemoveOauthMembers(memId)); var mockCacheMan = new Mock <ICacheManager>(MockBehavior.Strict); mockCacheMan.SetupGet(x => x.Memory).Returns(mockMemCache.Object); vMockOpCtx.SetupGet(x => x.Cache).Returns(mockCacheMan.Object); var mockCreOp = new Mock <CreateOauthAccessOperation>(MockBehavior.Strict); mockCreOp .Setup(x => x.Execute(vMockOpCtx.Object, It.IsAny <ICreateOperationBuilder>(), It.IsAny <CreateOperationTasks>(), It.IsAny <CreateFabOauthAccess>())) .Callback((IOperationContext opCtx, ICreateOperationBuilder build, CreateOperationTasks tasks, CreateFabOauthAccess cre) => { Assert.NotNull(cre, "Create should be filled."); Assert.AreEqual(code0, cre.Token, "Incorrect Create.Token."); Assert.AreEqual((pClientMode ? null : code1), cre.Refresh, "Incorrect Create.Refresh."); Assert.AreEqual(utcExpireTicks, cre.Expires, "Incorrect Create.Expires."); Assert.AreEqual(memId, cre.AuthenticatesMemberId, "Incorrect Create.AuthenticatesMemberId."); }) .Returns(oa); FabOauthAccess result = vTasks.AddAccess( vMockOpCtx.Object, mockCreOp.Object, memId, pClientMode); Assert.NotNull(result, "Result should be filled."); Assert.AreEqual(oa.Token, result.AccessToken, "Incorrect AccessToken."); Assert.AreEqual(oa.Refresh, result.RefreshToken, "Incorrect RefreshToken."); Assert.AreEqual(3600, result.ExpiresIn, "Incorrect ExpiresIn."); Assert.AreEqual("bearer", result.TokenType, "Incorrect TokenType."); var times = (pHasActiveMem ? Times.Never() : Times.Once()); mockAuth.Verify(x => x.SetFabricActiveMember(), times); mockAuth.Verify(x => x.RemoveFabricActiveMember(), times); mockMemCache.Verify(x => x.RemoveOauthMembers(memId), Times.Once); }
/*--------------------------------------------------------------------------------------------*/ public virtual void AddOauthAccess(ICreateOperationBuilder pCreCtx, OauthAccess pNewDom, out IWeaverVarAlias <OauthAccess> pAlias) { AddVertex(pCreCtx, pNewDom, out pAlias); }