public void InviteUser_Given_MeetingAttendee_With_Email_ReturnTrue() { var availabilityRepository = Substitute.For <IMinutzAvailabilityRepository>(); var attendeeRepository = Substitute.For <IMinutzAttendeeRepository>(); var userRepository = Substitute.For <IUserRepository>(); var applicationSetting = Substitute.For <IApplicationSetting>(); var restAuthUser = new AuthRestModel { InstanceId = Guid.NewGuid().ToString(), Email = "*****@*****.**" }; userRepository.CheckIfNewUser("foo", "foo", "foo", "foo", "foo").ReturnsForAnyArgs(new MessageBase { Condition = true, Code = 4 }); var attendee = new MeetingAttendee { Email = "*****@*****.**" }; var meeting = new Meeting { Name = "Foo", Id = Guid.NewGuid() }; var service = new InvitationService(_emailValidationService, availabilityRepository, attendeeRepository, userRepository, applicationSetting); var result = service.InviteUser(restAuthUser, attendee, meeting); Assert.IsTrue(result.Condition); }
//[Test] public void InviteUser_Given_Attendee_And_Meeting_IEmailValidationService_IsCalled() { var availabilityRepository = Substitute.For <IMinutzAvailabilityRepository>(); var attendeeRepository = Substitute.For <IMinutzAttendeeRepository>(); var userRepository = Substitute.For <IUserRepository>(); var applicationSetting = Substitute.For <IApplicationSetting>(); var restAuthUser = new AuthRestModel { InstanceId = Guid.NewGuid().ToString(), Email = "*****@*****.**" }; Mock <IEmailValidationService> _emailValidationService = new Mock <IEmailValidationService>(); _emailValidationService.Setup(x => x.Valid(It.IsAny <string>()).Returns(true)); var attendee = new MeetingAttendee { Email = "*****@*****.**" }; var meeting = new Meeting { Name = "Foo", Id = Guid.NewGuid() }; var service = new InvitationService(_emailValidationService.Object, availabilityRepository, attendeeRepository, userRepository, applicationSetting); service.InviteUser(restAuthUser, attendee, meeting); _emailValidationService.Verify(x => x.Valid("*****@*****.**"), Times.AtLeastOnce); }
public async Task <IActionResult> Edit(long id, [Bind("MeetingId,AttendeeId")] MeetingAttendee meetingAttendee) { if (id != meetingAttendee.AttendeeId) { return(NotFound()); } if (ModelState.IsValid) { try { _context.Update(meetingAttendee); await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!MeetingAttendeeExists(meetingAttendee.AttendeeId)) { return(NotFound()); } else { throw; } } return(RedirectToAction(nameof(Index))); } ViewData["AttendeeId"] = new SelectList(_context.Members, "Id", "Id", meetingAttendee.AttendeeId); ViewData["MeetingId"] = new SelectList(_context.Meetings, "Id", "Id", meetingAttendee.MeetingId); return(View(meetingAttendee)); }
public IActionResult AddMeetingAttendeeResult([FromBody] MeetingAttendee attendee) { var userInfo = User.ToRest(); var result = _minutzAttendeeService.AddAttendee(attendee.ReferenceId, attendee, userInfo); return(result.Condition ? Ok(result.Attendees) : StatusCode(result.Code, result.Message)); }
public AttendeeMessage UpdateAttendee(Guid meetingId, MeetingAttendee attendee, AuthRestModel user) { var instanceConnectionString = _applicationSetting.CreateConnectionString(_applicationSetting.Server, _applicationSetting.Catalogue, user.InstanceId, _applicationSetting.GetInstancePassword(user.InstanceId)); return(_minutzAttendeeRepository.UpdateAttendee(meetingId, attendee, user.InstanceId, instanceConnectionString)); }
public void InvalidNamesAreNotParsedOrChanged(string incomingName) { MeetingAttendee testee = new MeetingAttendee(); testee.CurrentTechnicalName = incomingName; Assert.AreEqual(incomingName, testee.Name); Assert.AreEqual(1, testee.NumberOfPersons); }
public void NameWithPreendedNumberIsParsed(string incomingName, string expectedName, int expectedNum) { MeetingAttendee testee = new MeetingAttendee(); testee.CurrentTechnicalName = incomingName; Assert.AreEqual(expectedName, testee.Name); Assert.AreEqual(expectedNum, testee.NumberOfPersons); }
public virtual void Update(MeetingViewModel meeting, ModelStateDictionary modelState) { if (ValidateModel(meeting, modelState)) { if (string.IsNullOrEmpty(meeting.Title)) { meeting.Title = ""; } var entity = meeting.ToEntity(); db.Meetings.Attach(entity); db.Entry(entity).State = EntityState.Modified; var oldMeeting = db.Meetings .Include(model => model.MeetingAttendees) .FirstOrDefault(m => m.MeetingID == meeting.MeetingID); foreach (var attendee in oldMeeting.MeetingAttendees.ToList()) { db.MeetingAttendees.Attach(attendee); if (meeting.Attendees == null || !meeting.Attendees.Contains(attendee.AttendeeID)) { db.Entry(attendee).State = EntityState.Deleted; } else { db.Entry(attendee).State = EntityState.Unchanged; ((List <int>)meeting.Attendees).Remove(attendee.AttendeeID); } entity.MeetingAttendees.Add(attendee); } if (meeting.Attendees != null) { foreach (var attendeeId in meeting.Attendees) { var meetingAttendee = new MeetingAttendee { MeetingID = entity.MeetingID, AttendeeID = attendeeId }; db.MeetingAttendees.Attach(meetingAttendee); db.Entry(meetingAttendee).State = EntityState.Added; entity.MeetingAttendees.Add(meetingAttendee); } } db.SaveChanges(); } }
public async Task <IActionResult> Create([Bind("MeetingId,AttendeeId")] MeetingAttendee meetingAttendee) { if (ModelState.IsValid) { _context.Add(meetingAttendee); await _context.SaveChangesAsync(); return(RedirectToAction(nameof(Index))); } ViewData["AttendeeId"] = new SelectList(_context.Members, "Id", "Id", meetingAttendee.AttendeeId); ViewData["MeetingId"] = new SelectList(_context.Meetings, "Id", "Id", meetingAttendee.MeetingId); return(View(meetingAttendee)); }
private string GetImageNameFromAttendee(MeetingAttendee attendee) { if (attendee.IsPhone) { return("call"); } if (attendee.IsHost || attendee.IsCoHost) { return("star"); } return("desktop"); }
public MessageBase SendMeetingMinutes(MeetingAttendee attendee, Meeting meeting, string instanceId) { var to = new EmailAddress(attendee.Email, attendee.Name); var result = new SendGridClient(_notify.NotifyKey) .SendEmailAsync(CreateMinutesMessage(to, _invitationSubject, meeting.Location, meeting.Id.ToString(), meeting.Name, instanceId)).Result; if (result.StatusCode == HttpStatusCode.OK || result.StatusCode == HttpStatusCode.Accepted) { return(new MessageBase { Condition = true, Message = result.Body.ReadAsStringAsync().Result, Code = 200 }); } return(new MessageBase { Condition = false, Message = "There was a issue with sending the email invitation.", Code = 500 }); }
public bool Update (MeetingAttendee attendee, string schema, string connectionString, string masterConnectionString) { try { bool result; using (IDbConnection dbConnection = new SqlConnection(connectionString)) { dbConnection.Open(); string updateQuery = $@"UPDATE [{schema}].[MeetingAttendee] SET Referanceid = '{attendee.ReferenceId.ToString()}', PersonIdentity = '{attendee.PersonIdentity}', Role = '{attendee.Role}', Status = '{attendee.Status}' WHERE Id = '{attendee.Id}' "; var instance = dbConnection.Execute(updateQuery); result = (instance == 1); } using (IDbConnection dbConnection = new SqlConnection(masterConnectionString)) { if (attendee.Company == null) { attendee.Company = string.Empty; } if (attendee.Department == null) { attendee.Department = string.Empty; } dbConnection.Open(); string personUpdateQuery = $@"UPDATE [app].[Person] SET Company = '{attendee.Company}', Department = '{attendee.Department}' WHERE Email = '{attendee.Email}' "; var instance = dbConnection.Execute(personUpdateQuery); result = (instance == 1); } return(result); } catch (Exception e) { Console.WriteLine(e.Message); return(false); } }
public virtual void Update(MeetingViewModel meeting, ModelStateDictionary modelState) { if (ValidateModel(meeting, modelState)) { if (string.IsNullOrEmpty(meeting.Title)) { meeting.Title = ""; } var entity = db.Meetings.Include(model => model.MeetingAttendees).FirstOrDefault(m => m.MeetingID == meeting.MeetingID); entity.Title = meeting.Title; entity.Start = meeting.Start; entity.End = meeting.End; entity.Description = meeting.Description; entity.IsAllDay = meeting.IsAllDay; entity.RoomID = meeting.RoomID; entity.RecurrenceID = meeting.RecurrenceID; entity.RecurrenceRule = meeting.RecurrenceRule; entity.RecurrenceException = meeting.RecurrenceException; entity.StartTimezone = meeting.StartTimezone; entity.EndTimezone = meeting.EndTimezone; foreach (var meetingAttendee in entity.MeetingAttendees.ToList()) { entity.MeetingAttendees.Remove(meetingAttendee); } if (meeting.Attendees != null) { foreach (var attendeeId in meeting.Attendees) { var meetingAttendee = new MeetingAttendee { MeetingID = entity.MeetingID, AttendeeID = attendeeId }; entity.MeetingAttendees.Add(meetingAttendee); } } db.SaveChanges(); } }
public bool AddInvitee (MeetingAttendee attendee, string schema, string connectionString, string defaultConnectionString, string defaultSchema, string referenceMeetingId, string inviteEmail) { using (IDbConnection dbConnection = new SqlConnection(connectionString)) { //string reference = $"invite|{schema}&{referenceMeetingId}"; // if (attendee.Id != Guid.Empty) { // attendee.Id = Guid.NewGuid (); // } dbConnection.Open(); string insertSql = $@"insert into [{schema}].[AvailibleAttendee]( [Id] ,[ReferanceId] ,[PersonIdentity] ,[Email] ,[Status] ,[Role] ) values( @Id ,@ReferenceId ,@PersonIdentity ,@Email ,@Status ,@Role )"; try { var instance = dbConnection.Execute(insertSql, new { attendee.Id, attendee.ReferenceId, attendee.PersonIdentity, Email = inviteEmail, attendee.Status, attendee.Role }); return(instance == 1); } catch (Exception e) { Console.WriteLine(e.Message); return(false); } } }
public bool Add (MeetingAttendee attendee, string schema, string connectionString) { using (IDbConnection dbConnection = new SqlConnection(connectionString)) { if (attendee.Id != Guid.Empty) { attendee.Id = Guid.NewGuid(); } dbConnection.Open(); string insertSql = $@"insert into [{schema}].[MeetingAttendee]( [Id] ,[ReferanceId] ,[PersonIdentity] ,[Email] ,[Role] ,[Status] ) values( @Id ,@ReferenceId ,@PersonIdentity ,@Email ,@Role ,@Status )"; try { var instance = dbConnection.Execute(insertSql, new { attendee.Id, attendee.ReferenceId, attendee.PersonIdentity, attendee.Email, attendee.Role, attendee.Status }); return(instance == 1); } catch (Exception e) { _logService.Log(LogLevel.Exception, $"Add Meeting Attendee: {e.InnerException.Message}"); return(false); } } }
public AttendeeMessage CreateAvailableAttendee(MeetingAttendee attendee, string schema, string connectionString) { if (string.IsNullOrEmpty(schema) || string.IsNullOrEmpty(connectionString)) { throw new ArgumentException("Please provide a valid agenda identifier, schema or connection string."); } try { using (IDbConnection masterDbConnection = new SqlConnection(connectionString)) { masterDbConnection.Open(); var id = Guid.NewGuid(); var insertQuery = $@"INSERT INTO [{schema}].[AvailibleAttendee] (Id, ReferanceId, PersonIdentity, Email, Status, Role) VALUES('{id}', '{attendee.ReferenceId}', '{attendee.Email}', '{attendee.Email}', '{attendee.Status}', '{attendee.Role}')" ; var insertData = masterDbConnection.Execute(insertQuery); if (insertData == 1) { attendee.Id = id; return(new AttendeeMessage { Condition = true, Message = "Successful", Code = 200, Attendee = attendee }); } return(new AttendeeMessage { Condition = false, Message = $"The available attendee {attendee.Email} could not be added.", Code = 500 }); } } catch (Exception e) { Console.WriteLine(e); return(new AttendeeMessage { Code = 500, Condition = false, Message = e.Message }); } }
/// <summary> /// Add an attendee into the database /// </summary> /// <param name="meetingId"></param> /// <param name="attendee">Full attendee entity</param> /// <param name="schema">Current instance id</param> /// <param name="connectionString">Full connection string for instance</param> /// <returns>Attendee Message with the attendee</returns> /// <exception cref="ArgumentException"></exception> public AttendeeMessage AddAttendee(Guid meetingId, MeetingAttendee attendee, string schema, string connectionString) { if (meetingId == Guid.Empty || string.IsNullOrEmpty(schema) || string.IsNullOrEmpty(connectionString)) { throw new ArgumentException("Please provide a valid agenda identifier, schema or connection string."); } try { using (IDbConnection dbConnection = new SqlConnection(connectionString)) { dbConnection.Open(); var insertSql = $@"INSERT INTO [{schema}].[MeetingAttendee] ([Id],[ReferanceId],[PersonIdentity],[Email],[Role],[Status]) VALUES ('{attendee.Id}','{meetingId}','{attendee.PersonIdentity}','{attendee.Email}','{attendee.Role}','{attendee.Status}') "; var data = dbConnection.Execute(insertSql); return(data == 1 ? new AttendeeMessage { Code = 200, Condition = true, Message = "Success", Attendee = attendee } : new AttendeeMessage { Code = 404, Condition = false, Message = "Could not insert attendee." }); } } catch (Exception e) { Console.WriteLine(e); return(new AttendeeMessage { Code = 500, Condition = false, Message = e.Message }); } }
public MeetingVM Update(MeetingVM meetingVM) { var meeting = _meetingRepo.GetAll().FirstOrDefault(m => m.ID == meetingVM.ID); if (meeting != null) { var attendees = _meetAttendeeRepo.GetAll().Where(ma => ma.MeetingID == meeting.ID).ToList(); if (attendees != null && attendees.Count > 0) { foreach (var attendee in attendees) { _meetAttendeeRepo.Delete(attendee.ID); } } meeting.Subject = meetingVM.Subject; meeting.MeetingAgenda = meetingVM.MeetingAgenda; meeting.MeetingDateTime = meetingVM.MeetingDateTime; meeting.Attendees = null; _meetingRepo.Update(meeting); if (meetingVM.Attendees != null && meetingVM.Attendees.Count > 0) { foreach (var attendeeVM in meetingVM.Attendees) { var attendee = new MeetingAttendee() { AttendeeID = attendeeVM.ID, MeetingID = meeting.ID }; _meetAttendeeRepo.Create(attendee); } } return(meetingVM); } return(null); }
public void InviteUser_Given_MeetingAttendee_With_InvalidEmail_ReturnFalse() { var availabilityRepository = Substitute.For <IMinutzAvailabilityRepository>(); var attendeeRepository = Substitute.For <IMinutzAttendeeRepository>(); var userRepository = Substitute.For <IUserRepository>(); var applicationSetting = Substitute.For <IApplicationSetting>(); var restAuthUser = new AuthRestModel { InstanceId = Guid.NewGuid().ToString(), Email = "*****@*****.**" }; var attendee = new MeetingAttendee { Email = "foo" }; var meeting = new Meeting { Name = "Foo", Id = Guid.NewGuid() }; var service = new InvitationService(_emailValidationService, availabilityRepository, attendeeRepository, userRepository, applicationSetting); var result = service.InviteUser(restAuthUser, attendee, meeting); Assert.IsFalse(result.Condition); }
public static InviteValidateResult Validate(this MeetingAttendee model) { if (model.ReferenceId == Guid.Empty) { return(new InviteValidateResult { Message = "Please provide a valid meetingId", Condition = false }); } if (string.IsNullOrEmpty(model.Email)) { return(new InviteValidateResult { Message = "Please provide a valid email address", Condition = false }); } return(string.IsNullOrEmpty(model.Name) ? new InviteValidateResult { Message = "Please provide a valid name.", Condition = false } : new InviteValidateResult { Condition = true, Message = "Valid" }); }
/// <summary> /// Parses the specified XML. /// </summary> /// <param name="xml">The XML.</param> /// <returns>Meeting Item or null if it's a folder.</returns> public static MeetingAttendee Parse(XmlNode xml, bool returnCurrentUsers) { if (xml == null || xml.Attributes == null) { return(null); } try { var item = new MeetingAttendee { TranscriptId = xml.SelectAttributeValue("transcript-id"), ScoId = xml.SelectAttributeValue("sco-id"), PrincipalId = xml.SelectAttributeValue("principal-id"), AssetId = xml.SelectAttributeValue("asset-id"), Login = xml.SelectSingleNodeValue("login/text()"), SessionName = xml.SelectSingleNodeValue("session-name/text()"), ScoName = xml.SelectSingleNodeValue("sco-name/text()"), ParticipantName = xml.SelectSingleNodeValue("participant-name/text()"), DateCreated = xml.ParseNodeDateTime("date-created/text()", default(DateTime)), DateEnd = xml.ParseNodeDateTime("date-end/text()", default(DateTime)), }; item.Duration = item.DateEnd.Subtract(item.DateCreated); if (!item.DateCreated.Equals(default(DateTime)) && (returnCurrentUsers || !item.DateEnd.Equals(default(DateTime)))) { return(item); } } catch (Exception ex) { TraceTool.TraceException(ex); } return(null); }
public bool AddAvailibleAttendee (MeetingAttendee attendee, string schema, string connectionString) { using (IDbConnection dbConnection = new SqlConnection(connectionString)) { if (attendee.Id != Guid.Empty) { attendee.Id = Guid.NewGuid(); } dbConnection.Open(); string insertSql = $@"insert into [{schema}].[AvailibleAttendee]( [Id] ,[ReferanceId] ,[PersonIdentity] ,[Email] ,[Status] ,[Role] ) values( @Id ,@ReferenceId ,@PersonIdentity ,@Email ,@Status ,@Role )"; var instance = dbConnection.Execute(insertSql, new { attendee.Id, attendee.ReferenceId, attendee.PersonIdentity, attendee.Email, attendee.Status, attendee.Role }); return(instance == 1); } }
public IActionResult InviteAttendeeResult([FromBody] MeetingAttendee attendee) { var userInfo = User.ToRest(); var validate = attendee.Validate(); if (!validate.Condition) { return(new BadRequestObjectResult(validate.Message)); } attendee.PersonIdentity = attendee.Email; attendee.Role = "Invited"; attendee.Status = "Invited"; var meeting = _getMeetingService.GetMeeting(userInfo.InstanceId, attendee.ReferenceId); if (!meeting.Condition) { return(BadRequest("There was a issue getting the meeting information.")); } var inviteRecords = _invitationService.InviteUser(userInfo, attendee, meeting.Meeting); if (!inviteRecords.Condition) { return(StatusCode(inviteRecords.Code, inviteRecords.Message)); } var notificationResult = _notificationService.SendMeetingInvitation(attendee, meeting.Meeting, userInfo.InstanceId); if (notificationResult.Condition) { return(Ok()); } return(StatusCode(notificationResult.Code, notificationResult.Message)); }
public void TestSendNotification() { var Id = Guid.NewGuid(); var meeting = new Meeting { Id = Id, Name = "Unit Test Email" }; var attendee = new MeetingAttendee { ReferenceId = Id, Email = "*****@*****.**", Name = "Lee-Roy Ashworth" }; var notify = new Notify(); var service = new NotificationService(notify); //var not = new StartupService(notify); var mail = service.SendMeetingInvitation(attendee, meeting, Id.ToString()); Assert.True(true); }
public ACSessionParticipantDto(MeetingAttendee source, TimeZoneInfo timeZone) { if (source == null) { throw new ArgumentNullException(nameof(source)); } if (timeZone == null) { throw new ArgumentNullException(nameof(timeZone)); } participantName = string.IsNullOrEmpty(source.ParticipantName) ? source.SessionName : source.ParticipantName; //guests have only sessionName sessionName = source.SessionName; login = source.Login; dateTimeEntered = FixACValue(source.DateCreated, timeZone).Value; dateTimeLeft = FixACValue(source.DateEnd, timeZone); durationInHours = (float)source.Duration.TotalHours; transcriptId = source.TranscriptId; scoId = source.ScoId; scoName = source.ScoName; assetId = source.AssetId; principalId = source.PrincipalId; }
public bool SendMeetingInvitation(MeetingAttendee attendee, MeetingViewModel meeting, string instanceId) { throw new System.NotImplementedException(); }
/// <summary> /// Get the attendees for a meeting /// </summary> /// <param name="meetingId">Current meeting Id</param> /// <param name="schema">Current instance id</param> /// <param name="connectionString">Instance connection string</param> /// <param name="masterConnectionString"></param> /// <returns>Collection of meeting attendees</returns> /// <exception cref="ArgumentException"></exception> public AttendeeMessage GetAttendees(Guid meetingId, string schema, string connectionString, string masterConnectionString) { if (meetingId == Guid.Empty || string.IsNullOrEmpty(schema) || string.IsNullOrEmpty(connectionString)) { throw new ArgumentException("Please provide a valid agenda identifier, schema or connection string."); } try { List <Person> people; using (IDbConnection dbConnection = new SqlConnection(masterConnectionString)) { var peopleSql = $@"SELECT * FROM [app].[Person]"; var peopleData = dbConnection.Query <Person>(peopleSql).ToList(); people = peopleData; } using (IDbConnection dbConnection = new SqlConnection(connectionString)) { dbConnection.Open(); var instanceSql = $@"SELECT * FROM [{schema}].[MeetingAttendee] WHERE [referanceId] = '{meetingId}'"; var instanceData = dbConnection.Query <MeetingAttendee> (instanceSql).ToList(); var attendees = new List <MeetingAttendee>(); foreach (var attendee in instanceData) { var att = new MeetingAttendee { PersonIdentity = attendee.PersonIdentity, Id = attendee.Id, Role = attendee.Role, Status = attendee.Status, Email = attendee.Email }; var person = people.FirstOrDefault(i => i.Identityid == attendee.PersonIdentity); if (person != null) { att.Name = string.IsNullOrEmpty(person.FullName) ? $"{person.FirstName} {person.LastName}" : person.FullName; att.Picture = person.ProfilePicture; } attendees.Add(att); } return(new AttendeeMessage { Code = 200, Condition = true, Message = "Success", Attendees = attendees }); } } catch (Exception e) { Console.WriteLine(e); return(new AttendeeMessage { Code = 500, Condition = false, Message = e.Message }); } }
public MeetingAttendee Put([FromBody] MeetingAttendee attendee) { var userInfo = Request.ExtractAuth(User, _authenticationService); return(attendee); }
/// <summary> /// Invite a attendee /// Validate the attendee is new, alternatively update reference to the new instance if required /// </summary> /// <param name="user" typeof="AuthRestModel">The current user / owner</param> /// <param name="invitee" typeof="MeetingAttendee">The new attendee</param> /// <param name="meeting" typeof="Minutz.Models.Entities.Meeting">The meeting entity for the invitation</param> /// <returns typeof="MessageBase">Result if was successful</returns> public MessageBase InviteUser(AuthRestModel user, MeetingAttendee invitee, Minutz.Models.Entities.Meeting meeting) { var validEmail = _emailValidationService.Valid(invitee.Email); if (!validEmail) { return new MessageBase { Condition = false, Message = $"{invitee.Email} is a invalid email address." } } ; if (meeting.Id == Guid.Empty || string.IsNullOrEmpty(meeting.Name)) { return new MessageBase { Condition = false, Message = "Meeting is invalid." } } ; var instanceConnectionString = _applicationSetting.CreateConnectionString(_applicationSetting.Server, _applicationSetting.Catalogue, user.InstanceId, _applicationSetting.GetInstancePassword(user.InstanceId)); var masterConnectionString = _applicationSetting.CreateConnectionString(); var userValidation = _userRepository.CheckIfNewUser(invitee.Email, invitee.ReferenceId.ToString(), user.InstanceId, instanceConnectionString, masterConnectionString); switch (userValidation.Code) { case 1: //create person var createPersonResult = _userRepository.CreatePerson(invitee, masterConnectionString); if (!createPersonResult.Condition) { return(new MessageBase { Condition = createPersonResult.Condition, Message = createPersonResult.Message, Code = createPersonResult.Code }); } var createPersonAvailableResult = _availabilityRepository.CreateAvailableAttendee(invitee, user.InstanceId, instanceConnectionString); if (!createPersonAvailableResult.Condition) { var message = $"Person was created but there was a issue with creating available attendee. \n {createPersonAvailableResult.Message}"; return(new MessageBase { Condition = createPersonAvailableResult.Condition, Message = message, Code = createPersonAvailableResult.Code }); } var createPersonAttendeeResult = _attendeeRepository.AddAttendee(invitee.ReferenceId, invitee, user.InstanceId, instanceConnectionString); if (!createPersonAttendeeResult.Condition) { var message = $"Person was created, and available attendee was created, but there was a issue with adding to meeting attendee. \n {createPersonAttendeeResult.Message}"; return(new MessageBase { Condition = createPersonAttendeeResult.Condition, Message = message, Code = createPersonAttendeeResult.Code }); } break; case 2: //create available var createAvailableResult = _availabilityRepository.CreateAvailableAttendee(invitee, user.InstanceId, instanceConnectionString); if (!createAvailableResult.Condition) { return(new MessageBase { Condition = createAvailableResult.Condition, Message = createAvailableResult.Message, Code = createAvailableResult.Code }); } var createAvailableAttendeeResult = _attendeeRepository.AddAttendee(invitee.ReferenceId, invitee, user.InstanceId, instanceConnectionString); if (!createAvailableAttendeeResult.Condition) { var message = $"Available attendee was created, but there was a issue with adding to meeting attendee. \n {createAvailableAttendeeResult.Message}"; return(new MessageBase { Condition = createAvailableAttendeeResult.Condition, Message = message, Code = createAvailableAttendeeResult.Code }); } break; case 3: //create meeting attendee var createAttendeeResult = _attendeeRepository.AddAttendee(invitee.ReferenceId, invitee, user.InstanceId, instanceConnectionString); if (!createAttendeeResult.Condition) { var message = $"There was a issue with adding to meeting attendee. \n {createAttendeeResult.Message}"; return(new MessageBase { Condition = createAttendeeResult.Condition, Message = message, Code = createAttendeeResult.Code }); } break; } return(new MessageBase { Condition = true, Message = "Successful" }); }
public virtual void Update(MeetingViewModel meeting, ModelStateDictionary modelState) { if (ValidateModel(meeting, modelState)) { if (string.IsNullOrEmpty(meeting.Title)) { meeting.Title = ""; } var entity = db.Meetings.Include("MeetingAttendees").FirstOrDefault(m => m.MeetingID == meeting.MeetingID); entity.OwnerID = meeting.OwnerID; entity.Title = meeting.Title; entity.Start = meeting.Start; entity.End = meeting.End; entity.Description = meeting.Description; entity.IsAllDay = meeting.IsAllDay; entity.RoomID = meeting.RoomID; entity.RecurrenceID = meeting.RecurrenceID; entity.RecurrenceRule = meeting.RecurrenceRule; entity.RecurrenceException = meeting.RecurrenceException; entity.StartTimezone = meeting.StartTimezone; entity.EndTimezone = meeting.EndTimezone; foreach (var meetingAttendee in entity.MeetingAttendees.ToList()) { entity.MeetingAttendees.Remove(meetingAttendee); } if (meeting.Attendees != null) { foreach (var attendeeId in meeting.Attendees) { var meetingAttendee = new MeetingAttendee { MeetingID = entity.MeetingID, AttendeeID = attendeeId }; entity.MeetingAttendees.Add(meetingAttendee); } } db.SaveChanges(); /** Error Code * if (ValidateModel(meeting, modelState)) * { * using (db) * { * if (string.IsNullOrEmpty(meeting.Title)) * { * meeting.Title = ""; * } * * var entity = meeting.ToEntity(); * db.Meetings.Attach(entity); * db.Entry(entity).State = EntityState.Modified; * * var oldMeeting = db.Meetings * .Include(model => model.MeetingAttendees) * .FirstOrDefault(m => m.MeetingID == meeting.MeetingID); * * foreach (var attendee in oldMeeting.MeetingAttendees.ToList()) * { * db.MeetingAttendees.Attach(attendee); * * if (meeting.Attendees == null || !meeting.Attendees.Contains(attendee.AttendeeID)) * { * db.Entry(attendee).State = EntityState.Deleted; * } * else * { * db.Entry(attendee).State = EntityState.Unchanged; * * ((List<int>)meeting.Attendees).Remove(attendee.AttendeeID); * } * * entity.MeetingAttendees.Add(attendee); * } * * if (meeting.Attendees != null) * { * foreach (var attendeeId in meeting.Attendees) * { * var meetingAttendee = new MeetingAttendee * { * MeetingID = entity.MeetingID, * AttendeeID = attendeeId * }; * * db.MeetingAttendees.Attach(meetingAttendee); * db.Entry(meetingAttendee).State = EntityState.Added; * * entity.MeetingAttendees.Add(meetingAttendee); * } * } * * db.SaveChanges(); * } **/ } }