public async Task <ActionResult> RegisterEmployeeUser(RegisterEmployeeViewModel model)
{
if (ModelState.IsValid)
{
// Check to see if this user is in the existing database
LogicLayer.UserManager usrMgr = new LogicLayer.UserManager();
try
{
if (usrMgr.FindUser(model.Email))
{
// If this user already exists, we need to use the regular Register method
return(RedirectToAction("Register", "Account"));
}
// Not an existing user, create a DataObjects.User without roles
else
{
var employee = new DataObjects.User()
{
// These fields are need by sp_insert_user
Email = model.Email,
FirstName = model.GivenName,
LastName = model.FamilyName,
PhoneNumber = model.PhoneNumber,
};
// Add the DataObjects.User to Employe table
if (usrMgr.AddUser(employee))
{
var employeeID = usrMgr.RetrieveUserIDFromEmail(model.Email);
var user = new ApplicationUser()
{
EmployeeID = employeeID,
GivenName = model.GivenName,
FamilyName = model.FamilyName,
UserName = model.Email,
Email = model.Email
};
var result = await UserManager.CreateAsync(user, "newuser");
if (result.Succeeded)
{
return(RedirectToAction("Index", "Admin"));
}
AddErrors(result);
}
}
}
catch
{
// Creating Employee Failed
return(View(model));
}
}
// ModelState was not valid
return(View(model));
}
/// <summary>
/// Sets User Default Profile
/// </summary>
/// <param name="userId">string user id</param>
/// <param name="defaultProfileId">string profile id</param>
/// <returns>System.Theading.Tasks.Task</returns>
public async Task <SyncState> SetUserDefaultProfile(string userId, string defaultProfileId)
{
DataObjects.User user = await userTable.LookupAsync(userId);
if (user != null)
{
user.DefaultProfileId = defaultProfileId;
await userTable.UpdateAsync(user);
}
return(await SyncUser());
}
/// <summary>
/// Updates a User and Syncs with mobile API values
/// </summary>
/// <param name="user">DataObjects.User row to add or update</param>
/// <returns>System.Threading.Tasks.Task</returns>
public async Task UpdateUser(DataObjects.User user)
{
try
{
await userTable.UpdateAsync(user);
await SyncUser();
}
catch (Exception ex)
{
Debug.WriteLine("Error updating user: " + ex.Message);
}
}
public async Task <ActionResult> RegisterEmployeeUser(RegisterEmployeeViewModel model)
{
if (ModelState.IsValid)
{
// check to see if the user is in the existing database
LogicLayer.UserManager usrMgr = new LogicLayer.UserManager();
try
{
if (usrMgr.FindUser(model.Email))
{
// if the user already exists, we need to use the regular Register method
return(RedirectToAction("Register", "Account"));
}
else // not an existing user, create a DataObjects.User without any roles
{
var employee = new DataObjects.User()
{
// these fields are needed by sp_insert_user
Email = model.Email,
FirstName = model.GivenName,
LastName = model.FamilyName,
PhoneNumber = model.PhoneNumber
};
if (usrMgr.CreateEmployee(employee.FirstName, employee.LastName, employee.PhoneNumber, employee.Email)) // add the DataObjects.User to Employee table
{
var employeeID = usrMgr.RetrieveUserIdFromEmail(model.Email);
var user = new ApplicationUser // if it worked, create an Identity user
{
EmployeeID = employeeID,
GivenName = model.GivenName,
FamilyName = model.FamilyName,
UserName = model.Email,
Email = model.Email
};
var result = await UserManager.CreateAsync(user, "newuser");
if (result.Succeeded) // go back to Admin/Index View
{
return(RedirectToAction("Index", "Admin"));
}
AddErrors(result);
}
}
}
catch
{
// creating employee failed
return(View(model));
}
}
// modelstate was not valid
return(View(model));
}
public static DataObjects.User MapFromDto(this DataTransferObject.UserDto itemDto)
{
if (itemDto == null) return null;
var item = new DataObjects.User ();
item.UserId = itemDto.UserId;
item.Login = itemDto.Username;
item.Created = itemDto.Created;
item.Email = itemDto.Email;
return item;
}
public static DataTransferObject.UserDto MapToDto(this DataObjects.User item)
{
if (item == null)
{
return(null);
}
var itemDto = new DataTransferObject.UserDto();
itemDto.UserId = item.UserId;
itemDto.Username = item.Login;
itemDto.Created = item.Created;
itemDto.Email = item.Email;
return(itemDto);
}
public static DataObjects.User MapFromDto(this DataTransferObject.UserDto itemDto)
{
if (itemDto == null)
{
return(null);
}
var item = new DataObjects.User();
item.UserId = itemDto.UserId;
item.Login = itemDto.Username;
item.Created = itemDto.Created;
item.Email = itemDto.Email;
return(item);
}
// GET api/<controller>
public async Task <User> Get()
{
if (credentials == null)
{
// get the credentials of the user who already signed in
credentials = await User.GetAppServiceIdentityAsync <FacebookCredentials>(Request);
}
fbRequestUrl = "https://graph.facebook.com/me?fields=name,email,id&access_token=" + credentials.AccessToken;
var client = new HttpClient();
var resp = await client.GetAsync(fbRequestUrl);
resp.EnsureSuccessStatusCode();
var fbInfo = await resp.Content.ReadAsStringAsync();
FacebookInfo info = JsonConvert.DeserializeObject <FacebookInfo>(fbInfo);
context = new ToDoTogetherAppContext();
domainManager = new EntityDomainManager <DataObjects.User>(context, Request);
var user = context.Users.FirstOrDefault(u => u.Email == info.Email);
// create new user in the database if one doesn't already exist
if (user == null)
{
user = new DataObjects.User {
Email = info.Email, UserName = info.Name, ProviderId = info.Id
};
await domainManager.InsertAsync(user);
}
// add user to the database with just an email (user was previously added by someone else to the project as a colaborator)
else if (string.IsNullOrEmpty(user.ProviderId))
{
user.UserName = info.Name;
user.ProviderId = info.Id;
await context.SaveChangesAsync();
}
return(user);
}
/// <summary>
/// Sets Current User Data in local tables.
/// </summary>
/// <param name="Id">String Guid of current authorized user</param>
/// <returns>System.Threading.Tasks.Task</returns>
public async Task SetNewUser(string Id)
{
try
{
DataObjects.Profile defaultProfile = null;
//New User, User should be connected to internet for sign in to work.
//Need to sync user table to see if user already exists.
if (string.IsNullOrEmpty(_currentUserId) || _currentUserId == Guid.Empty.ToString())
{
await SyncUser();
}
DataObjects.User currentUser = await userTable.LookupAsync(Id);
//If user still not found after sync need to insert new user
if (currentUser == null || currentUser.Id != Id)
{
currentUser = new DataObjects.User()
{
Id = Id, ActiveDirectoryObjectId = Id
};
await userTable.InsertAsync(currentUser);
defaultProfile = new DataObjects.Profile()
{
Id = Guid.NewGuid().ToString(), PrimaryUserId = currentUser.Id
};
await AddUpdateProfile(defaultProfile);
await SetUserDefaultProfile(currentUser.Id, defaultProfile.Id);
await SyncUser();
await SyncProfile();
}
else
{
//User Existed In Cloud, retrieve profile
await SyncProfile();
defaultProfile = await GetProfile(currentUser.DefaultProfileId);
if (defaultProfile == null)
{
defaultProfile = new DataObjects.Profile()
{
Id = Guid.NewGuid().ToString(), PrimaryUserId = currentUser.Id
};
await AddUpdateProfile(defaultProfile);
await SetUserDefaultProfile(currentUser.Id, defaultProfile.Id);
await SyncUser();
await SyncProfile();
}
}
//Make Sure user has a profile.
_currentUserId = Id;
_currentProfileId = defaultProfile.Id;
_isLoggedIn = true;
await SyncPump();
await SyncChild();
await SyncMedia();
await Task.WhenAll(new Task[] { SyncPresetExperiences(),
SyncUserExperiences(),
SyncHistoricalSessions(),
SyncCaregiverRequest(),
SyncCaregiverRelation() });
}
catch (Exception ex)
{
string error = ex.Message;
}
finally
{
OnSetUserCompleteEvent(new object());
}
}
public async Task <IHttpActionResult> GetMe()
{
//var settings = this.Configuration.GetMobileAppSettingsProvider().GetMobileAppSettings();
//var traceWriter = this.Configuration.Services.GetTraceWriter();
var userId = this.User.GetUserId();
var creds = await this.User.GetAppServiceIdentityAsync <FacebookCredentials>(this.Request);
string facebookUserId = null;
string firstName = null;
string lastName = null;
string eMail = null;
string imageUrl = null;
string profileUrl = null;
using (var db = new timelineformsContext())
{
var userDb = db.Users.FirstOrDefault(u => u.Id == userId);
if (userDb == null)
{
// Inserts the user into the database.
facebookUserId = creds.UserClaims.FirstOrDefault(c => c.Type == ClaimTypes.NameIdentifier).Value;
firstName = creds.UserClaims.FirstOrDefault(c => c.Type == ClaimTypes.GivenName).Value;
lastName = creds.UserClaims.FirstOrDefault(c => c.Type == ClaimTypes.Surname).Value;
eMail = creds.UserClaims.FirstOrDefault(c => c.Type == ClaimTypes.Email).Value;
profileUrl = creds.UserClaims.FirstOrDefault(c => c.Type == FacebookProfileUrlClaim).Value;
imageUrl = $"https://graph.facebook.com/{facebookUserId}/picture?width=150";
userDb = new DataObjects.User
{
Id = userId,
FacebookUserId = facebookUserId,
FirstName = firstName,
LastName = lastName,
EMail = eMail,
ImageUrl = imageUrl,
ProfileUrl = profileUrl,
Deleted = false
};
db.Users.Add(userDb);
await db.SaveChangesAsync();
}
else
{
// The user already exists. Retrieves the information.
facebookUserId = userDb.FacebookUserId;
firstName = userDb.FirstName;
lastName = userDb.LastName;
eMail = userDb.EMail;
imageUrl = userDb.ImageUrl;
profileUrl = userDb.ProfileUrl;
}
}
var user = new User
{
UserId = userId,
FacebookUserId = facebookUserId,
FirstName = firstName,
LastName = lastName,
EMail = eMail,
ImageUrl = imageUrl,
ProfileUrl = profileUrl
};
return(Ok(user));
}
public async Task <ActionResult> Register(RegisterViewModel model)
{
if (ModelState.IsValid)
{
// check to see if this user is in the existing database
LogicLayer.UserManager usrMgr = new LogicLayer.UserManager();
try
{
if (usrMgr.FindUser(model.Email))
{
// this requires the user to use the same password as the one in the internal database
var oldUser = usrMgr.AuthenticateUser(model.Email, model.Password);
var user = new ApplicationUser
{
// populate these fields with wxisting data from oldUser
GivenName = oldUser.FirstName,
FamilyName = oldUser.LastName,
PersonID = oldUser.PersonID,
// populate these fields normally
UserName = model.Email,
Email = model.Email
};
// create the user with the Identity system UserManager normally
var result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
// use the oldUser.Roles list to add the internally assigned roles to the user
foreach (var role in oldUser.Roles)
{
UserManager.AddToRole(user.Id, role);
}
await SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);
return(RedirectToAction("Index", "Home"));
}
AddErrors(result);
}
else // not an existing user, create a user withou
{
var user = new ApplicationUser
{
// We will uncomment the following two lines later, once our ViewModel and
// our View are updated to ask for them:
GivenName = model.GivenName,
FamilyName = model.FamilyName,
UserName = model.Email,
Email = model.Email
};
var result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
// my code
var dbUser = new DataObjects.User
{
FirstName = model.GivenName,
LastName = model.FamilyName,
Email = model.Email
};
usrMgr.AddNewlyRegisteredUser(dbUser, model.Password);
await SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);
return(RedirectToAction("Index", "Home"));
}
AddErrors(result);
}
}
catch
{
// creating old user failed, probably because AuthenticateUser failed
return(View(model));
}
}
// modelstate was not valid
return(View(model));
}
