public async Task <UserEnvelope> Handle(Command request, CancellationToken cancellationToken)
{
if (_currentUserAccessor.GetCurrentUserType().Equals(UserConstants.User))
{
throw new RestException(HttpStatusCode.Unauthorized, new { Username = Constants.UNAUTHERIZE });
}
if (await _context.Persons.Where(x => x.Username == request.User.Username).AsNoTracking().AnyAsync(cancellationToken))
{
throw new RestException(HttpStatusCode.BadRequest, new { Username = Constants.IN_USE });
}
var person = new Person
{
Username = request.User.Username,
ProfileUrl = request.User.ProfileUrl,
Phone = request.User.Phone,
UserType = request.User.UserType,
Password = _passwordHasher.Hash(request.User.Password),
CreatedDate = DateTime.Now
};
await _context.Persons.AddAsync(person, cancellationToken);
await _context.SaveChangesAsync(cancellationToken);
var auditId = _currentUserAccessor.GetAuditId();
var user = _mapper.Map <Person, User>(person);
user.Type = UserConstants.GetUserTypeString(person.UserType);
user.Token = _jwtTokenGenerator.CreateToken(user.Username, user.Type, auditId.ToString());
return(new UserEnvelope(user));
}
public async Task <UserEnvelope> Handle(Query request, CancellationToken cancellationToken)
{
var currentUsername = _currentUserAccessor.GetCurrentUsername();
var person = await _context.Persons
.AsNoTracking()
.FirstOrDefaultAsync(x => x.Username == request.Username, cancellationToken);
if (person == null)
{
throw new RestException(HttpStatusCode.NotFound, new { User = Constants.NOT_FOUND });
}
if (_currentUserAccessor.GetCurrentUserType().Equals(UserConstants.User) &&
!currentUsername.Equals(person.Username)
)
{
throw new RestException(HttpStatusCode.Unauthorized, new { User = Constants.UNAUTHERIZE });
}
var user = _mapper.Map <Person, User>(person);
user.Type = UserConstants.GetUserTypeString(person.UserType);
if (!user.Username.Equals(currentUsername))
{
return(new UserEnvelope(user));
}
// To mark the profile UI is current user
user.IsCurrentUser = true;
return(new UserEnvelope(user));
}
private Constants InitializeConstants()
{
return new Constants()
{
ActionTypes = new ObservableCollection<ActionType>(UserConstants.DefaultActionTypes()),
Colors = new ObservableCollection<BuiltSteady.Zaplify.Devices.ClientEntities.Color>(UserConstants.DefaultColors()),
Permissions = new ObservableCollection<Permission>(UserConstants.DefaultPermissions()),
Priorities = new ObservableCollection<Priority>(UserConstants.DefaultPriorities()),
ItemTypes = new ObservableCollection<ItemType>(UserConstants.DefaultItemTypes())
};
}
private ObservableCollection<Folder> InitializeFolders()
{
// get the default folders and enqueue an operation to insert each one of them and their subitems
var folders = new ObservableCollection<Folder>(UserConstants.DefaultFolders(null));
foreach (var folder in folders)
{
string queueName = folder.Name.StartsWith("$") ? RequestQueue.SystemQueue : RequestQueue.UserQueue;
FolderDictionary.Add(folder.ID, folder);
RequestQueue.EnqueueRequestRecord(queueName,
new RequestQueue.RequestRecord() { ReqType = RequestQueue.RequestRecord.RequestType.Insert, Body = folder, ID = folder.ID, IsDefaultObject = true });
foreach (var item in folder.Items)
{
RequestQueue.EnqueueRequestRecord(queueName,
new RequestQueue.RequestRecord() { ReqType = RequestQueue.RequestRecord.RequestType.Insert, Body = item, ID = item.ID, IsDefaultObject = true });
}
StorageHelper.WriteFolder(folder);
}
// extract the $Client folder and handle it specially
var cf = folders.Single(f => f.Name == SystemEntities.Client);
folders.Remove(cf);
ClientFolder = cf;
// extract the $PhoneClient folder and handle it specially
var pcf = folders.Single(f => f.Name == SystemEntities.PhoneClient);
folders.Remove(pcf);
PhoneClientFolder = pcf;
// initialize the SelectedCount for a few default folders and lists
/*
foreach (var folder in folders)
{
if (folder.Name == UserEntities.People ||
folder.Name == UserEntities.Places)
{
ListMetadataHelper.IncrementListSelectedCount(pcf, folder);
continue;
}
foreach (var item in folder.Items)
{
if (item.Name == UserEntities.Tasks ||
item.Name == UserEntities.Groceries)
{
ListMetadataHelper.IncrementListSelectedCount(pcf, item);
continue;
}
}
}
*/
return folders;
}
void CreateDefaultFolders(UserDataModel model)
{
try
{
List <Folder> folders = UserConstants.DefaultFolders(this.CurrentUser);
foreach (var folder in folders)
{
// child items must be added AFTER saving parent items
// EF cannot determine which items are dependent on eachother
List <Item> folderItems = new List <Item>();
List <Item> childItems = new List <Item>();
foreach (var item in folder.Items)
{
if (item.ParentID == null)
{
folderItems.Add(item);
}
else
{
childItems.Add(item);
}
}
folder.Items = folderItems;
model.StorageContext.Folders.Add(folder);
model.StorageContext.SaveChanges();
if (childItems.Count > 0)
{
foreach (var item in childItems)
{
model.StorageContext.Items.Add(item);
}
model.StorageContext.SaveChanges();
}
}
// create an operation corresponding to the new user creation
var operation = model.StorageContext.CreateOperation(this.CurrentUser, "POST", (int?)HttpStatusCode.Created, this.CurrentUser, null);
// kick off the New User workflow
WorkflowHost.WorkflowHost.InvokeWorkflowForOperation(model.StorageContext, null, operation);
}
catch (Exception ex)
{
TraceLog.TraceException("CreateDefaultFolders failed", ex);
throw;
}
}
public async Task <UserEnvelope> Handle(Command request, CancellationToken cancellationToken)
{
var person = await _context.Persons
.Where(x => x.Username == request.User.Username)
.AsNoTracking()
.SingleOrDefaultAsync(cancellationToken);
if (person == null)
{
throw new RestException(HttpStatusCode.Unauthorized, new { Error = "Invalid email / password." });
}
if (!_passwordHasher.Verify(request.User.Password, person.Password))
{
throw new RestException(HttpStatusCode.Unauthorized, new { Error = "Invalid email / password." });
}
var user = _mapper.Map <Person, User>(person);
user.Type = UserConstants.GetUserTypeString(person.UserType);
user.IsCurrentUser = true;
/*
* Trace user login
*/
var userAgent = _currentUserAccessor.GetUserAgent();
var description = $"LoggedIn using ip: {_currentUserAccessor.GetUserIp()}, " +
$"UserAgent: {userAgent.OS} {userAgent.Name} {userAgent.Version}";
var audit = new Audit()
{
Descriptions = description,
CreatedDate = DateTime.Now,
PersonId = person.Id
};
await _context.Audits.AddAsync(audit, cancellationToken);
await _context.SaveChangesAsync(cancellationToken);
user.Token = _jwtTokenGenerator.ValidTokenTime(ValidPeriodUser).CreateToken(person.Username, user.Type, audit.Id.ToString());
return(new UserEnvelope(user));
}
private ObservableCollection<ItemType> InitializeItemTypes()
{
return new ObservableCollection<ItemType>(UserConstants.DefaultItemTypes());
}
// update constants in User database to current version defined in EntityConstants
public bool VersionConstants(string me)
{
try
{
bool updateDB = false;
if (Versions.Any(v => v.VersionType == DatabaseVersion.Constants && v.VersionString == UserConstants.ConstantsVersion) == false)
{ // no database - create and lock the new version entry
TraceLog.TraceInfo(String.Format("User database version {0} not found", UserConstants.ConstantsVersion));
// remove an existing database version (there should never be more than one)
foreach (var existingVersion in Versions.Where(v => v.VersionType == DatabaseVersion.Constants).ToList())
{
Versions.Remove(existingVersion);
}
SaveChanges();
// create the new version entry
DatabaseVersion ver = new DatabaseVersion()
{
VersionType = DatabaseVersion.Constants,
VersionString = UserConstants.ConstantsVersion,
Status = me
};
Versions.Add(ver);
SaveChanges();
updateDB = true;
}
else
{
var dbVersion = Versions.Single(v => v.VersionType == DatabaseVersion.Constants && v.VersionString == UserConstants.ConstantsVersion);
if (dbVersion.Status == DatabaseVersion.Corrupted)
{ // try to update the database again - take a lock
TraceLog.TraceInfo("User database corrupted");
dbVersion.Status = me;
SaveChanges();
updateDB = true;
}
}
if (updateDB == false)
{
TraceLog.TraceInfo(String.Format("User database version {0} is up to date", UserConstants.ConstantsVersion));
return(true);
}
}
catch (Exception ex)
{
TraceLog.TraceException("Could not find database version", ex);
return(false);
}
// update the default database values
DatabaseVersion version = null;
UserStorageContext versionContext = Storage.NewUserContext;
try
{ // verify that this unit of execution owns the update lock for the database version
version = versionContext.Versions.Single(v => v.VersionType == DatabaseVersion.Constants && v.VersionString == UserConstants.ConstantsVersion);
if (version.Status != me)
{
return(true);
}
TraceLog.TraceInfo(String.Format("{0} updating User datatbase to version {1}", me, UserConstants.ConstantsVersion));
// update existing action types, add new action types
foreach (var entity in UserConstants.DefaultActionTypes())
{
if (ActionTypes.Any(e => e.ActionTypeID == entity.ActionTypeID))
{
ActionTypes.Single(e => e.ActionTypeID == entity.ActionTypeID).Copy(entity);
}
else
{
ActionTypes.Add(entity);
}
}
SaveChanges();
TraceLog.TraceInfo("Replaced action types");
// update existing colors, add new colors
foreach (var entity in UserConstants.DefaultColors())
{
if (Colors.Any(e => e.ColorID == entity.ColorID))
{
Colors.Single(e => e.ColorID == entity.ColorID).Copy(entity);
}
else
{
Colors.Add(entity);
}
}
SaveChanges();
TraceLog.TraceInfo("Replaced colors");
// update existing permissions, add new permissions
foreach (var entity in UserConstants.DefaultPermissions())
{
if (Permissions.Any(e => e.PermissionID == entity.PermissionID))
{
Permissions.Single(e => e.PermissionID == entity.PermissionID).Copy(entity);
}
else
{
Permissions.Add(entity);
}
}
SaveChanges();
TraceLog.TraceInfo("Replaced permissions");
// update existing priorities, add new priorities
foreach (var entity in UserConstants.DefaultPriorities())
{
if (Priorities.Any(e => e.PriorityID == entity.PriorityID))
{
Priorities.Single(e => e.PriorityID == entity.PriorityID).Copy(entity);
}
else
{
Priorities.Add(entity);
}
}
SaveChanges();
TraceLog.TraceInfo("Replaced priorities");
// update existing or add new built-in users
foreach (var user in UserConstants.DefaultUsers())
{
if (Users.Any(u => u.ID == user.ID))
{
var existing = Users.Single(u => u.ID == user.ID);
existing.Name = user.Name;
existing.Email = user.Email;
existing.CreateDate = user.CreateDate;
}
else
{
Users.Add(user);
}
}
SaveChanges();
TraceLog.TraceInfo("Replaced users");
// update existing or add new built-in itemtypes and fields
foreach (var itemType in UserConstants.DefaultItemTypes())
{
if (ItemTypes.Any(it => it.ID == itemType.ID))
{
var existing = ItemTypes.Include("Fields").Single(it => it.ID == itemType.ID);
existing.Copy(itemType);
if (itemType.Fields == null)
{
continue;
}
foreach (var field in itemType.Fields)
{
if (existing.Fields.Any(f => f.ID == field.ID))
{
var existingField = existing.Fields.Single(f => f.ID == field.ID);
existingField.Copy(field);
}
else
{
existing.Fields.Add(field);
}
}
}
else
{
ItemTypes.Add(itemType);
}
}
SaveChanges();
TraceLog.TraceInfo("Replaced item types and fields");
// save the new version number
version.Status = DatabaseVersion.OK;
versionContext.SaveChanges();
return(true);
}
catch (Exception ex)
{
TraceLog.TraceException("VersionConstants failed", ex);
// mark the version as corrupted
version.Status = DatabaseVersion.Corrupted;
versionContext.SaveChanges();
return(false);
}
}
