public async Task <IActionResult> AddUserContactByEmail([FromBody] UserContactModel userContactModel)
{
User user = await GetUserAsync().ConfigureAwait(false);
// find other user
User contact = await userManager.FindByEmailAsync(userContactModel.ContactEmail);
if (contact == null)
{
return(BadRequest("No user with specified email found"));
}
try
{
userContactRepository.Add(new UserContact
{
OwnerId = user.Id,
ContactId = contact.Id
});
return(Ok());
}
catch (ArgumentException e)
{
return(BadRequest(e.Message));
}
}
public IActionResult Post([FromBody] UserContactModel model)
{
try
{
if (!string.IsNullOrEmpty(model.Id))
{
//Check Empty Guid
Guid userid = new Guid(model.Id);
if (userid != Guid.Empty)
{
//Update
APIReturnModel update = UserContactServices.SaveUserContacts(model);
return(Ok(new { data = update.Value, status = StatusMessages.Get(update.Status) }));
}
else
{
//Passed User ID is empty guid
return(Ok(new { data = string.Empty, status = StatusMessages.Error_UserUpdateFailed_GUID }));
}
}
else
{
//Insert
APIReturnModel create = UserContactServices.SaveUserContacts(model);
return(Ok(new { data = create.Value, status = StatusMessages.Get(create.Status) }));
}
}
catch
{
}
return(Ok(new { data = string.Empty, status = StatusMessages.Error_Failed }));
}
public async Task <UserContactModel> PostUserContact(UserContactModel model)
{
await _context.UserContacts.AddAsync(model);
await _context.SaveChangesAsync();
return(model);
}
public async Task AddById_Should_Return_Ok_If_Contact_Id_Is_An_Existing_User()
{
UserContactModel model = ValidUserContactModel;
HttpResponseMessage result = await Client.PostAsync(AddByIdPath, Stringify(model));
Assert.That(result.StatusCode, Is.EqualTo(HttpStatusCode.OK));
}
public async Task AddByEmail_Should_Return_Bad_Request_If_ContactEmail_Is_Not_An_Existing_User()
{
UserContactModel model = ValidUserContactModel;
model.ContactEmail = model.ContactEmail + "randomTextAndStuffs";
HttpResponseMessage result = await Client.PostAsync(AddByEmailPath, Stringify(model));
Assert.That(result.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest));
}
public bool AcceptFriendRequest(int contactId, int userId)
{
var userContact = new UserContactModel()
{
StatusId = (int)Lookups.ContactStatuses.Accepted,
UserId = contactId,
ContactId = userId,
};
return(_userContact.Update(userContact));
}
public int AddFriendRequest(int contactId, int userId)
{
var userContact = new UserContactModel()
{
StatusId = (int)Lookups.ContactStatuses.Requested,
UserId = userId,
ContactId = contactId,
};
return(_userContact.Add(userContact));
}
public async Task AddById_Should_Add_New_UserContact_To_Context()
{
UserContactModel model = ValidUserContactModel;
int beforeCount = Context.UserContacts.Count();
await Client.PostAsync(AddByIdPath, Stringify(model));
int afterCount = Context.UserContacts.Count();
Assert.That(afterCount, Is.EqualTo(beforeCount + 1));
}
public bool Update(UserContactModel model)
{
var userContact =
_db.UserContacts.First(x => x.UserId == model.UserId && x.ContactId == model.ContactId);
userContact.StatusId = model.StatusId;
userContact.LastUpdatedOn = UnixTimeBaseClass.UnixTimeNow;
_db.Entry(userContact).State = EntityState.Modified;
_db.SaveChanges();
return(true);
}
public async Task Remove_Should_Return_Bad_Request_If_UserContact_Does_Not_Exists()
{
// remove all user contacts
Context.UserContacts.RemoveRange(Context.UserContacts);
UserContactModel model = ValidUserContactModel;
model.ContactId = user.Id;
HttpResponseMessage result = await Client.PostAsync(RemovePath, Stringify(model));
Assert.That(result.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest));
}
public int Add(UserContactModel model)
{
var contact = new UserContact()
{
UserId = model.UserId,
ContactId = model.ContactId,
StatusId = model.StatusId,
CreatedOn = UnixTimeBaseClass.UnixTimeNow
};
_db.UserContacts.Add(contact);
_db.SaveChanges();
return(contact.UserContactId);
}
public async Task AddById_Should_Return_Bad_Request_If_UserContact_Already_Exists()
{
Context.UserContacts.Add(new UserContact
{
ContactId = user.Id,
OwnerId = user.Id,
});
Context.SaveChanges();
UserContactModel model = ValidUserContactModel;
HttpResponseMessage result = await Client.PostAsync(AddByIdPath, Stringify(model));
Assert.That(result.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest));
}
private async Task <bool> SetNewEmailContactAsync(ApplicationUser appUser, UserContactModel emailContact,
IConvertibleToUserContacts userContracts)
{
if (emailContact != null && emailContact.Value != userContracts.Email
) //TODO It can happen that this check wont work before new contact is formatted, move this to manager
{
emailContact.Value = userContracts.Email;
emailContact.ConfirmCode = await m_identityUserManager.GenerateEmailConfirmationTokenAsync(appUser);
appUser.Email = emailContact.Value; //Save new values to appuser instance for future send of confirm code
appUser.EmailConfirmCode = emailContact.ConfirmCode;
return(true);
}
return(false);
}
public async Task Remove_Should_Return_Bad_Request_If_ContactId_Is_Not_An_Existing_User()
{
Context.UserContacts.Add(new UserContact
{
ContactId = user.Id,
OwnerId = user.Id,
});
Context.SaveChanges();
UserContactModel model = ValidUserContactModel;
model.ContactId = -5;
HttpResponseMessage result = await Client.PostAsync(RemovePath, Stringify(model));
Assert.That(result.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest));
}
public async Task Remove_Should_Return_Ok_If_Contact_Id_Is_An_Existing_User()
{
UserContact userContact = new UserContact
{
ContactId = user.Id,
OwnerId = user.Id,
};
Context.UserContacts.Add(userContact);
Context.SaveChanges();
UserContactModel model = ValidUserContactModel;
HttpResponseMessage result = await Client.PostAsync(RemovePath, Stringify(model));
await result.Content.ReadAsStringAsync();
Assert.That(result.StatusCode, Is.EqualTo(HttpStatusCode.OK));
}
public async Task Remove_Should_Remove_Existing_UserContact_From_Context()
{
Context.UserContacts.Add(new UserContact
{
ContactId = user.Id,
OwnerId = user.Id,
});
Context.SaveChanges();
UserContactModel model = ValidUserContactModel;
int beforeCount = Context.UserContacts.Count();
await Client.PostAsync(RemovePath, Stringify(model));
int afterCount = Context.UserContacts.Count();
Assert.That(afterCount, Is.EqualTo(beforeCount - 1));
}
public ActionResult AddContact(Guid userId)
{
var repository = CurrentAccountDbContext.GetUserRepository();
var user = repository.GetById(userId);
if (!CurrentUser.CanManageAccount() && user.Id != CurrentUser.Id)
{
throw new NoAccessToPageException();
}
var model = new UserContactModel()
{
ModalMode = Request.IsAjaxRequest(),
ReturnUrl = Url.Action("Edit", new { id = userId.ToString() }),
UserId = user.Id
};
return(View(model));
}
public async Task <IActionResult> RemoveUserContact([FromBody] UserContactModel userContactModel)
{
User user = await GetUserAsync().ConfigureAwait(false);
try
{
userContactRepository.Delete(new UserContact
{
OwnerId = user.Id,
ContactId = userContactModel.ContactId
});
return(Ok());
}
catch (ArgumentException e)
{
return(BadRequest(e.Message));
}
}
public ActionResult EditContact(Guid id)
{
var repository = CurrentAccountDbContext.GetUserRepository();
var contact = repository.GetContactById(id);
if (!CurrentUser.CanManageAccount() && contact.UserId != CurrentUser.Id)
{
throw new NoAccessToPageException();
}
var model = new UserContactModel()
{
ModalMode = Request.IsAjaxRequest(),
ReturnUrl = Url.Action("Edit", new { id = contact.UserId.ToString() }),
Id = id,
UserId = contact.UserId,
Type = contact.Type,
Value = contact.Value
};
return(View(model));
}
public ActionResult EditContact(UserContactModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var repository = CurrentAccountDbContext.GetUserRepository();
var contact = repository.GetContactById(model.Id);
if (!CurrentUser.CanManageAccount() && contact.UserId != CurrentUser.Id)
{
throw new NoAccessToPageException();
}
repository.EditContactById(model.Id, model.Type, model.Value);
if (model.ModalMode)
{
return(PartialView("UserContactData", contact));
}
return(Redirect(model.ReturnUrl));
}
public ActionResult AddContact(UserContactModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var repository = CurrentAccountDbContext.GetUserRepository();
var userId = model.UserId;
var user = repository.GetById(userId);
if (!CurrentUser.CanManageAccount() && user.Id != CurrentUser.Id)
{
throw new NoAccessToPageException();
}
var contact = repository.AddContactToUser(user.Id, model.Type, model.Value, MvcApplication.GetServerDateTime());
if (model.ModalMode)
{
return(PartialView("UserContactRow", contact));
}
return(Redirect(model.ReturnUrl));
}
public async Task <IActionResult> AddUserContactById([FromBody] UserContactModel userContactModel)
{
User user = await GetUserAsync().ConfigureAwait(false);
if (await userManager.FindByIdAsync(userContactModel.ContactId.ToString()) == null)
{
return(BadRequest("No user with specified id found"));
}
try
{
userContactRepository.Add(new UserContact
{
OwnerId = user.Id,
ContactId = userContactModel.ContactId
});
return(Ok());
}
catch (ArgumentException e)
{
return(BadRequest(e.Message));
}
}
public bool ValidateContact(UserContactModel contact)
{
return(m_contactValidatorsDict[contact.Type].Validate(contact.Value));
}
/// <summary>
/// 1= Success, 0= Failed, 4= User Not Found
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public APIReturnModel SaveUserContacts(UserContactModel model)
{
try
{
UserContact contacts = new UserContact();
bool isupdate = false;
//Check user id is provided
if (!string.IsNullOrEmpty(model.UserId))
{
//Check user id exists in db
SystemUser chkexisting = Db.SystemUsers.FirstOrDefault(d => d.Id == model.UserId && !d.IsArchived);
if (chkexisting != null)
{
contacts = Db.UserContacts.FirstOrDefault(d => d.Id == model.Id);
if (contacts == null)
{
contacts = new UserContact
{
Id = Guid.NewGuid().ToString()
};
}
else
{
isupdate = true;
}
contacts.UserId = model.UserId;
contacts.ContactPhone = model.ContactPhone;
contacts.ContactName = model.ContactName;
contacts.ContactDescription = model.ContactDescription;
contacts.IsArchived = false;
if (!isupdate)
{
Db.UserContacts.Add(contacts);
}
Db.SaveChanges();
return(new APIReturnModel {
Status = 1, Value = contacts.Id
});
}
else
{
return new APIReturnModel {
Status = 4
}
};
}
else
{
return new APIReturnModel {
Status = 4
}
};
}
catch (Exception ex)
{
return(new APIReturnModel {
Status = 0
});
}
}
