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