具有ASP.NET身份的Azure移动应用

Question

My cenario is: I already have implemented an ASP.NET WebAPI app with Identity and Register/Login actions. This is My ApiAccountController:

    [Authorize]
    [RoutePrefix("api/Account")]
    public class ApiAccountController : ApiController
    {
        private const string LocalLoginProvider = "Local";
        private ApplicationUserManager _userManager;

        public ApiAccountController()
        {
        }

        public ApiAccountController(ApplicationUserManager userManager,
            ISecureDataFormat<AuthenticationTicket> accessTokenFormat)
        {
            UserManager = userManager;
            AccessTokenFormat = accessTokenFormat;
        }

        public ApplicationUserManager UserManager
        {
            get { return _userManager ?? Request.GetOwinContext().GetUserManager<ApplicationUserManager>(); }
            private set { _userManager = value; }
        }

        public ISecureDataFormat<AuthenticationTicket> AccessTokenFormat { get; }

        // POST api/Account/Register
        [AllowAnonymous]
        [Route("Register")]
        public async Task<IHttpActionResult> Register(RegisterViewModel model)
        {
            if (!ModelState.IsValid) return BadRequest(ModelState);
            var user = new ApplicationUser
            {
                Name = model.Nome,
                UserName = model.Email,
                Email = model.Email,
                CidadeId = model.CidadeId
            };
            var result = await UserManager.CreateAsync(user, model.Password);
            //return !result.Succeeded ? GetErrorResult(result) : Ok();
            if (result.Succeeded)
            {
                var code = await UserManager.GenerateEmailConfirmationTokenAsync(user.Id);
                var callbackUrl = new Uri(Url.Link("ConfirmEmailRoute", new { userId = user.Id, code }));
                await
                    UserManager.SendEmailAsync(user.Id, "Confirme Sua Conta",
                        "Para confirmar sua conta, clique <a href=\"" + callbackUrl + "\">Aqui!</a>");
                // Uri locationHeader = new Uri(Url.Link("GetUserById", new { id = user.Id }));
                return Ok();
            }
            return GetErrorResult(result);
        }

        [HttpGet]
        [AllowAnonymous]
        [Route("ConfirmEmail", Name = "ConfirmEmailRoute")]
        public async Task<IHttpActionResult> ConfirmEmail(Guid userId, string code)
        {
            if (string.IsNullOrEmpty(userId.ToString()) || string.IsNullOrWhiteSpace(code))
            {
                ModelState.AddModelError("", "Códigos necessários");
                return BadRequest(ModelState);
            }

            var result = await UserManager.ConfirmEmailAsync(userId, code);

            if (result.Succeeded)
                return Ok("Conta confirmada! Obrigado pela preferência, agora você pode utilizar nosso novo app");
            return GetErrorResult(result);
        }

        [HttpPost]
        [AllowAnonymous]
        [Route("Login")]
        public async Task<IHttpActionResult> Login(LoginUserViewModel model)
        {
            var request = HttpContext.Current.Request;
            var tokenServiceUrl = request.Url.GetLeftPart(UriPartial.Authority) + request.ApplicationPath + "/Token";
            using (var client = new HttpClient())
            {
                var requestParams = new List<KeyValuePair<string, string>>
                {
                    new KeyValuePair<string, string>("grant_type", "password"),
                    new KeyValuePair<string, string>("username", model.Username),
                    new KeyValuePair<string, string>("password", model.Password)
                };
                var requestParamsFormUrlEncoded = new FormUrlEncodedContent(requestParams);
                var tokenServiceResponse = await client.PostAsync(tokenServiceUrl, requestParamsFormUrlEncoded);
                var responseString = await tokenServiceResponse.Content.ReadAsStringAsync();
                if (tokenServiceResponse.StatusCode != HttpStatusCode.OK) return BadRequest();
                using (var tx = new TransactionScope(TransactionScopeOption.Required,
                    new TransactionOptions { IsolationLevel = IsolationLevel.ReadCommitted },
                    TransactionScopeAsyncFlowOption.Enabled))
                {
                    try
                    {
                        var user = UserManager.FindByName(model.Username);
                        if (user == null) return NotFound();
                        if (!user.EmailConfirmed) return BadRequest();
                        var json = JsonConvert.DeserializeObject<Dictionary<string, string>>(responseString);
                        user.AccessToken = json["access_token"];
                        UserManager.Update(user);
                        tx.Complete();
                        var vm = user.Adapt<UserLoggedViewModel>();
                        return Ok(vm);
                    }
                    catch
                    {
                        tx.Dispose();
                        throw;
                    }
                }
            }
        }


        // POST api/Account/Logout
        [Route("Logout")]
        public IHttpActionResult Logout()
        {
            Authentication.SignOut(CookieAuthenticationDefaults.AuthenticationType);
            return Ok();
        }

// Some actions was removed
        #region Helpers

        private IAuthenticationManager Authentication
        {
            get { return Request.GetOwinContext().Authentication; }
        }

        private IHttpActionResult GetErrorResult(IdentityResult result)
        {
            if (result == null)
                return InternalServerError();

            if (!result.Succeeded)
            {
                if (result.Errors != null)
                    foreach (var error in result.Errors)
                        ModelState.AddModelError("", error);

                if (ModelState.IsValid)
                    return BadRequest();

                return BadRequest(ModelState);
            }

            return null;
        }

        #endregion
    }

This is my Start.Auth configuration

public partial class Startup
{
    public static OAuthAuthorizationServerOptions OAuthOptions { get; private set; }

    public static string PublicClientId { get; private set; }

