public async Task <ResponseModel> CreateUserAsync(UserModel user)
{
var rs = await this.QueryEmail(user.Email, IncludeOptions.Entities);
if (rs.Code == ResponseCode.NoData)
{
EmailEntity e = new EmailEntity(new EmailModel(user.Email, user.UserId));
var rsE = await this.InsertEntity <EmailEntity>(e);
if (rsE.Code != ResponseCode.Ok)
{
return(rsE);
}
}
else if (rs.Code == ResponseCode.Ok)
{
//exists, see if the userid is set.. if not, update it
if (rs.Data[0].HasUser)
{
return(ResponseModel.Error(ResponseCode.EmailUnavailable));
}
rs.Data[0].EmailEntity.Email.UserId = user.UserId;
var rsE = await this.UpdateEntity <EmailEntity>(rs.Data[0].EmailEntity);
if (rsE.Code != ResponseCode.Ok)
{
return(rsE);
}
}
else
{
return(rs.ToResponse());
}
//we're here - email entity set - now create the user
UserEntity ue = new UserEntity(user);
var rsU = await this.InsertEntity(ue);
//return an error and we'll also need to revert the userId on the email record
if (rsU.Code != ResponseCode.Ok)
{
var dte = EmailEntity.SetUser(user.Email, Guid.Empty);
var rsDTE = await this.UpdateEntityProperty(EntityTableType.email, dte); // fire and forget
if (rsDTE.Code != ResponseCode.Ok)
{
// handle appropriately
}
return(rsU);
}
return(ResponseModel.Success());
}
public async Task <ResponseModel <UserComposite> > QueryUser(string email, IncludeOptions options = IncludeOptions.None)
{
TableQuery <EmailEntity> query = new TableQuery <EmailEntity>().Where(EmailEntity.QueryKey(email));
var rs = await QueryEntities <EmailEntity>(query);
if (rs.Code != ResponseCode.Ok)
{
return(ResponseModel <UserComposite> .Error(rs.Code, rs.Message));
}
if (rs.Data[0].Email.UserId == null || rs.Data[0].Email.UserId == Guid.Empty)
{
return(ResponseModel <UserComposite> .Error(ResponseCode.NotFound));
}
return(await QueryUser(rs.Data[0].Email.UserId, options));
}
public async Task <ResponseModel <EmailComposite> > QueryEmail(string email, IncludeOptions options = IncludeOptions.None)
{
EmailComposite c = new EmailComposite();
TableQuery <EmailEntity> query = new TableQuery <EmailEntity>().Where(EmailEntity.QueryKey(email));
var rs = await QueryEntities <EmailEntity>(query);
if (rs.Code != ResponseCode.Ok)
{
return(ResponseModel <EmailComposite> .Error(rs.Code, rs.Message));
}
c.Email = rs.Data[0].Email;
if ((options & IncludeOptions.Entities) == IncludeOptions.Entities)
{
c.EmailEntity = rs.Data[0];
}
return(ResponseModel <EmailComposite> .Success(c));
}
public async Task <ResponseModel> DeleteUserAsync(UserModel user)
{
ResponseModel rs = null;
// delete everything about the user...
rs = await this.DeletePartition(EntityTableType.user, user.UserId.Encode());
if (rs.Code == ResponseCode.Ok)
{
//release the email
var ee = await this.QueryEmail(user.Email, IncludeOptions.Entities);
if (ee.Code == ResponseCode.Ok)
{
EmailEntity e = ee.Data[0].EmailEntity;
e.Email.UserId = Guid.Empty;
rs = await this.UpdateEntity <EmailEntity>(e);
}
}
return(rs);
}
public async Task <ResponseModel <UserModel> > ChangeUserEmailAsync(Guid userId, string newEmail)
{
var rsUser = await this.QueryUser(userId, IncludeOptions.Entities);
if (rsUser.Code != ResponseCode.Ok)
{
return(ResponseModel <UserModel> .Error(rsUser.Code, rsUser.Message));
}
var user = rsUser.Data[0].User;
var rsOldEmail = await this.QueryEmail(user.Email);
if (rsOldEmail.Code != ResponseCode.Ok)
{
return(ResponseModel <UserModel> .Error(rsOldEmail.Code, rsOldEmail.Message));
}
var rsNewEmail = await this.QueryEmail(newEmail);
if (rsNewEmail.Code != ResponseCode.Ok && rsNewEmail.Code != ResponseCode.NoData)
{
return(ResponseModel <UserModel> .Error(rsNewEmail.Code, rsNewEmail.Message));
}
if (rsNewEmail.Code == ResponseCode.Ok && rsNewEmail.Data[0].HasUser)
{
return(ResponseModel <UserModel> .Error(ResponseCode.EmailUnavailable));
}
//release the userId from the old email -> or maybe wait to do that once the email has been verified?
var rsOld = await this.UpdateEntityProperty(EntityTableType.email, EmailEntity.SetUser(user.Email, Guid.Empty));
if (rsOld.Code != ResponseCode.Ok)
{
return(ResponseModel <UserModel> .Error(rsOld.Code, rsOld.Message));
}
ResponseModel rsNew = null;
if (rsNewEmail.Code == ResponseCode.NoData)
{
rsNew = await this.InsertEntity <EmailEntity>(new EmailEntity( new EmailModel(newEmail, userId)));
}
else if (rsNewEmail.Code == ResponseCode.Ok)
{
rsNew = await this.UpdateEntityProperty(EntityTableType.email, EmailEntity.SetUser(newEmail, userId));
}
if (rsNew.Code != ResponseCode.Ok)
{
//revert the old email address update
rsOld = await this.UpdateEntityProperty(EntityTableType.email, EmailEntity.SetUser(user.Email, user.UserId));
if (rsOld.Code != ResponseCode.Ok)
{
return(ResponseModel <UserModel> .Error(rsOld.Code, rsOld.Message));
}
return(ResponseModel <UserModel> .Error(rsNew.Code, rsNew.Message));
}
//we're here - email entity set - now update the user
user.EmailOld = user.Email;
user.Email = newEmail;
user.EmailInvalid = false;
user.EmailVerification = new UserContactVerificationModel(ContactMethodType.Email);
var dte = UserEntity.UpdateEmail(userId, user.EmailOld, user.Email, user.EmailVerification);
var rsU = await this.UpdateEntityProperty(EntityTableType.user, dte);
//return an error and we'll also need to revert the userId on the email record
if (rsU.Code != ResponseCode.Ok)
{
// handle appropriately
}
return(ResponseModel <UserModel> .Success(user));
}
