private void HandleDbUpdateException(DbUpdateException ex)
{
throw new NotImplementedException();
}
public bool IsConstraintViolation(DbUpdateException dbUpdateException)
{
return(dbUpdateException?.InnerException is SqlException sqlException && (sqlException.Number == 2627 || sqlException.Number == 547 || sqlException.Number == 2601));
}
protected void OnDbUpdateException(DbUpdateException e)
{
Messenger?.Send(CommandName.ShowDbUpdateException, e);
}
public void DbUpdateException_exposes_public_string_constructor()
{
var ex = new DbUpdateException("Foo");
Assert.Equal("Foo", ex.Message);
}
public ReferenceConstraintException(string message, DbUpdateException inner)
: base(message, inner)
{
}
public static bool IsUniqueConstraintViolation(this DbUpdateException e,
IUniqueConstraintDetectionStrategy strategy)
{
return(strategy.IsUniqueConstraintViolation(e));
}
public UserViewModel Register(RegisterViewModel viewModel)
{
if (viewModel == null)
{
throw new ArgumentNullException(nameof(viewModel));
}
if (string.IsNullOrWhiteSpace(viewModel.Email))
{
throw new ArgumentException(nameof(viewModel));
}
if (string.IsNullOrWhiteSpace(viewModel.Password) || string.IsNullOrWhiteSpace(viewModel.PasswordConfirmation))
{
throw new ArgumentException(nameof(viewModel));
}
var duplicateUser = Repository.Where(x => x.Email == viewModel.Email).FirstOrDefault();
if (duplicateUser != null)
{
throw new DuplicateException("This user is dubplicate");
}
if (viewModel.Password != viewModel.PasswordConfirmation)
{
throw new PasswordMismatchException();
}
if (PasswordStrength.CheckStrength(viewModel.Password) < PasswordStrength.PasswordScore.Medium)
{
throw new WeakPasswordException();
}
if (!viewModel.HasAcceptedTerms)
{
throw new TermsNotAcceptedException();
}
var newUser = new User
{
UserId = Guid.NewGuid().ToString(),
FirstName = viewModel.FirstName,
LastName = viewModel.LastName,
Email = viewModel.Email,
LastLoggedIn = null,
DateCreated = DateTime.UtcNow,
PasswordHash = PasswordHash.HashPassword(viewModel.Password),
Role = "User"
};
try
{
Repository.Insert(newUser);
Repository.SaveChanges();
}
catch (DbUpdateException)
{
var ex = new DbUpdateException("Unable to save changes to the DB.");
ex.Data.Add("AddedUser", newUser);
throw ex;
}
return(new UserViewModel()
{
UserId = newUser.UserId,
Email = newUser.Email,
FirstName = newUser.FirstName,
LastName = newUser.LastName,
Role = newUser.Role
});
}
internal static string GetFormattedErrorMessage(this DbUpdateException dbUpdateException)
{
var stringBuilder = new StringBuilder();
var sqlException = dbUpdateException.InnerException?.InnerException as SqlException;
foreach (var entry in dbUpdateException.Entries)
{
stringBuilder.AppendLine(
$"Entity of type \"{entry.Entity.GetType().GetFormattedName()}\" in state \"{entry.State}\" has caused a DbUpdateException.");
if (entry.State == EntityState.Modified)
{
stringBuilder.AppendLine();
stringBuilder.AppendLine("Modified properties:");
foreach (var property in entry.GetProperties())
{
stringBuilder.AppendLine(
$"- ({(property.IsModified ? "X" : " ")}) {property.Name}: OriginalValue =\"{property.OriginalValue}\", CurrentValue=\"{property.CurrentValue}\"");
}
}
if (sqlException != null)
{
stringBuilder.AppendLine();
stringBuilder.AppendLine("SqlException Errors:");
foreach (SqlError sqlExceptionError in sqlException.Errors)
{
if (sqlExceptionError.Number == SqlStatementTerminationNumber)
{
continue;
}
stringBuilder.AppendLine($"-> Number {sqlExceptionError.Number}: {sqlExceptionError.Message}");
switch (sqlExceptionError.Number)
{
case 242:
stringBuilder.AppendLine(" Following properties may have cause the implications:");
foreach (string propertyName in entry.CurrentValues.PropertyNames)
{
var propertyInfo = entry.Entity.GetType().GetProperty(propertyName);
var propertyType = propertyInfo.PropertyType;
DateTime?propertyValue = null;
if (propertyType == typeof(DateTime?))
{
propertyValue = entry.CurrentValues.GetValue <DateTime?>(propertyName);
}
if (propertyType == typeof(DateTime))
{
propertyValue = entry.CurrentValues.GetValue <DateTime>(propertyName);
}
if (propertyValue.HasValue && !IsValidSqlServerDatetime(propertyValue.Value))
{
stringBuilder.AppendLine($" - Property: \"{propertyName}\", Type: {propertyType.GetFormattedName()}, Value: \"{propertyValue.Value}\"");
}
}
break;
case 547:
var relationshipSourceColumnName = GetSourceColumnName(sqlExceptionError.Message);
stringBuilder.AppendLine(" Following properties may have cause the implications:");
foreach (string propertyName in entry.CurrentValues.PropertyNames)
{
var propertyInfo = entry.Entity.GetType().GetProperty(propertyName);
var propertyType = propertyInfo.PropertyType;
var propertyValue = entry.CurrentValues.GetValue <object>(propertyName);
var isColumnPossiblyAffected = propertyName.Contains(relationshipSourceColumnName);
stringBuilder.AppendLine(
$" - ({(isColumnPossiblyAffected ? "X" : " ")}) {propertyName}: Type: {propertyType.GetFormattedName()}, Value: \"{propertyValue}\"");
}
stringBuilder.AppendLine(" This operation failed because another data entry uses this entry.");
break;
case 2601:
stringBuilder.AppendLine(" One of the properties is marked as Unique index and there is already an entry with that value.");
break;
}
}
}
}
string errorMessage = stringBuilder.ToString();
return(errorMessage);
}
protected virtual void ThrowEnhancedValidationException(DbUpdateException e)
{
throw new DbUpdateException(e.Message, e.InnerException);
}
public static string ExtractDetails(this DbUpdateException exception)
{
var dataNameProperty = "Detail";
return(Extract(exception, dataNameProperty));
}
public static string ExtractConstraints(this DbUpdateException exception)
{
var dataNameProperty = "ConstraintName";
return(Extract(exception, dataNameProperty));
}
private IActionResult HandleSqlException(DbUpdateException ex)
{
throw new NotImplementedException();
}
public Result HandleDatabaseException(DbUpdateException dbUpdateException, string propertyName)
{
return(DbUtil.HandleDatabaseException(dbUpdateException, propertyName));
}
public static Exception ReThrow <T>(Exception ex)
{
SqlException sqlEx = TryExtractException <SqlException>(ex);
DbUpdateException dbEx = TryExtractException <DbUpdateException>(ex);
if (sqlEx != null)
{
//string exMessage = sqlEx.Message;
string message = RepositoryResource.ErrorMessage_GeneralError;
ErrorTypeEnum error = ErrorTypeEnum.None;
string columnName = string.Empty;
string tableName = string.Empty;
string indexName = string.Empty;
MatchCollection coll;
switch (sqlEx.Number)
{
case (2):
case (53):
//_error = DataAccessErrorType.NetworkAddressNotFound;
break;
case (547):
//if (sqlEx.Message.Contains("DELETE"))
//{
// Match match = Regex.Match(sqlEx.Message, @"\'([^']*)\'");
// coll = Regex.Matches(sqlEx.Message, "\"[^\"]*\"");
// //if (match.Success)
// // columnName = match.Value.Substring(1, match.Value.Length - 2);
// if (coll.Count == 3)
// tableName = coll[2].Value.Substring(1, coll[2].Value.Length - 2);
//}
//error = ErrorTypeEnum.DeleteReferencedRecord;
//string tableNameCaption = ResourceManager.GetString(tableName.Replace('.', '_'));
//string entityNameCaption = typeof(T).Name;
//if (string.IsNullOrEmpty(tableNameCaption) || string.IsNullOrEmpty(entityNameCaption))
// message = RepositoryResource.ErrorMessage_GeneralDependency;
//else
// message = string.Format(RepositoryResource.ErrorMessage_TwoEntityDependency, tableNameCaption, entityNameCaption);
return(new BusinessRuleException(RepositoryResource.ErrorMessage_GeneralDependency, RepositoryResource.ErrorMessage_GeneralDependency, typeof(T).Name, sqlEx));
case (4060):
//error = ErrorTypeEnum.InvalidDatabase;
break;
case (18452):
case (18456):
error = ErrorTypeEnum.LoginFailed;
message = RepositoryResource.ErrorMessage_LogingFailed;
break;
case (10054):
//_error = DataAccessErrorType.ConnectionRefused;
break;
case (2627):
case (2601):
error = ErrorTypeEnum.DuplicateValue;
message = "يجب أن لا يتكرر الحقل الفريد";
break;
default:
break;
}
if (sqlEx.Class == 20)
{
error = ErrorTypeEnum.ConnectionFailed;
message = RepositoryResource.ErrorMessage_ConnectionFailed;
}
return(new RepositoryException(typeof(T).Name, error, message, ex));
}
else if (ex is InvalidOperationException)
{
return(new RepositoryException(typeof(T).Name, ErrorTypeEnum.None, ex.Message, ex));
}
else if (ex is DbUpdateConcurrencyException)
{
return(new RepositoryException(typeof(T).Name, ErrorTypeEnum.ConcurrencyCheckFailed, "تم تعديل الكائن من قبل مستخدم آخر, يرجى تحديث المستعرض والمحاولة مرة آخرى", ex));
}
else if (ex is ModelValidationException)
{
return(new RepositoryException(typeof(T).Name, ErrorTypeEnum.ValidationError, "يجب التأكد من أن قواعد التأكد من الصحة صحيحة", ex));
}
return(ex);
}
public HttpResponseMessage SaveChatMessage(ChatHistoryDTO message)
{
VolunteerMatchDbContext db = new VolunteerMatchDbContext();
try
{
//////////////////////////////////////////////////////////
/// TODO: ///
/// 1. CALCULATE DATETIME HERE ///
//////////////////////////////////////////////////////////
int datetime = (int)DateTimeOffset.Now.ToUnixTimeSeconds();
ChatHistory newMessage = new ChatHistory()
{
datetime = datetime,
fromMemberId = message.fromMemberId,
toMemberId = message.toMemberId,
text = message.text,
chatRoomId = message.chatRoomId
};
newMessage.markAsRead = false;
newMessage.meetingMsg = false;
newMessage.meetingUnixDate = 0;
if (message.meetingMsg)
{
newMessage.meetingMsg = true;
newMessage.meetingDateLabel = message.meetingDateLabel;
newMessage.meetingEventTitle = message.meetingEventTitle;
newMessage.meetingTimeLabel = message.meetingTimeLabel;
newMessage.meetingUnixDate = message.meetingUnixDate;
newMessage.meetingLocationLabel = message.meetingLocationLabel;
newMessage.text = "Meeting invitation";
}
db.ChatHistories.Add(newMessage);
db.SaveChanges();
return(Request.CreateResponse(HttpStatusCode.OK, "Message saved in DB"));
}
catch (DbEntityValidationException ex)
{
string errors = "";
foreach (DbEntityValidationResult vr in ex.EntityValidationErrors)
{
foreach (DbValidationError er in vr.ValidationErrors)
{
errors += $"PropertyName - {er.PropertyName }, Error {er.ErrorMessage} <br/>";
}
}
return(Request.CreateResponse(HttpStatusCode.BadRequest, errors));
}
catch (DbUpdateException ex)
{
DbUpdateException e = (DbUpdateException)ex;
string errors = "";
foreach (DbEntityEntry entry in e.Entries)
{
errors += $"Error in entity - {entry.Entity.GetType().Name}, entity state - {entry.State} <br/>";
foreach (string prop in entry.CurrentValues.PropertyNames)
{
errors += $"for column - {prop}, value - {entry.CurrentValues[prop]} <br/>";
}
errors += "---------------";
}
return(Request.CreateResponse(HttpStatusCode.BadRequest, errors));
}
catch (Exception ex)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, ex.Message));
}
}
public bool IsUniqueConstraintViolation(DbUpdateException exception)
{
return(exception.InnerException?.Message?.IndexOf("unique", StringComparison.OrdinalIgnoreCase) >= 0);
}
public HttpResponseMessage getRoomChats(int memberId)
{
VolunteerMatchDbContext db = new VolunteerMatchDbContext();
try
{
var allChatRoomsId = db.ChatHistories.Where(x => x.fromMemberId == memberId || x.toMemberId == memberId).Select(y => y.chatRoomId).ToList();
List <int> relevantChatRoomsId = new List <int>();
List <ChatRoomDTO> chatRooms = new List <ChatRoomDTO>();
foreach (int chatRoomId in allChatRoomsId)
{
if (!relevantChatRoomsId.Contains(chatRoomId))
{
relevantChatRoomsId.Add(chatRoomId);
}
}
foreach (var chatRoomId in relevantChatRoomsId)
{
int firstMemberId = (int)db.ChatHistories.Where(x => x.chatRoomId == chatRoomId).Select(y => y.fromMemberId).FirstOrDefault();
int SecondMemberId = (int)db.ChatHistories.Where(x => x.chatRoomId == chatRoomId).Select(y => y.toMemberId).FirstOrDefault();
int otherMemberId;
if (firstMemberId == memberId)
{
otherMemberId = SecondMemberId;
}
else
{
otherMemberId = firstMemberId;
};
string otherMemberName = db.Members.Where(x => x.id == otherMemberId).Select(y => y.fullName).FirstOrDefault();
string otherMemberImage = db.Members.Where(x => x.id == otherMemberId).Select(y => y.pictureUrl).FirstOrDefault();
ChatHistory chatHistory = new ChatHistory();
//CHECK IF CAN BE OPTIMIZED
var chat = db.ChatHistories.Where(x => x.chatRoomId == chatRoomId).Select(y => y.text).ToList();
var chatDate = db.ChatHistories.Where(x => x.chatRoomId == chatRoomId).Select(y => y.datetime).ToList();
int numOfMassages = chat.Count();
string lastSentence = chat[numOfMassages - 1];
var chatIds = db.ChatHistories.Where(x => x.chatRoomId == chatRoomId).Select(y => y.fromMemberId).ToList();
int lastMessageSenderId = (int)chatIds[numOfMassages - 1];
var messageMarkAsReadList = db.ChatHistories.Where(x => x.chatRoomId == chatRoomId).Select(y => y.markAsRead).ToList();
bool lastMessageMarkedAsRead = (bool)messageMarkAsReadList[numOfMassages - 1];
int lastUnixDate = (int)chatDate[numOfMassages - 1];
DateTime dtDateTime = new DateTime(1970, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc);
dtDateTime = dtDateTime.AddSeconds(lastUnixDate).ToLocalTime();
//Checking if last massage was sent over the last 24 hrs
string lastDate;
DateTime now = DateTime.Now;
if (dtDateTime > now.AddHours(-24) && dtDateTime <= now)
{
decimal hours = Math.Floor((decimal)(now - dtDateTime).TotalHours);
int hoursDiffInt = (int)hours;
if (hoursDiffInt == 0)
{
lastDate = (now - dtDateTime).Minutes.ToString();
if (lastDate == "0")
{
lastDate = "Now";
}
else
{
lastDate += " min ago";
}
}
else
{
lastDate = $"{hoursDiffInt}h ago";
}
}
else
{
string year = dtDateTime.Year.ToString();
string month = dtDateTime.Month.ToString();
string day = dtDateTime.Day.ToString();
lastDate = $"{day}/{month}/{year}";
};
ChatRoomDTO chatRoomDTO = new ChatRoomDTO()
{
chatRoomId = chatRoomId,
otherMemberId = otherMemberId,
otherMemberName = otherMemberName,
otherMemberImage = otherMemberImage,
latstSentence = lastSentence,
lastDate = lastDate,
lastMessageSenderId = lastMessageSenderId,
lastMessageMarkedAsRead = lastMessageMarkedAsRead,
lastUnixDate = lastUnixDate
};
chatRooms.Add(chatRoomDTO);
}
List <ChatRoomDTO> SortedList = chatRooms.OrderByDescending(o => o.lastUnixDate).ToList();
return(Request.CreateResponse(HttpStatusCode.OK, SortedList));
}
catch (DbEntityValidationException ex)
{
string errors = "";
foreach (DbEntityValidationResult vr in ex.EntityValidationErrors)
{
foreach (DbValidationError er in vr.ValidationErrors)
{
errors += $"PropertyName - {er.PropertyName }, Error {er.ErrorMessage} <br/>";
}
}
return(Request.CreateResponse(HttpStatusCode.BadRequest, errors));
}
catch (DbUpdateException ex)
{
DbUpdateException e = (DbUpdateException)ex;
string errors = "";
foreach (DbEntityEntry entry in e.Entries)
{
errors += $"Error in entity - {entry.Entity.GetType().Name}, entity state - {entry.State} <br/>";
foreach (string prop in entry.CurrentValues.PropertyNames)
{
errors += $"for column - {prop}, value - {entry.CurrentValues[prop]} <br/>";
}
errors += "---------------";
}
return(Request.CreateResponse(HttpStatusCode.BadRequest, errors));
}
catch (Exception ex)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, ex.Message));
}
}
public bool HasUniqueConstraintViolation(DbUpdateException ex)
{
SqlException sex = ex.GetOriginalException <SqlException>();
return(sex?.Errors?.Cast <SqlError>()?.Any(e => e.Number == 2627) ?? false);
}
private static void EvaluateExeption(ILogger logger, IEnumerable <LogCategory> logCategories, string methodName, DbUpdateException dbu_ex)
{
if (dbu_ex.Entries != null)
{
foreach (DbEntityEntry result in dbu_ex.Entries.Where(f => f.Entity != null))
{
logger.WriteWarning(new LogMessage(string.Concat("Type: ", result.Entity.GetType().Name, " was part of the problem")), logCategories);
}
}
if (dbu_ex.InnerException != null && dbu_ex.InnerException is UpdateException)
{
EvaluateExeption(logger, logCategories, methodName, dbu_ex.InnerException as UpdateException);
}
logger.WriteError(dbu_ex, logCategories);
throw new DSWException(string.Concat(methodName, ".UpdateException -> ", dbu_ex.Message), dbu_ex, DSWExceptionCode.DB_EntityStateError);
}
public override bool IsUniqueConstraintViolationException(DbUpdateException exception)
{
return(exception.InnerException is MySqlException mysqlException &&
mysqlException.Number == UniqueConstraintViolationErrorCode);
}
public void GetEntry_throws_if_the_DbUpdateException_contains_null_context()
{
var ex = new DbUpdateException("", new UpdateException());
Assert.Null(ex.Entries.SingleOrDefault());
}
protected void getMessageDbUpdateException(DbUpdateException ex)
{
throw new Exception(ex.InnerException.InnerException.Message);
}
public ReferenceConstraintException(DbUpdateException inner) : base(defaultMessage, inner)
{
}
public HttpResponseMessage AddMeetingSkipped(int memberId)
{
VolunteerMatchDbContext db = new VolunteerMatchDbContext();
try
{
Member member = db.Members.Where(x => x.id == memberId).FirstOrDefault();
if (member.numMeetingsSkipped >= 2)
{
//TO ADD:
// MAIL THAT ACCOUNT IS BLOCKED SINCE SKIPPED 3 MEETINGS
//DELETE MEMBER FROM DB
member.numMeetingsSkipped += 1;
db.SaveChanges();
return(Request.CreateResponse(HttpStatusCode.OK, "Member account is now blocked - deleted from db and sent pdf to mail with details"));
}
else if (member.numMeetingsSkipped == null)
{
member.numMeetingsSkipped = 1;
}
else
{
member.numMeetingsSkipped += 1;
}
db.SaveChanges();
return(Request.CreateResponse(HttpStatusCode.OK, "One skipped meeting was added "));
}
catch (DbEntityValidationException ex)
{
string errors = "";
foreach (DbEntityValidationResult vr in ex.EntityValidationErrors)
{
foreach (DbValidationError er in vr.ValidationErrors)
{
errors += $"PropertyName - {er.PropertyName }, Error {er.ErrorMessage} <br/>";
}
}
return(Request.CreateResponse(HttpStatusCode.BadRequest, errors));
}
catch (DbUpdateException ex)
{
DbUpdateException e = (DbUpdateException)ex;
string errors = "";
foreach (DbEntityEntry entry in e.Entries)
{
errors += $"Error in entity - {entry.Entity.GetType().Name}, entity state - {entry.State} <br/>";
foreach (string prop in entry.CurrentValues.PropertyNames)
{
errors += $"for column - {prop}, value - {entry.CurrentValues[prop]} <br/>";
}
errors += "---------------";
}
return(Request.CreateResponse(HttpStatusCode.BadRequest, errors));
}
catch (Exception ex)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, ex.Message));
}
}
public abstract bool IsUniqueConstraintViolationException(DbUpdateException exception);
public HttpResponseMessage Register(MemberSignupDTO memberSignupDTO)
{
VolunteerMatchDbContext db = new VolunteerMatchDbContext();
try
{
Member member = new Member();
member.email = memberSignupDTO.email;
member.city = memberSignupDTO.city;
member.password = memberSignupDTO.password;
member.fullName = memberSignupDTO.fullName;
member.pictureUrl = memberSignupDTO.pictureUrl;
member.occupation = memberSignupDTO.occupation;
member.gender = memberSignupDTO.gender;
member.biography = memberSignupDTO.bio;
member.dateOfBirth = memberSignupDTO.dateOfBirth;
member.lastLocationLat = 0;
member.lastLocationLong = 0;
db.Members.Add(member);
db.SaveChanges();
FeedSetting feedSetting = new FeedSetting
{
memberId = member.id,
memberType = memberSignupDTO.feedSettings.memberType,
participantAgeRange = memberSignupDTO.feedSettings.participantAgeRange,
participantGender = memberSignupDTO.feedSettings.participantGender,
postLocation = memberSignupDTO.feedSettings.postLocation
};
db.FeedSettings.Add(feedSetting);
foreach (HobbiesDTO hobby in memberSignupDTO.hobbies)
{
MembersHobby hobbies = new MembersHobby();
hobbies.hobbyId = hobby.id;
hobbies.memberId = member.id;
db.MembersHobbies.Add(hobbies);
}
db.SaveChanges();
AuthorizedMemberDetailsDTO authorizedMemberDetailsDTO = new AuthorizedMemberDetailsDTO()
{
id = member.id,
name = member.fullName,
participantAge = memberSignupDTO.feedSettings.participantAgeRange,
participantGender = memberSignupDTO.feedSettings.participantGender,
helpType = memberSignupDTO.feedSettings.memberType,
meetingLocation = memberSignupDTO.feedSettings.postLocation,
pictureUrl = member.pictureUrl
};
return(Request.CreateResponse(HttpStatusCode.OK, authorizedMemberDetailsDTO));
}
catch (DbEntityValidationException ex)
{
string errors = "";
foreach (DbEntityValidationResult vr in ex.EntityValidationErrors)
{
foreach (DbValidationError er in vr.ValidationErrors)
{
errors += $"PropertyName - {er.PropertyName }, Error {er.ErrorMessage} <br/>";
}
}
return(Request.CreateResponse(HttpStatusCode.BadRequest, errors));
}
catch (DbUpdateException ex)
{
DbUpdateException e = (DbUpdateException)ex;
string errors = "";
foreach (DbEntityEntry entry in e.Entries)
{
errors += $"Error in entity - {entry.Entity.GetType().Name}, entity state - {entry.State} <br/>";
foreach (string prop in entry.CurrentValues.PropertyNames)
{
errors += $"for column - {prop}, value - {entry.CurrentValues[prop]} <br/>";
}
errors += "---------------";
}
return(Request.CreateResponse(HttpStatusCode.BadRequest, errors));
}
catch (Exception ex)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, ex.Message));
}
}
public EFRepositoryUpdateException(DbUpdateException dbUpEx) : base(dbUpEx.Message, dbUpEx)
{
}
public HttpResponseMessage UpdateProfile(ProfileDetailsDTO profileDetailsDTO, int userId)
{
VolunteerMatchDbContext db = new VolunteerMatchDbContext();
Member member = db.Members.Where(x => x.id == userId).FirstOrDefault();
try
{
if (profileDetailsDTO.unixDate == null)
{
member.city = profileDetailsDTO.city;
member.biography = profileDetailsDTO.bio;
member.occupation = profileDetailsDTO.occupation;
member.gender = profileDetailsDTO.gender;
member.pictureUrl = profileDetailsDTO.pictureUrl;
}
else
{
member.city = profileDetailsDTO.city;
member.biography = profileDetailsDTO.bio;
member.occupation = profileDetailsDTO.occupation;
member.gender = profileDetailsDTO.gender;
member.pictureUrl = profileDetailsDTO.pictureUrl;
member.dateOfBirth = profileDetailsDTO.unixDate;
}
if (profileDetailsDTO.hobbies != null)
{
foreach (MembersHobby hobby in db.MembersHobbies.Where(x => x.memberId == userId))
{
MembersHobby membersHobby = hobby;
db.MembersHobbies.Remove(membersHobby);
}
foreach (HobbiesDTO hobby in profileDetailsDTO.hobbies)
{
MembersHobby hobbies = new MembersHobby();
hobbies.hobbyId = hobby.id;
hobbies.memberId = member.id;
db.MembersHobbies.Add(hobbies);
}
}
db.SaveChanges();
}
catch (DbEntityValidationException ex)
{
string errors = "";
foreach (DbEntityValidationResult vr in ex.EntityValidationErrors)
{
foreach (DbValidationError er in vr.ValidationErrors)
{
errors += $"PropertyName - {er.PropertyName }, Error {er.ErrorMessage} <br/>";
}
}
return(Request.CreateResponse(HttpStatusCode.BadRequest, errors));
}
catch (DbUpdateException ex)
{
DbUpdateException e = (DbUpdateException)ex;
string errors = "";
foreach (DbEntityEntry entry in e.Entries)
{
errors += $"Error in entity - {entry.Entity.GetType().Name}, entity state - {entry.State} <br/>";
foreach (string prop in entry.CurrentValues.PropertyNames)
{
errors += $"for column - {prop}, value - {entry.CurrentValues[prop]} <br/>";
}
errors += "---------------";
}
return(Request.CreateResponse(HttpStatusCode.BadRequest, errors));
}
catch (Exception ex)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, ex.Message));
}
return(Request.CreateResponse(HttpStatusCode.OK, "Profile updated successfully"));
}
private string GetErrorText(DbUpdateException dbEx) => dbEx.Message;
public ViolationOfConstraintException(string message, DbUpdateException inner)
: base(message, inner)
{
}
