public static void EnsureSeedData(this AppIdentityDbContext context)
{
AppUserManager userMgr = new AppUserManager(new UserStore <AppUser, AppRole, AppIdentityDbContext, string>(context), null, new PasswordHasher <AppUser>(), null, null, null, null, null, null);
AppRoleManager roleMgr = new AppRoleManager(new RoleStore <AppRole, AppIdentityDbContext, string>(context), null, null, null, null, null);
string roleName = "Administrators";
string userName = "******";
string password = "******";
string email = "*****@*****.**";
if (!roleMgr.RoleExistsAsync(roleName).Result)
{
roleMgr.CreateAsync(new AppRole(roleName)).Wait();
}
AppUser user = userMgr.FindByNameAsync(userName).Result;
if (user == null)
{
user = new AppUser {
UserName = userName, Email = email
};
userMgr.CreateAsync(user, password).Wait();
user = userMgr.FindByNameAsync(userName).Result;
}
if (!userMgr.IsInRoleAsync(user, roleName).Result)
{
userMgr.AddToRoleAsync(user, roleName).Wait();
}
context.SaveChanges();
}
public async Task <IHttpActionResult> FacebookRegister(RegisterExternalBindingModel3 model)
{
try
{
if (string.IsNullOrEmpty(model.Token))
{
return(BadRequest("Invalid OAuth access token"));
}
var tokenExpirationTimeSpan = TimeSpan.FromDays(360);
// Get the fb access token and make a graph call to the /me endpoint
var fbUser = await VerifyFacebookAccessToken(model.Token);
if (fbUser?.Email == null)
{
return(BadRequest("Invalid OAuth access token"));
}
// Check if the user is already registered
var user = await UserManager.FindByEmailAsync(fbUser.Email);
// If not, register it
if (user == null)
{
var userPassword = "******" + fbUser.ID.ToString();
var randomPassword = System.Web.Security.Membership.GeneratePassword(10, 0) + "1Ds@";
user = new User()
{
UserName = fbUser.Email, MobileNumber = model.PhoneNumber, Email = fbUser.Email, Name = string.IsNullOrWhiteSpace(fbUser.Name) ? model.Name : fbUser.Name, PhoneNumber = model.PhoneNumber, Photo = model.Photo, CountryCode = model.CountryCode
};
user.Id = Guid.NewGuid().ToString();
IdentityResult result = await UserManager.CreateAsync(user, userPassword + randomPassword);
if (!result.Succeeded)
{
return(GetErrorResult(result));
}
IdentityResult roleResult;
bool adminRoleExists = await AppRoleManager.RoleExistsAsync("User");
if (!adminRoleExists)
{
roleResult = await AppRoleManager.CreateAsync(new RoleForUser()
{
Id = Guid.NewGuid().ToString(),
Name = "User"
});
}
var userResult = await UserManager.AddToRoleAsync(user.Id, "User");
}
return(Ok(GenerateLocalAccessTokenResponse(user.UserName, user.Id)));
}
catch (Exception e)
{
throw e;
}
}
private async Task <Tuple <ApplicationUser, string> > RegisterPelanggan(string email, string password)
{
try
{
ApplicationUser user = new Models.ApplicationUser {
UserName = email, Email = email, LockoutEnabled = false, EmailConfirmed = false
};
var created = await UserManager.CreateAsync(user, password);
if (created.Succeeded)
{
string roleName = "Pelanggan";
if (!await AppRoleManager.RoleExistsAsync(roleName))
{
var r = new MySql.AspNet.Identity.IdentityRole("125", roleName);
var roleCreated = await AppRoleManager.CreateAsync(r);
if (!roleCreated.Succeeded)
{
throw new SystemException("Role Tidak Berhasil Disimpan");
}
}
var role = await AppRoleManager.FindByNameAsync(roleName);
if (role != null)
{
var added = await UserManager.AddToRoleAsync(user.Id, roleName);
if (!added.Succeeded)
{
throw new SystemException(string.Format("User Tidak Berhasil Di tambahkan Ke Role {0}", roleName));
}
}
else
{
throw new SystemException(string.Format("Role {0} Tidak Ditemukan", roleName));
}
}
else
{
throw new SystemException("User TIdak Berhasil Dibuat");
}
string c = await UserManager.GenerateEmailConfirmationTokenAsync(user.Id);
string strcode = HttpUtility.UrlEncode(c);
var callbackUrl = Url.Link("DefaultApi", new { controller = "User/ConfirmPassword", userId = user.Id, code = strcode });
await UserManager.SendEmailAsync(user.Id, "Confirm your account", "Please confirm your account by clicking <a href=\"" + callbackUrl + "\">here</a>");
return(Tuple.Create(user, strcode));
}
catch (Exception ex)
{
throw new SystemException(ex.Message);
}
}
private async Task CreateRole(string str)
{
var role = new ApplicationRole();
bool rExists = await AppRoleManager.RoleExistsAsync(str);
if (!rExists)
{
role.Name = str;
await AppRoleManager.CreateAsync(role);
}
}
private async Task <ApplicationUser> RegisterPetugas(string email)
{
try
{
var user = new Models.ApplicationUser {
UserName = email, Email = email, LockoutEnabled = true, EmailConfirmed = true
};
var created = await UserManager.CreateAsync(user, "Petugas#123");
if (created.Succeeded)
{
string roleName = "Petugas";
if (!await AppRoleManager.RoleExistsAsync(roleName))
{
var r = new MySql.AspNet.Identity.IdentityRole("123", roleName);
var roleCreated = await AppRoleManager.CreateAsync(r);
if (!roleCreated.Succeeded)
{
throw new SystemException("Role Tidak Berhasil Disimpan");
}
}
var role = await AppRoleManager.FindByNameAsync(roleName);
if (role != null)
{
var added = await UserManager.AddToRoleAsync(user.Id, roleName);
if (!added.Succeeded)
{
throw new SystemException(string.Format("User Tidak Berhasil Di tambahkan Ke Role {0}", roleName));
}
}
else
{
throw new SystemException(string.Format("Role {0} Tidak Ditemukan", roleName));
}
}
else
{
throw new SystemException("User TIdak Berhasil Dibuat");
}
return(user);
}
catch (Exception ex)
{
throw new SystemException(ex.Message);
}
}
public async Task <IHttpActionResult> TwitterRegister(RegisterExternalBindingModel2 model)
{
if (string.IsNullOrEmpty(model.AccessToken) || string.IsNullOrEmpty(model.AccessTokenSecret))
{
return(BadRequest("Invalid OAuth access token"));
}
Auth.SetUserCredentials(ConfigurationManager.AppSettings["Twitter.ConsumerKey"], ConfigurationManager.AppSettings["Twitter.ConsumerSecretKey"], model.AccessToken, model.AccessTokenSecret);
var twUser = Tweetinvi.User.GetAuthenticatedUser();
var tokenExpirationTimeSpan = TimeSpan.FromDays(360);
// Get the fb access token and make a graph call to the /me endpoint
if (twUser?.Email == null)
{
return(BadRequest("invalid token"));
}
// Check if the user is already registered
var user = await UserManager.FindByEmailAsync(twUser.Email);
// If not, register it
if (user == null)
{
var randomPassword = System.Web.Security.Membership.GeneratePassword(10, 0) + "1Ds@";
user = new User()
{
UserName = twUser.Email, Email = twUser.Email, Name = twUser.Name.IsNullOrWhiteSpace() ? model.Name : twUser.Name, PhoneNumber = model.PhoneNumber, Photo = twUser.ProfileImageUrl, CountryCode = model.CountryCode
};
IdentityResult result = await UserManager.CreateAsync(user, randomPassword);
if (!result.Succeeded)
{
return(GetErrorResult(result));
}
IdentityResult roleResult;
bool adminRoleExists = await AppRoleManager.RoleExistsAsync("User");
if (!adminRoleExists)
{
roleResult = await AppRoleManager.CreateAsync(new RoleForUser()
{
Name = "User"
});
}
var userResult = await UserManager.AddToRoleAsync(user.Id, "User");
}
return(Ok(GenerateLocalAccessTokenResponse(user.UserName, user.Id)));
}
public async Task <IHttpActionResult> IsInRole(string role)
{
if (!User.Identity.IsAuthenticated)
{
return(BadRequest("User not authenticated"));
}
var roleExists = await AppRoleManager.RoleExistsAsync(role);
if (!roleExists)
{
return(BadRequest("Role does not exist"));
}
var isInRole = await AppUserManager.IsInRoleAsync(User.Identity.GetUserId(), role);
if (!isInRole)
{
return(BadRequest("User not in role"));
}
return(Ok("User in role"));
}
public async Task <bool> RoleExistsAsync(string roleName)
{
return(await _roleManager.RoleExistsAsync(roleName));
}
// PUT: api/SetPengawas/5
public async Task <HttpResponseMessage> Put(int id, [FromBody] pegawai value)
{
var role = "Pengawas";
using (var db = new OcphDbContext())
{
var trans = db.BeginTransaction();
try
{
if (value.Pengawas == false)
{
var isExis = await AppRoleManager.RoleExistsAsync(role);
if (!isExis)
{
var r = await AppRoleManager.CreateAsync(new IdentityRole(role) { Name = role });
if (!r.Succeeded)
{
throw new System.Exception(string.Format("Role {0} Gagal Dibuat, Hubungi Administrator", role));
}
}
if (db.Pegawai.Update(O => new { O.Pengawas }, new pegawai {
Pengawas = true
}, O => O.Id == value.Id))
{
var roleResult = await UserManager.AddToRoleAsync(value.UserId, role);
if (!roleResult.Succeeded)
{
throw new System.Exception(string.Format("Gagal Menambahkan User Role"));
}
else
{
trans.Commit();
value.Pengawas = true;
return(Request.CreateResponse(HttpStatusCode.OK, value));
}
}
else
{
throw new System.Exception(string.Format("Gagal Menambahkan User Role"));
}
}
else
{
if (db.Pegawai.Update(O => new { O.Pengawas }, new pegawai {
Pengawas = false
}, O => O.Id == value.Id))
{
var roleResult = await UserManager.RemoveFromRoleAsync(value.UserId, role);
if (!roleResult.Succeeded)
{
throw new System.Exception(string.Format("Gagal Menghapus User Role"));
}
else
{
trans.Commit();
value.Pengawas = false;
return(Request.CreateResponse(HttpStatusCode.OK, value));
}
}
else
{
throw new System.Exception(string.Format("Gagal Menghapus User Role"));
}
}
}
catch (Exception ex)
{
trans.Rollback();
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ex.Message));
}
}
}
// POST: api/Pegawai
public async Task <HttpResponseMessage> Post([FromBody] pegawai value)
{
RegisterViewModel model = new RegisterViewModel();
model.Email = value.Email;
model.Password = "******";
try
{
if (ModelState.IsValid)
{
var user = new ApplicationUser {
UserName = model.Email, Email = model.Email
};
var result = await UserManager.CreateAsync(user, model.Password);
string role = "Pegawai";
if (result.Succeeded)
{
var isExis = await AppRoleManager.RoleExistsAsync(role);
if (!isExis)
{
var r = await AppRoleManager.CreateAsync(new IdentityRole(role) { Name = role });
if (r.Succeeded)
{
var roleResult = await UserManager.AddToRoleAsync(user.Id, role);
if (!roleResult.Succeeded)
{
throw new System.Exception(string.Format("Gagal Menambahkan User Role"));
}
}
else
{
throw new System.Exception(string.Format("Role {0} Gagal Dibuat, Hubungi Administrator", role));
}
}
using (var db = new OcphDbContext())
{
value.UserId = user.Id;
value.Id = db.Pegawai.InsertAndGetLastID(value);
string c = await UserManager.GenerateEmailConfirmationTokenAsync(user.Id);
string code = HttpUtility.UrlEncode(c);
var callbackUrl = Url.Link("DefaultApi", new { controller = "Account/ConfirmEmail", userId = user.Id, code = code });
await UserManager.SendEmailAsync(user.Id, "Confirm your account", "Please confirm your account by clicking <a href=\"" + callbackUrl + "\">here</a>");
return(Request.CreateResponse(HttpStatusCode.OK, value));
}
}
else
{
throw new SystemException("Data Tidak berhasil ditambah");
}
}
else
{
throw new SystemException("Data Tidak Valid");
}
}
catch (Exception ex)
{
if (value.Id > 0)
{
return(Request.CreateResponse(HttpStatusCode.Created, "Email Confirm Account Not Sended"));
}
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ex.Message, ex));
}
}
