public Task TheDefaultDefaultShouldBe404()
{
var builder = new AppBuilder();
var app = builder.Build();
var helper = new OwinHelper();
return(app(helper.Env).Then(() => helper.ResponseStatusCode.ShouldBe(404)));
}
public async Task <NotificationResult> DeleteUser()
{
var user = OwinHelper.CreateUser(User.Identity as ClaimsIdentity);
await this.UserProvider.DeleteUserWithDependenciesAsync(user);
this.EmailProvider.SendDeleteConfirmationAsync(user);
return(new NotificationResult(user.Email));
}
public static IdentityUser GetCurrentIdentityUser()
{
if (!OwinHelper.GetOwinContext(HttpContext.Current).Request.User.Identity.IsAuthenticated)
{
return(null);
}
var manager = GetUserManager();
return(manager.FindById(OwinHelper.GetOwinContext(HttpContext.Current).Request.User.Identity.Name));
}
public static IEnumerable <string> CreateAndLoginUser(string username, string email, string name, string userClass = null)
{
var loginInfo = OwinHelper.GetOwinContext(HttpContext.Current).Authentication.GetExternalLoginInfo();
if (loginInfo == null)
{
//RedirectOnFail(HttpContext.Current.Response);
return(new[] { "No External Login information found." });
}
return(CreateAndLoginUser(username, email, name, loginInfo.ExternalIdentity.Claims, loginInfo, userClass));
}
public override async Task GrantResourceOwnerCredentials(OAuthGrantResourceOwnerCredentialsContext context)
{
User user = await this.UserProvider.FindAsync(context.UserName, context.Password);
if (user == null)
{
context.SetError("invalid_grant", Exceptions.InvalidGrant);
return;
}
OwinHelper.SingIn(context, user);
}
public async Task <IHttpActionResult> GetExternalLogin(string provider, string error = null)
{
if (error != null)
{
return(Redirect(Url.Content("~/") + "#error=" + Uri.EscapeDataString(error)));
}
ExternalLoginProvider loginProvider;
if (!Enum.TryParse <ExternalLoginProvider>(provider, ignoreCase: true, result: out loginProvider) ||
loginProvider == ExternalLoginProvider.None)
{
//Unsupported login provider
return(InternalServerError());
}
if (!User.Identity.IsAuthenticated)
{
return(new ChallengeResult(loginProvider, this));
}
ExternalLoginModel externalLogin = ExternalLoginModel.FromIdentity(User.Identity as ClaimsIdentity);
if (externalLogin == null)
{
return(InternalServerError());
}
if (externalLogin.Provider != loginProvider)
{
Request.GetOwinContext().Authentication.SignOut(
DefaultAuthenticationTypes.ExternalCookie,
OAuthDefaults.AuthenticationType,
CookieAuthenticationDefaults.AuthenticationType);
return(new ChallengeResult(loginProvider, this));
}
User user = await this.UserProvider.FindAsync(externalLogin.Provider, externalLogin.ProviderKey);
if (user != null)
{
OwinHelper.SingIn(Request.GetOwinContext(), user, externalLogin);
}
else
{
OwinHelper.SingIn(Request.GetOwinContext(), externalLogin);
}
return(Ok());
}
public Task Invoke(IDictionary<string, object> env)
{
var helper = new OwinHelper(env);
if (helper.RequestPath.StartsWith(_arg1, StringComparison.OrdinalIgnoreCase))
{
helper.ResponseHeaders["Content-Type"] = new[] { "text/plain" };
using (var writer = new StreamWriter(helper.OutputStream))
{
writer.Write(_arg2);
}
return TaskHelpers.Completed();
}
// to pass along the request, call the next app
return _app(env);
}
public Task Invoke(IDictionary <string, object> env)
{
var helper = new OwinHelper(env);
if (helper.RequestPath.StartsWith(_arg1, StringComparison.OrdinalIgnoreCase))
{
helper.ResponseHeaders["Content-Type"] = new[] { "text/plain" };
using (var writer = new StreamWriter(helper.OutputStream))
{
writer.Write(_arg2);
}
return(TaskHelpers.Completed());
}
// to pass along the request, call the next app
return(_app(env));
}
/// <summary>
/// Extracts user info from identity
/// </summary>
/// <param name="identity"></param>
/// <returns></returns>
public User TryGetRegisteredUserFromIdentity(ClaimsIdentity claimsIdentity)
{
if (claimsIdentity == null || !claimsIdentity.IsAuthenticated)
{
return(null);
}
//if issued by external => user is not registered, return null
Claim userIdClaim = claimsIdentity.FindFirst(ClaimTypes.NameIdentifier);
if (userIdClaim.Issuer != ClaimsIdentity.DefaultIssuer)
{
return(null);
}
return(OwinHelper.CreateUser(claimsIdentity));
}
public async Task <RegistrationResult> RegisterExternal()
{
ExternalLoginModel externalLogin = ExternalLoginModel.FromIdentity(User.Identity as ClaimsIdentity);
if (externalLogin == null)
{
throw new ApiException(Exceptions.ExternalLoginNotFound);
}
var user = await this.UserProvider.CreateExternalAsync(externalLogin);
var userViewModel = UserProvider.MapUserToViewModel(user, externalLogin);
OwinHelper.SingIn(Request.GetOwinContext(), user, externalLogin);
var token = OwinHelper.CreateToken(Request.GetOwinContext(), user, externalLogin);
return(new RegistrationResult(userViewModel, token));
}
public static Func <AppFunc, AppFunc> Invoke(string arg1, string arg2)
{
return(app => env =>
{
var helper = new OwinHelper(env);
if (helper.RequestPath.StartsWith(arg1, StringComparison.OrdinalIgnoreCase))
{
helper.ResponseHeaders["Content-Type"] = new[] { "text/plain" };
using (var writer = new StreamWriter(helper.OutputStream))
{
writer.Write(arg2);
}
return TaskHelpers.Completed();
}
// to pass along the request, call the next app
return app(env);
});
}
public static bool IsAuthenticatedInMode(Type authType)
{
var identity = OwinHelper.GetOwinContext(HttpContext.Current).Request?.User?.Identity;
return
(
(
(identity != null)
&&
(identity.IsAuthenticated)
)
&&
(
(authType == null)
||
(identity.GetType() == authType)
)
);
}
public static AppFunc Middleware(AppFunc app, string arg1, string arg2)
{
return env =>
{
var helper = new OwinHelper(env);
if (helper.RequestPath.StartsWith(arg1, StringComparison.OrdinalIgnoreCase))
{
helper.ResponseHeaders["Content-Type"] = new[] { "text/plain" };
using (var writer = new StreamWriter(helper.OutputStream))
{
writer.Write(arg2);
}
return TaskHelpers.Completed();
}
// to pass along the request, call the next app
return app(env);
};
}
protected override void OnStart(string[] args)
{
try
{
Quartz.Core.IOC.ObjectContainer.ApplicationStart(new Quartz.Core.IOC.AutoFacContainer());
if (this.pcScheduler == null)
{
pcScheduler = Scheduler.Create();
}
pcScheduler.Start();
owinHelper = OwinHelper.Create(SysConfig <ProjectInstaller> .OwinPort);
owinHelper.Start();
}
catch (Exception ex)
{
Log4.Error(ex.Message);
Log4.Error(ex.StackTrace);
}
}
public void Start()
{
List <HttpRoute> routes = new List <HttpRoute>();
routes.Add(new HttpRoute()
{
RouteTemplate = @"{controller}/{action}/{id}"
});
owin = new OwinHelper(@"https://127.0.0.1:11508", new OwinStart()
{
IsOpenSignalR = true,
IsCorss = true,
FileServerOptions = null,
Routes = routes,
ResultToJson = true,
IsOpenWebApi = true
});
owin.Start();
Console.WriteLine("CameraHttpServer已启动!");
}
static void Main(string[] args)
{
ObjectContainer.ApplicationStart(new Quartz.Core.IOC.AutoFacContainer());
//ITest _ITest = ObjectContainer.Current.Resolve<ITest>();
//_ITest.SayHello();
//Console.ReadLine();
var pcScheduler = Scheduler.Create();
pcScheduler.Start();
OwinHelper owinHelper = OwinHelper.Create("8099");
owinHelper.Start();
Console.ReadLine();
//Quartz.Core.Log4net.Log4.Info("test.......");
//Console.ReadLine();
}
public static bool CheckAccess(string resourceType, string resource, string action, string userName)
{
var resourceAction = new ResourceAction(resourceType, resource, ClaimTypes.ActionType, action);
var user = IdentityHelper.GetIdentityUserByName(userName);
var manager = IdentityHelper.GetUserManager();
ClaimsIdentity userIdentity = null;
if (user == null)
{
log4net.LogManager.GetLogger(nameof(ClaimPermission)).Warn($"A user with username '{userName}' was not found by user manager. Creating Claims Identity from Owin Context Request User.Identity ...");
userIdentity = (OwinHelper.GetOwinContext(HttpContext.Current).Request.User.Identity as ClaimsIdentity);
}
else
{
userIdentity = user.GenerateUserIdentityAsync(manager).Result;
}
var context = CreateAuthorizationContext(ClaimsPrincipal.Current, resourceAction);
var claimsAuthorizationManager =
FederatedAuthentication.FederationConfiguration.IdentityConfiguration.ClaimsAuthorizationManager as AuthorizationManager;
return(claimsAuthorizationManager.CheckAccess(context, userIdentity));
}
static void Start()
{
Log4.Info("开始启动作业...");
ObjectContainer.ApplicationStart(new Quartz.Core.IOC.AutoFacContainer());
ITest _ITest = ObjectContainer.Current.Resolve <ITest>();
_ITest.SayHello(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff") + "端口8099正在启动...");
var pcScheduler = Scheduler.Create();
//pcScheduler.Start();
OwinHelper owinHelper = OwinHelper.Create("8099");
owinHelper.Start();
_ITest.SayHello(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff") + "端口8099启动成功！");
Console.ReadLine();
//Log4.Info(string.Format("【{0}】开始执行IJOB的[Execute]...","dddd"));
//Console.ReadLine();
}
public static string GetCurrentUserName()
{
return(OwinHelper.GetOwinContext(HttpContext.Current).Request.User.Identity.Name);
}
public static bool ValidateExternalLoginAndLogin(out ApplicationUser appUser, out IEnumerable <string> errors)
{
errors = new List <string>();
appUser = null;
// Get external login info
var manager = GetUserManager();
var loginInfo = OwinHelper.GetOwinContext(HttpContext.Current).Authentication.GetExternalLoginInfo();
if (loginInfo == null)
{
//RedirectOnFail(HttpContext.Current.Response);
errors = new[] { "No External Login information found." };
return(false);
}
// Find local user associated with the external login
var user = manager.Find(loginInfo.Login);
if (user != null)
{
// If local user exists -> Login
SignIn(loginInfo, isPersistent: false);
appUser = user.User;
return(true);
//IdentityHelper.RedirectToReturnUrl(HttpContext.Current.Request.QueryString["ReturnUrl"], HttpContext.Current.Response);
}
if (HttpContext.Current.User.Identity.IsAuthenticated)
{
// If the external login is not associated with the currently logged in User -> associate
// Apply Xsrf check when linking
loginInfo = OwinHelper.GetOwinContext(HttpContext.Current).Authentication.GetExternalLoginInfo(XsrfKey, HttpContext.Current.User.Identity.GetUserId());
if (loginInfo == null)
{
errors = new[] { "No External Login information found." };
return(false);
}
var id = HttpContext.Current.User.Identity.GetUserId();
var addLoginResult = manager.AddLogin(id, loginInfo.Login);
if (addLoginResult.Succeeded)
{
// If successfully associated the user with the external login -> redirect to ReturnUrl
//IdentityHelper.RedirectToReturnUrl(HttpContext.Current.Request.QueryString["ReturnUrl"], HttpContext.Current.Response);
appUser = manager.Find(loginInfo.Login).User;
return(true);
}
// Failure to associate -> Return any Errors (result is already populated)
errors = addLoginResult.Errors;
return(false);
}
// If not local user exists and no user is already logged in in this session -> return to UI to get more info
errors = new[] { "No local user exists. Please create your local user by providing the following details." };
appUser = new ApplicationUser
{
Email = loginInfo.Email,
UserName = loginInfo.DefaultUserName,
Name = loginInfo.DefaultUserName,
Claims = new List <ApplicationUserClaim>()
};
foreach (var claim in loginInfo.ExternalIdentity.Claims)
{
appUser.AddClaims(new ApplicationUserClaim
{
ClaimType = claim.Type,
ClaimValue = claim.Value,
ClaimValueType = claim.ValueType,
Issuer = claim.Issuer,
OriginalIssuer = claim.OriginalIssuer,
});
}
return(false);
}
public static SignInManager <IdentityUser, string> GetSignInManager()
{
return(OwinHelper.GetOwinContext(HttpContext.Current)?.Get <SignInManager <IdentityUser, string> >());
}
public Task TheDefaultDefaultShouldBe404()
{
var builder = new AppBuilder();
var app = builder.Build();
var helper = new OwinHelper();
return app(helper.Env).Then(() => helper.ResponseStatusCode.ShouldBe(404));
}
