public async Task <IActionResult> Post([FromBody] MeetingDto meetingDto)
{
meetingDto.AdminId = int.Parse(HttpContext.User.Claims.FirstOrDefault(x => x.Type == "UserId").Value);
var newMeeting = await _meetingService.InsertMeeting(meetingDto);
return(Ok(new ApiResponse <MeetingDto>(meetingDto)));
}
public async Task <ActionResult <Meeting> > PostMeeting(MeetingDto meetingDto)
{
var username = User.Identity.Name;
var account = await _accountsRepository.SelectByUsername(username);
var meeting = new Meeting()
{
Name = meetingDto.Name,
ExpiryDate = meetingDto.ExpiryDate,
MapPoint = new Point(meetingDto.Longitude, meetingDto.Latitude)
{
SRID = 4326
},
Address = meetingDto.Address,
Description = meetingDto.Description,
AuthorId = account.Id,
CreationDate = DateTime.Now,
MaxNumberOfParticipants = meetingDto.MaxNumberOfParticipants,
Participants = new List <StudentifyAccount>()
};
meeting.CreationDate = DateTime.Now;
await _meetingsRepository.Insert.One(meeting);
return(CreatedAtAction(nameof(GetMeeting), new { id = meeting.Id }, meeting));
}
private static bool CompareWithDto(MeetingGetDto m, MeetingDto dto)
{
if (m is null)
{
return(false);
}
if (dto is null)
{
return(false);
}
if (m.Name != dto.Name)
{
return(false);
}
if (m.ExpiryDate != dto.ExpiryDate)
{
return(false);
}
if (m.Description != dto.Description)
{
return(false);
}
if (m.Description != dto.Description)
{
return(false);
}
if (m.MaxNumberOfParticipants != dto.MaxNumberOfParticipants)
{
return(false);
}
return(true);
}
public async Task <ActionResult <MeetingDto> > Get(int id)
{
try
{
var result = await meetingService.GetAsync(id);
if (result == null)
{
return(NotFound());
}
MeetingDto meeting = new MeetingDto
{
Id = result.Id,
Topic = result.Topic,
Date = result.Date.Value.ToString("d"),
DateTime = result.Date,
StartTime = result.Date.Value.ToString("HH:mm"),
EndTime = result.EndTime,
Participants = result.Participants.Select(y => new ParticipantDto {
Id = y.Id, Fullname = y.Fullname
}).ToArray()
};
return(meeting);
}
catch (Exception)
{
return(StatusCode(StatusCodes.Status500InternalServerError, "Database Failure"));
}
}
public void Test_Passing_Valid_Values()
{
// ARRANGE
IOrganisation organisation = new Organisation(
id: Guid.NewGuid(),
code: "CBC",
name: "County Bridge Club",
bgColour: "000000");
IMeeting meeting = new Meeting(
id: Guid.NewGuid(),
committee: new Committee(
id: Guid.NewGuid(),
organisation: organisation,
name: "TSC",
description: "Tournament Sub-Committee"),
meetingDateTime: new DateTime(2019, 12, 30, 19, 15, 00));
// ACT
MeetingDto meetingDto = MeetingDto.ToDto(meeting);
// ASSERT
Assert.AreEqual(meeting.Id, meetingDto.Id);
Assert.AreEqual(meeting.Committee.Id, meetingDto.CommitteeId);
Assert.AreEqual(meeting.MeetingDateTime, meetingDto.MeetingDateTime);
}
public async Task <IActionResult> Create([FromBody] MeetingDto meeting)
{
var currentUser = await this.userContext.GetCurrentUser();
if (!currentUser.CanCreateMeetings)
{
return(BadRequest());
}
try
{
await this.meetingBop.CreateMeeting(new CxMeetingModel()
{
Id = "",
Title = meeting.Title,
Description = meeting.Description,
OwnerId = currentUser.Id,
StartTime = meeting.StartTime,
Duration = meeting.Duration,
IsPublic = meeting.IsPublic
});
}
catch (Exception)
{
return(BadRequest());
}
return(Ok());
}
public void Create(MeetingDto meetingModel, AppType appType, Guid syncId)
{
var userName = securityService.GetCurrentUserName();
switch ((MeetingType)meetingModel.MeetingType)
{
case MeetingType.Working:
{
var command = RMSMapper.Map<MeetingDto, CreateWorkingMeetingCmd>(meetingModel);
command.AppType = appType;
command.ActionOwnerUserName = userName;
command.SyncId = syncId;
meetingService.CreateWorkingMeeting(command);
}
break;
case MeetingType.NonWorking:
{
var command = RMSMapper.Map<MeetingDto, CreateNonWorkingMeetingCmd>(meetingModel);
command.AppType = appType;
command.ActionOwnerUserName = userName;
command.SyncId = syncId;
meetingService.CreateNonWorkingMeeting(command);
}
break;
default:
throw new Exception("MeetingType is not set correctlly");
}
}
public IActionResult Post([FromBody] MeetingDto meeting)
{
var currentUserId = int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value);
meeting.User = new UserForListDto {
Id = currentUserId
};
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var metetingToCreate = _mapper.Map <Meeting>(meeting);
if (!_repo.IsDateAvaliable(metetingToCreate))
{
ModelState.AddModelError("Horário", "Horário indisponível, selecione outro horário!");
return(BadRequest(ModelState));
}
var createdMeeting = _repo.Save(metetingToCreate);
var meetingToReturn = _mapper.Map <MeetingDto>(createdMeeting);
return(CreatedAtRoute("GetMeeting", new { controller = "Meeting", id = createdMeeting.Id }, meetingToReturn));
}
public async Task <IActionResult> AddMeeting(MeetingDto dto)
{
if (!Validation.IsValidName(dto.title))
{
return(BadRequest($"Error: {dto.title}"));
}
if (!DateTime.TryParseExact(dto.datetimestart, "dd/MM/yyyy HH:mm", CultureInfo.InvariantCulture,
DateTimeStyles.None, out DateTime datetimeStart))
{
return(BadRequest($"{dto.datetimestart} is not in an acceptable format."));
}
if (!DateTime.TryParseExact(dto.datetimeend, "dd/MM/yyyy HH:mm", CultureInfo.InvariantCulture,
DateTimeStyles.None, out DateTime datetimeEnd))
{
return(BadRequest($"{dto.datetimeend} is not in an acceptable format."));
}
if (datetimeStart > datetimeEnd)
{
return(BadRequest($"Error: {dto.datetimestart}>{dto.datetimeend}"));
}
db.Meetings.Add(new Meeting {
Title = dto.title, DatetimeStart = datetimeStart, DatetimeEnd = datetimeEnd
});
await db.SaveChangesAsync();
return(new OkObjectResult($"Meeting \"{dto.title}\" added"));
}
public async Task <IActionResult> PutMeeting(int id, MeetingDto meetingDto)
{
Meeting meeting;
try
{
meeting = await _meetingsRepository.Select.ById(id);
}
catch (DataException)
{
return(BadRequest());
}
meeting.Name = meetingDto.Name;
meeting.ExpiryDate = meetingDto.ExpiryDate;
meeting.MapPoint.X = meetingDto.Longitude;
meeting.MapPoint.Y = meetingDto.Latitude;
meeting.Address = meetingDto.Address;
meeting.Description = meetingDto.Description;
meeting.MaxNumberOfParticipants = meetingDto.MaxNumberOfParticipants;
try
{
await _meetingsRepository.Update.One(meeting, id);
}
catch (DataException)
{
return(NotFound());
}
return(NoContent());
}
public void Test_Passing_Valid_Values()
{
// ARRANGE
OrganisationDto organisationDto = new OrganisationDto(
id: Guid.NewGuid(),
code: "CBC",
name: "County Bridge Club",
bgColour: "000000");
CommitteeDto committeeDto = new CommitteeDto(
id: Guid.NewGuid(),
organisationId: organisationDto.Id,
name: "TSC",
description: "Tournament Sub-Committee",
organisation: organisationDto);
MeetingDto meetingDto = new MeetingDto(
Guid.NewGuid(),
committeeId: committeeDto.Id,
meetingDateTime: new DateTime(2019, 12, 30, 19, 15, 00),
committee: committeeDto);
// ACT
IMeeting meeting = meetingDto.ToDomain();
// ASSERT
Assert.IsNotNull(meeting);
Assert.AreEqual(meetingDto.Id, meeting.Id);
Assert.IsNotNull(meeting.Committee);
Assert.AreEqual(meetingDto.CommitteeId, meeting.Committee.Id);
Assert.AreEqual(meetingDto.MeetingDateTime, meeting.MeetingDateTime);
}
public ICollection <MeetingDto> SearchMeetings(MeetingDto searchCriteria)
{
if (searchCriteria == null)
{
Logger.Logger.LogError("Meetings searchCriteria is null!");
throw new NSIException("Parameter searchCriteria is null!", Level.Error, ErrorType.InvalidParameter);
}
var meetings = from meeting in _dbContext.Meeting select meeting;
if (searchCriteria.MeetingId != 0)
{
meetings = meetings.Where(x => x.MeetingId == searchCriteria.MeetingId);
}
if (!string.IsNullOrEmpty(searchCriteria.Title))
{
meetings = meetings.Where(x => x.Title.Contains(searchCriteria.Title));
}
if (searchCriteria.To != null)
{
meetings = meetings.Where(x => x.To.Value.Date == searchCriteria.To.Value.Date);
}
ICollection <MeetingDto> meetingsDto = new List <MeetingDto>();
foreach (var item in meetings)
{
meetingsDto.Add(Mappers.MeetingsRepository.MapToDto(item));
}
return(meetingsDto);
}
public async Task <MeetingDto> GetMeeting(int id)
{
var meeting = await _meetingRepository.GetMeeting(id);
if (meeting == null)
{
return(null);
}
var meetingDto = new MeetingDto
{
MeetingId = meeting.MeetingId,
Description = meeting.Description,
AdminId = meeting.AdminId,
Date = meeting.Date,
MaxPeople = meeting.MaxPeople,
City = new CityDto
{
CityId = meeting.City.CityId,
Name = meeting.City.Name,
Latitude = meeting.City.Latitude,
Longitude = meeting.City.Longitude
}
};
return(meetingDto);
}
public static async Task <MeetingDto> GetMeetingById(int id)
{
Meeting entity = await MeetingRead.GetMeeting(id, a => a.Location, a => a.Organizer, a => a.Participants);
MeetingDto result = Convert(entity);
return(result);
}
public async Task <IActionResult> Put(MeetingDto meetingDto)
{
var adminId = int.Parse(HttpContext.User.Claims.FirstOrDefault(x => x.Type == "UserId").Value);
var result = await _meetingService.UpdateMeeting(meetingDto, adminId);
return(Ok(new ApiResponse <bool>(result)));
}
public static Meeting ToModel(this MeetingDto meeting) =>
new Meeting
{
Id = Guid.Parse(meeting.Id),
UserId = Guid.Parse(meeting.UserId),
Start = meeting.Start.ToDateTimeOffset(),
End = meeting.End.ToDateTimeOffset(),
Name = meeting.Name,
Description = meeting.Descripton
};
public override bool Equals(object o)
{
MeetingDto dto = o as MeetingDto;
if (dto is null)
{
return(false);
}
return(CompareWithDto(this, dto));
}
public void Test_Default_Constructor()
{
// ACT
MeetingDto dto = new MeetingDto();
// ASSERT
Assert.AreEqual(Guid.Empty, dto.Id);
Assert.AreEqual(Guid.Empty, dto.CommitteeId);
Assert.AreEqual(DateTime.MinValue, dto.MeetingDateTime);
}
public MeetingDto InsertMeeting(MeetingDto model)
{
var entity_meeting = Mappers.MeetingsRepository.MapToDbEntity(model);
_dbContext.Meeting.Add(entity_meeting);
if (_dbContext.SaveChanges() > 0)
{
return(GetMeetingById(entity_meeting.MeetingId));
}
throw new NSIException("Error while inserting new meeting");
}
public async Task <MeetingDto> InsertMeeting(MeetingDto meetingDto)
{
var meeting = new Meeting
{
MeetingId = meetingDto.MeetingId,
Description = meetingDto.Description,
AdminId = meetingDto.AdminId,
Date = meetingDto.Date,
MaxPeople = meetingDto.MaxPeople,
City = new City
{
CityId = meetingDto.City.CityId,
Name = meetingDto.City.Name,
Latitude = meetingDto.City.Latitude,
Longitude = meetingDto.City.Longitude
}
};
try
{
// valido que por lo menos sea con un dia de diferncia la meeting
if ((meeting.Date - DateTime.Now).TotalDays < 1)
{
throw new ChallengeException("La fecha ingresada debe ser mayor a hoy.");
}
var inserted = await _meetingRepository.InsertMeeting(meeting);
meetingDto.MeetingId = inserted.MeetingId;
meetingDto.City = new CityDto
{
CityId = inserted.City.CityId,
Name = inserted.City.Name,
Latitude = inserted.City.Latitude,
Longitude = inserted.City.Longitude
};
return(meetingDto);
}
catch (Exception ex)
{
if (ex.Message.Contains("Ya existe"))
{
throw new ChallengeException(ex.Message);
}
if (ex.Message.Contains("ciudad"))
{
throw new ChallengeException(ex.Message);
}
throw;
}
}
public void GetMeetingTimes_ReturnsOK()
{
// Arrange
int id = 123;
string title = "naziv";
string meetPlace = "mjesto";
DateTime from = DateTime.Now;
DateTime to = DateTime.Now.AddDays(10);
var usersOnMeeting = new List <UserMeetingDto>()
{
new UserMeetingDto()
{
UserId = 1
},
new UserMeetingDto()
{
UserId = 2
},
new UserMeetingDto()
{
UserId = 3
},
new UserMeetingDto()
{
UserId = 4
}
};
var meeting = new MeetingDto()
{
MeetingId = id,
Title = title,
MeetingPlace = meetPlace,
From = from,
To = to,
UserMeeting = usersOnMeeting
};
var meetingRepo = new Mock <IMeetingsRepository>();
meetingRepo.Setup(x => x.InsertMeeting(meeting));
var meetingManipulation = new MeetingsManipulation(meetingRepo.Object);
var controller = new MeetingsController(meetingManipulation);
// Act
var result = controller.GetMeetingsTimes(new List <int> {
1, 2, 3, 4
}, from, to, 10, 123);
// Assert
Assert.IsType <OkObjectResult>(result);
}
public Task <bool> Post([FromBody] MeetingDto value)
{
Meetings meetings = new Meetings
{
Agenda = value.Agenda,
Subject = value.Subject,
DateTime = value.MeetingTime,
CreatedBy = value.UserID,
UpdateDate = DateTime.Now,
AttendeesIds = value.Attendees
};
return(Task.FromResult(_meetingService.Add(meetings)));
}
public static void AreEqual_BaseMeetingDto(MeetingDto expect, MeetingDto actual)
{
Assert.AreEqual(expect.Subject, actual.Subject);
Assert.AreEqual(expect.StartDate.ToString(CultureInfo.CurrentCulture),
actual.StartDate.ToString(CultureInfo.CurrentCulture));
Assert.AreEqual(expect.MeetingType, actual.MeetingType);
Assert.AreEqual(expect.Duration, actual.Duration);
Assert.AreEqual(expect.Description, actual.Description);
Assert.AreEqual(expect.LocationAddress, actual.LocationAddress);
Assert.AreEqual(expect.LocationLatitude, actual.LocationLatitude);
Assert.AreEqual(expect.LocationLongitude, actual.LocationLongitude);
Assert.AreEqual(expect.Agenda, actual.Agenda);
Assert.AreEqual(expect.Attendees, actual.Attendees);
}
/// <summary>
/// Convert from Entity to DTO
/// </summary>
/// <param name="meetingEntity"></param>
/// <returns></returns>
public static MeetingDto Convert(Meeting meetingEntity)
{
MeetingDto result = new MeetingDto()
{
Id = meetingEntity.Id,
Title = meetingEntity.Title,
Description = meetingEntity.Description,
MeetingStart = meetingEntity.MeetingStart,
MeetingEnd = meetingEntity.MeetingEnd,
OrganizerRefId = meetingEntity.OrganizerRefId,
LocationRefId = meetingEntity.LocationRefId,
};
return(result);
}
/// <summary>
/// Convert from DTO to Entity
/// </summary>
/// <param name="meetingDto"></param>
/// <returns></returns>
public static Meeting Convert(MeetingDto meetingDto)
{
Meeting result = new Meeting()
{
Id = meetingDto.Id,
Title = meetingDto.Title,
Description = meetingDto.Description,
MeetingStart = meetingDto.MeetingStart,
MeetingEnd = meetingDto.MeetingEnd,
OrganizerRefId = meetingDto.OrganizerRefId,
LocationRefId = meetingDto.LocationRefId,
};
return(result);
}
public Task <bool> Put(int id, [FromBody] MeetingDto value)
{
Meetings meetings = new Meetings
{
Agenda = value.Agenda,
Subject = value.Subject,
DateTime = value.MeetingTime,
CreatedBy = 1,//value.UserId,
UpdateDate = DateTime.Now,
AttendeesIds = value.Attendees,
Id = id
};
return(Task.FromResult(_meetingService.Update(meetings)));
}
public async Task <HttpResponseMessage> UpdateMeeting([FromBody] MeetingDto meetingDto)
{
HttpResponseMessage result;
try
{
await MeetingService.UpdateMeeting(meetingDto);
result = Request.CreateResponse(HttpStatusCode.Created);
}
catch (Exception e)
{
Console.WriteLine(e);
result = Request.CreateErrorResponse(HttpStatusCode.InternalServerError, e.Message);
}
return(result);
}
private static MeetingDto createBaseMeetingDto(DateTime startDate, int duration)
{
var dto = new MeetingDto
{
Subject = "TestMeeting",
StartDate = startDate,
Duration = duration,
Description = "This is test Meeting that we want to have in this section",
LocationAddress = "its test location for us to know ",
LocationLatitude = 3.334433443,
LocationLongitude = 4.33333333,
Agenda = "this is test meeting agenda",
Attendees = "ehsan mohammadi,reza akbari, davood shokri,mohammad reza bayat",
};
return dto;
}
public static Meeting MapToDbEntity(MeetingDto model)
{
return(new Meeting()
{
MeetingId = model.MeetingId,
Title = model.Title,
MeetingPlace = model.MeetingPlace,
From = model.From,
To = model.To,
CreatedByUserId = 1,
DateCreated = DateTimeOffset.UtcNow,
UserMeeting = model.UserMeeting.Select(x => new UserMeeting()
{
UserId = x.UserId
}).ToList()
});
}
public MeetingDto UpdateMeeting(int meetingId, MeetingDto model)
{
var meeting = _dbContext.Meeting.FirstOrDefault(x => x.MeetingId == meetingId && x.IsDeleted == false);
if (meeting == null)
{
throw new NSIException("Meeting not found");
}
//remove all users for this meeting from UserMeeting table
var atendees = _dbContext.UserMeeting.Where(x => x.MeetingId == meetingId).ToList();
if (atendees != null)
{
_dbContext.UserMeeting.RemoveRange(atendees);
}
//update data
meeting.Title = model.Title ?? meeting.Title;
meeting.MeetingPlace = model.MeetingPlace ?? meeting.MeetingPlace;
meeting.DateModified = DateTimeOffset.UtcNow;
if (model.From != null)
{
meeting.From = model.From;
}
if (model.To != null)
{
meeting.To = model.To;
}
//update users
foreach (var item in model.UserMeeting)
{
meeting.UserMeeting.Add(new UserMeeting()
{
UserId = item.UserId, MeetingId = meetingId
});
}
if (_dbContext.SaveChanges() > 0)
{
return(GetMeetingById(meeting.MeetingId));
}
throw new NSIException("Error while updating new meeting");
}
public IActionResult Search([FromBody] MeetingsSearchModel model, int pageNumber, int pageSize)
{
try
{
if (model == null)
{
throw new NSIException("MeetingSearchModel is null", DC.Exceptions.Enums.Level.Error, DC.Exceptions.Enums.ErrorType.InvalidParameter);
}
MeetingDto meetingDto = new MeetingDto()
{
MeetingId = model.MeetingId,
To = model.To,
Title = model.Title,
From = model.From,
UserMeeting = model.UserMeeting.Select(x => new UserMeetingDto()
{
UserId = x.UserId,
UserName = x.UserName
})
};
return(Ok(new NSIResponse <ICollection <MeetingDto> > {
Data = _meetingsManipulation.SearchMeetings(meetingDto, pageNumber, pageSize), Message = "Success"
}));
}
catch (NSIException ex)
{
Logger.Logger.LogError(ex);
if (ex.ErrorType == DC.Exceptions.Enums.ErrorType.MissingData)
{
return(NoContent());
}
return(BadRequest(new NSIResponse <object> {
Data = null, Message = "Parameter error!"
}));
}
catch (Exception ex)
{
Logger.Logger.LogError(ex);
return(StatusCode(500, new NSIResponse <object> {
Data = null, Message = ex.Message
}));
}
}
public async Task CreateMeetingAsync(Guid meetingId, DateTime meetingDateTime)
{
var dto = new MeetingDto
{
Id = meetingId,
DateTime = meetingDateTime
};
var response = await _client.PostAsJsonAsync(
"", dto);
if (!response.IsSuccessStatusCode)
{
var error = response.Content.ReadAsStringAsync().Result;
throw new ApplicationException(error);
}
}
/// <inheritdoc/>
public async Task CreateMeetingAsync(
IWho who,
IAuditHeaderWithAuditDetails auditHeader,
IMeeting meeting)
{
this.logger.ReportEntry(
who,
new { Meeting = meeting });
MeetingDto dto = MeetingDto.ToDto(meeting);
this.context.Meetings.Add(dto);
await this.context.SaveChangesAsync().ConfigureAwait(false);
Audit.AuditCreate(auditHeader, dto, dto.Id);
this.logger.ReportExit(who);
}
public void Delete(MeetingDto dto, AppType appType, Guid syncId)
{
var userName = securityService.GetCurrentUserName();
var command = new DeleteMeetingCmd(dto.Id, userName, appType, syncId);
meetingService.Delete(command);
}
public static void AreEqual_State(MeetingStateEnum state, MeetingDto actual)
{
Assert.AreEqual(state,actual.State);
}
public static void AreEqual_WorkingMeetingDto(MeetingDto expect, MeetingDto actual)
{
Assert.AreEqual(expect.Decisions, actual.Decisions);
Assert.AreEqual(expect.Details, actual.Details);
}
private MeetingDto mapToMeetingDto(MeetingViewModel meetingModel)
{
string datetime = ConvertDigitsToLatin(meetingModel.StartDate) + "/" + meetingModel.StartTime + "/0";
var meetingDto = new MeetingDto
{
Id = meetingModel.Id,
Agenda = meetingModel.Agenda,
LocationAddress = meetingModel.Address,
Attendees = meetingModel.AttendeesList,
Description = meetingModel.Description,
Duration = meetingModel.Duration,
LocationLatitude = meetingModel.Latitude,
LocationLongitude = meetingModel.Longitude,
Subject = meetingModel.Subject,
MeetingType = meetingModel.MeetingType,
StartDate = GetChristianDateTime(datetime),
Details = meetingModel.Details,
Decisions = meetingModel.Decisions,
State = (MeetingStateEnum)meetingModel.State,
Reminder = new ReminderDto
{
ReminderType = (ReminderType)meetingModel.ReminderType,
RepeatingType = (RepeatingType)meetingModel.RepeatingType,
ReminderTimeType = (ReminderTimeType)meetingModel.ReminderTime
}
};
return meetingDto;
}
private MeetingViewModel mapToViewModel(MeetingDto dto)
{
var meetingModel = new MeetingViewModel
{
Id = dto.Id,
Address = dto.LocationAddress,
Agenda = dto.Agenda,
AttendeesList = dto.Attendees,
Latitude = dto.LocationLatitude,
Longitude = dto.LocationLongitude,
Description = dto.Description,
Duration = dto.Duration,
MeetingType = dto.MeetingType,
StartTime = dto.StartDate.ToString("HH:mm"),
StartDate = GetPersianDate(dto.StartDate),
StartDateTime = dto.StartDate,
Subject = dto.Subject,
Details = dto.Details,
Decisions = dto.Decisions,
ReminderTime = dto.Reminder != null ? (int)dto.Reminder.ReminderTimeType : 0,
ReminderType = dto.Reminder != null ? (int)dto.Reminder.ReminderType : 0,
RepeatingType = dto.Reminder != null ? (int)dto.Reminder.RepeatingType : 0,
State = dto.State
};
return meetingModel;
}