    // For more information on configuring authentication, please visit http://go.microsoft.com/fwlink/?LinkId=301864
    public void ConfigureAuth(IAppBuilder app)
    {
        // Configure the db context, user manager and signin manager to use a single instance per request
        app.CreatePerOwinContext(ApplicationDbContext.Create);
        app.CreatePerOwinContext<ApplicationUserManager>(ApplicationUserManager.Create);
        app.CreatePerOwinContext<ApplicationSignInManager>(ApplicationSignInManager.Create);

        // Enable the application to use a cookie to store information for the signed in user
        // and to use a cookie to temporarily store information about a user logging in with a third party login provider
        // Configure the sign in cookie
        app.UseCookieAuthentication(new CookieAuthenticationOptions
        {
            AuthenticationType = DefaultAuthenticationTypes.ApplicationCookie,
            LoginPath = new PathString("/Account/Login"),
            Provider = new CookieAuthenticationProvider
            {
                // Enables the application to validate the security stamp when the user logs in.
                // This is a security feature which is used when you change a password or add an external login to your account.  
                OnValidateIdentity =
                    SecurityStampValidator.OnValidateIdentity<ApplicationUserManager, ApplicationUser, Guid>(
                        TimeSpan.FromMinutes(30),
                        (manager, user) =>
                            user.GenerateUserIdentityAsync(manager, DefaultAuthenticationTypes.ApplicationCookie),
                        id => Guid.Parse(id.GetUserId()))
            }
        });

        app.UseExternalSignInCookie(DefaultAuthenticationTypes.ExternalCookie);

        // Enables the application to temporarily store user information when they are verifying the second factor in the two-factor authentication process.
        app.UseTwoFactorSignInCookie(DefaultAuthenticationTypes.TwoFactorCookie, TimeSpan.FromMinutes(5));

        // Enables the application to remember the second login verification factor such as phone or email.
        // Once you check this option, your second step of verification during the login process will be remembered on the device where you logged in from.
        // This is similar to the RememberMe option when you log in.
        app.UseTwoFactorRememberBrowserCookie(DefaultAuthenticationTypes.TwoFactorRememberBrowserCookie);

        app.CreatePerOwinContext(ApplicationDbContext.Create);
        app.CreatePerOwinContext<ApplicationUserManager>(ApplicationUserManager.Create);

        // Enable the application to use a cookie to store information for the signed in user
        // and to use a cookie to temporarily store information about a user logging in with a third party login provider
        app.UseCookieAuthentication(new CookieAuthenticationOptions());
        app.UseExternalSignInCookie(DefaultAuthenticationTypes.ExternalCookie);

        // Configure the application for OAuth based flow
        PublicClientId = "self";
        OAuthOptions = new OAuthAuthorizationServerOptions
        {
            TokenEndpointPath = new PathString("/Token"),
            Provider = new ApplicationOAuthProvider(PublicClientId),
            AuthorizeEndpointPath = new PathString("/api/Account/ExternalLogin"),
            AccessTokenExpireTimeSpan = TimeSpan.FromDays(7),
            RefreshTokenProvider = new RefreshTokenProvider(),
            // In production mode set AllowInsecureHttp = false
            AllowInsecureHttp = true
        };

        // Enable the application to use bearer tokens to authenticate users
        app.UseOAuthBearerTokens(OAuthOptions);

        //var options = new AppServiceAuthenticationOptions()
        //{
        //    SigningKey = ConfigurationManager.AppSettings["SigningKey"],
        //    ValidAudiences = new[] {ConfigurationManager.AppSettings["ValidAudience"]},
        //    ValidIssuers = new[] {ConfigurationManager.AppSettings["ValidIssuer"]},
        //    TokenHandler = WebApiConfig.Configuration.GetAppServiceTokenHandler()
        //};

        //app.UseAppServiceAuthentication(options);

    }
}

The WebAPIConfig

  public static class WebApiConfig
{
    //public static HttpConfiguration Configuration { get; private set; }
    public static void Register(HttpConfiguration config)
    {
        //Configuration = config;
        // Web API configuration and services
        // Configure Web API to use only bearer token authentication.
        config.SuppressDefaultHostAuthentication();
        config.Filters.Add(new HostAuthenticationFilter(OAuthDefaults.AuthenticationType));
        config.EnableCors(new EnableCorsAttribute("*", "*", "*"));
        config.Formatters.Remove(config.Formatters.XmlFormatter);
        config.Formatters.JsonFormatter.SerializerSettings.ReferenceLoopHandling = ReferenceLoopHandling.Ignore;
        config.Formatters.JsonFormatter.SerializerSettings.NullValueHandling = NullValueHandling.Ignore;

        // Web API routes
        config.MapHttpAttributeRoutes();

        config.Routes.MapHttpRoute(
            "DefaultApi",
            "api/{controller}/{id}",
            new {id = RouteParameter.Optional}
        );

        var container = LightInjectContainer.Register();
        container.RegisterApiControllers();
        container.EnableWebApi(config);

        MapsterConfig.RegisterMappings();

       // Database.SetInitializer<SolumDbContext>(null);

       // new MobileAppConfiguration()
       //     .UseDefaultConfiguration()
       //     .ApplyTo(config);

    }
}

This is totally functional and I use this with my mobile app. But, I want to use the azure offline sync with per-user data sync. Reading some articles on Google, no one say exactly how to use Identity on Mobile Apps. All articles says to read the Microsoft Documentation of how to configure custom login provider, but neither they explain how to configure this exactly. I already read some posts here. Some people have the same problem I have and no one has the solution, a real example of how to use this or I not found this.

For clear, I want to use my Identity configuration with Azure Mobile App and sync per-user data with the azure offline sync funcionalities.

Someone can help me about this?

I really thank!

Answer 1

您需要阅读我的书的第2章-http://aka.ms/zumobook