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();
* }
**/
}
}
