public async Task <JsonResult> CreateConference(string branchId, ConferenceDTO confDetails)
{
if (!IsNumeric(branchId) || ((await _dbContext.FindAsync <Branch>(Int32.Parse(branchId)) == null)))
{
throw new ArgumentNullException($"Null or invalid parameter: {nameof(branchId)}");
}
if (confDetails == null)
{
throw new ArgumentNullException(nameof(confDetails));
}
if (!IsConfDatesValid(confDetails.StartTime, confDetails.EndTime))
{
throw new ArgumentOutOfRangeException($"Null or invalid parameter: {nameof(confDetails.StartTime)}, {nameof(confDetails.EndTime)}");
}
//TODO: Need model to handle conference details
//TODO: Check that conference is NEW
var newConference = Conference.BuildConference(confDetails, Int32.Parse(branchId));
_dbContext.Conferences.Add(newConference);
_dbContext.SaveChanges();
await Task.Yield();
return(Json(newConference));
}
public void PostConference(ConferenceDTO conference, string currentUser)
{
var newAddress = new Address()
{
Street = conference.Street,
City = conference.City,
State = conference.State,
Zip = conference.Zip
};
_addressRepo.add(newAddress);
_addressRepo.saveChanges();
var newConference = new Conference
{
Name = conference.Name,
AddressId = newAddress.Id,
//Address = _addressRepo.FindByAddress(conference.Street, conference.City,
//conference.State, conference.Zip).FirstOrDefault(),
ApplicationUserId = (from a in _userRepo.List()
where a.UserName == currentUser
select a.Id).FirstOrDefault(),
ImageUrl = conference.ImageUrl,
StartDate = conference.StartDate,
EndDate = conference.EndDate
};
_confRepo.AddConference(newConference);
_confRepo.SaveChanges();
}
public async Task <bool> EditConferenceAsync(ConferenceDTO conference)
{
var path = Properties.Resources.editConferencePath;
var result = await _apiHelper.Put(path, conference);
return(result != null && result.ResponseType == ResponseType.Success);
}
public void AddConference(ConferenceDTO conferenceDTO)
{
var conference = MapperExtension.mapper.Map <ConferenceDTO, Conference>(conferenceDTO);
_db.Conferences.Add(conference);
_db.SaveChanges();
}
public void EditConference(ConferenceDTO conferenceDTO)
{
var conference = MapperExtension.mapper.Map <ConferenceDTO, Conference>(conferenceDTO);
_db.Entry(_db.Conferences.Find(conferenceDTO.ConferenceId)).CurrentValues.SetValues(conference);
_db.SaveChanges();
}
public static ConferenceInfo ToViewModel(this ConferenceDTO dto)
{
if (dto == null)
{
return(null);
}
var model = new ConferenceInfo();
model.Id = dto.Id;
model.Name = dto.Name;
model.Description = dto.Description;
model.Location = dto.Location;
model.Tagline = dto.Tagline;
model.TwitterSearch = dto.TwitterSearch;
model.StartDate = dto.StartDate;
model.EndDate = dto.EndDate;
model.AccessCode = dto.AccessCode;
model.OwnerName = dto.OwnerName;
model.OwnerEmail = dto.OwnerEmail;
model.Slug = dto.Slug;
model.IsPublished = dto.IsPublished;
model.WasEverPublished = dto.WasEverPublished;
return(model);
}
public void when_starting_registration_then_returns_view_with_registration_for_conference()
{
var conferenceId = Guid.NewGuid();
var seatId = Guid.NewGuid();
var conferenceDTO =
new ConferenceDTO(conferenceId, "conference", "Test Conference", "", new[] { new ConferenceSeatTypeDTO(seatId, "Test Seat", 10d) });
// Arrange
Mock.Get <IViewRepository>(this.viewRepository)
.Setup(r => r.Query <ConferenceDTO>())
.Returns(new ConferenceDTO[] { conferenceDTO }.AsQueryable());
// Act
var result = (ViewResult)this.sut.StartRegistration("conference");
// Assert
Assert.NotNull(result);
Assert.Equal("", result.ViewName);
var resultRegistration = result.Model as global::Conference.Web.Public.Models.OrderViewModel;
Assert.NotNull(resultRegistration);
Assert.Equal("conference", resultRegistration.ConferenceCode);
Assert.Equal("Test Conference", resultRegistration.ConferenceName);
Assert.Equal(1, resultRegistration.Items.Count);
Assert.Equal("Test Seat", resultRegistration.Items[0].SeatTypeDescription);
}
public void modifyDescription(int uId, int cId, string cName, DateTime cStartDate, DateTime cEndDate, string Cdomain, DateTime CabstractDeadline, DateTime cFullPaperDeadline)
{
var c = new ConferenceDTO {
Id = cId, Name = cName, StartDate = cStartDate.ToString(), EndDate = cEndDate.ToString(), Domain = Cdomain, AbstractDeadline = CabstractDeadline.ToString(), FullPaperDeadline = cFullPaperDeadline.ToString()
};
_server.ModifyDescription(uId, c);
}
public MyProposals(ClientController controller, UserDTO user, OpenedFrom openedFrom, ConferenceDTO conference)
{
_user = user;
_ctrl = controller;
_openedFrom = openedFrom;
_conference = conference;
InitializeComponent();
}
public AddReviewer(ClientController clientController, UserDTO user, ConferenceDTO conference)
{
_clientController = clientController;
_user = user;
_conference = conference;
InitializeComponent();
ConferenceNameLabel.Text = $"{ConferenceNameLabel.Text} {_conference.Name}";
}
public IActionResult Post([FromBody] ConferenceDTO conference)
{
if (ModelState.IsValid)
{
_confServ.PostConference(conference, User.Identity.Name);
return(Ok(conference));
}
return(HttpBadRequest(ModelState));
}
// methods from IUserConferenceService
public void addConference(int uId, int cId, string cName, DateTime cStartDate, DateTime cEndDate, string Cdomain, DateTime CabstractDeadline, DateTime cFullPaperDeadline, float Price, string Description)
{
var c = new ConferenceDTO()
{
Name = cName, StartDate = cStartDate.ToString(), EndDate = cEndDate.ToString(), Domain = Cdomain, AbstractDeadline = CabstractDeadline.ToString(), FullPaperDeadline = cFullPaperDeadline.ToString(), Price = Price, State = ConferenceState.Proposed.ToString(), MainDescription = Description
};
_server.AddConference(uId, c);
}
private void assignBuildings_button_Click(object sender, RoutedEventArgs e)
{
ConferenceDTO selected_conference = (ConferenceDTO)ConferencesBox.SelectedItem;
if (selected_conference != null)
{
AssignBuildingToConference newAssignBuildingWindow = new AssignBuildingToConference(selected_conference);
newAssignBuildingWindow.ShowDialog();
}
}
public AddEditConference(ConferenceDTO conference)
{
InitializeComponent();
WindowHelper.SmallWindowSettings(this);
core = new ConferenceCore();
currentConference = conference;
if (conference != null)
{
InitializeEditFields();
}
}
public AssignBuildingToConference(ConferenceDTO arg_conferenceID)
{
InitializeComponent();
WindowHelper.SmallWindowSettings(this);
this.Title = this.Title + arg_conferenceID.Title;
this.current_conference = arg_conferenceID;
this.conferenceId = current_conference.ConferenceId;
assignButton.IsEnabled = false;
unassignButton.IsEnabled = false;
InitializeData();
}
public bool EditConference(ConferenceDTO conference)
{
try
{
_repository.EditConference(conference);
}
catch
{
return(false);
}
return(true);
}
private void ConferencesBox_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
ConferenceDTO selected = (ConferenceDTO)ConferencesBox.SelectedItem;
if (selected != null)
{
assignBuildings_button.IsEnabled = true;
}
else
{
assignBuildings_button.IsEnabled = false;
}
}
public IHttpActionResult EditConference([FromBody] ConferenceDTO conference)
{
if (string.IsNullOrEmpty(conference.Title) || string.IsNullOrEmpty(conference.Place) ||
conference.BeginDate == default(DateTime) || conference.EndDate == default(DateTime))
{
return(BadRequest());
}
if (_bll.EditConference(conference))
{
return(Ok());
}
return(InternalServerError());
}
public void when_specifying_seats_for_a_valid_registration_then_places_registration_and_redirects_to_action()
{
var conferenceId = Guid.NewGuid();
var seatTypeId = Guid.NewGuid();
var conferenceDTO =
new ConferenceDTO(conferenceId, "conference", "Test Conference", "", new[] { new ConferenceSeatTypeDTO(seatTypeId, "Test Seat", 10d) });
// Arrange
Mock.Get <IViewRepository>(this.viewRepository)
.Setup(r => r.Query <ConferenceDTO>())
.Returns(new ConferenceDTO[] { conferenceDTO }.AsQueryable());
var orderId = Guid.NewGuid();
Mock.Get <IViewRepository>(this.viewRepository)
.Setup(r => r.Find <OrderDTO>(orderId))
.Returns(new OrderDTO(orderId, Order.States.Booked));
var registration =
new global::Conference.Web.Public.Models.OrderViewModel
{
Id = orderId,
ConferenceCode = "conference",
Items = new[] { new OrderItemViewModel {
Quantity = 10, SeatTypeId = seatTypeId
} }
};
// Act
var result = (RedirectToRouteResult)this.sut.StartRegistration("conference", registration);
// Assert
Assert.Equal(null, result.RouteValues["controller"]);
Assert.Equal("SpecifyRegistrantDetails", result.RouteValues["action"]);
Assert.Equal("conference", result.RouteValues["conferenceCode"]);
Assert.Equal(orderId, result.RouteValues["orderId"]);
Mock.Get <ICommandBus>(this.bus)
.Verify(
b =>
b.Send(It.Is <Envelope <ICommand> >(e =>
((RegisterToConference)e.Body).ConferenceId == conferenceId &&
((RegisterToConference)e.Body).OrderId == orderId &&
((RegisterToConference)e.Body).Seats.Count == 1 &&
((RegisterToConference)e.Body).Seats.ElementAt(0).Quantity == 10 &&
((RegisterToConference)e.Body).Seats.ElementAt(0).SeatTypeId == seatTypeId)),
Times.Once());
}
public ConferenceDTO updateConference(ConferenceDTO conferenceDTO)
{
using (var uow = new UnitOfWork())
{
var repo = uow.getRepository <Conference>();
var conf = repo.get(conferenceDTO.Id);
if (conf == null)
{
return(null);
}
repo.update(conferenceDTO.Id, converter.convertToPOCOModel(conferenceDTO));
uow.saveChanges();
return(conferenceDTO);
}
}
public CreateUpdateConferenceForm(BaseForm form, CUFormDTO <conference> formDTO)
{
caller = form;
//form.Hide();
InitializeComponent();
this.db = formDTO.contex;
conferenceDTO = new ConferenceDTO();
crud = new ConferenceCrud(db);
addressCrud = new AddressCrud(db);
countryCrud = new CountryCrud(db);
currentCrudOp = formDTO.op;
this.formDTO = formDTO;
}
public void TestConferenceServiceAddConf()
{
var service = new UserConferenceService();
ConferenceDTO conferenceToAdd = new ConferenceDTO
{
Name = "Nume",
Edition = 11,
StartDate = (new DateTime(2018, 1, 12)).ToString(),
EndDate = (new DateTime(2020, 1, 12)).ToString(),
Domain = "Domeniu",
AbstractDeadline = (new DateTime(2019, 1, 12)).ToString(),
FullPaperDeadline = (new DateTime(2020, 1, 1)).ToString(),
MainDescription = "Descriere",
Price = 25f,
State = ConferenceState.Accepted.ToString()
};
Assert.AreEqual(0, service.GetAllConferences().ToList().Count);
PrepareData();
Assert.AreEqual(1, service.GetAllConferences().ToList().Count);
//the conference will be added
try
{
var confSaved = service.AddConference(1, conferenceToAdd);
Assert.AreEqual(2, service.GetAllConferences().ToList().Count);
}
catch (Exception e)
{
Assert.Fail();
}
//an error is thrown when the conference fails validation
try
{
service.AddConference(1, conferenceToAdd);
Assert.Fail();
}
catch (Exception e)
{
Assert.IsNotNull(e);
Assert.AreEqual(2, service.GetAllConferences().ToList().Count);
}
}
public AddSections(ConferenceDTO conf, ClientController ct)
{
conference = conf;
ctrl = ct;
remainingProposals = new DataTable();
remainingProposals.Columns.Add("Id", typeof(int));
remainingProposals.Columns.Add("Title", typeof(string));
remainingProposals.Columns.Add("Subject", typeof(string));
remainingProposals.Columns.Add("Url", typeof(string));
chosenProposals = new DataTable();
chosenProposals.Columns.Add("Id", typeof(int));
chosenProposals.Columns.Add("Title", typeof(string));
chosenProposals.Columns.Add("Subject", typeof(string));
chosenProposals.Columns.Add("Url", typeof(string));
InitializeComponent();
initializeData();
}
private async void SubmitButton_Click(object sender, RoutedEventArgs e)
{
if (ValidateForm())
{
bool result = false;
if (currentConference == null)
{
var conference = new ConferenceDTO()
{
Title = TitleBox.Text,
Description = DescriptionBox.Text,
Place = PlaceBox.Text,
BeginDate = BeginDatePicker.SelectedDate.Value,
EndDate = EndDatePicker.SelectedDate.Value
};
result = await core.AddConferenceAsync(conference);
}
else
{
currentConference.Title = TitleBox.Text;
currentConference.Description = DescriptionBox.Text;
currentConference.Place = PlaceBox.Text;
currentConference.BeginDate = BeginDatePicker.SelectedDate.Value;
currentConference.EndDate = EndDatePicker.SelectedDate.Value;
result = await core.EditConferenceAsync(currentConference);
}
if (result)
{
MessageBox.Show("Success");
Close();
}
else
{
MessageBox.Show("Failure");
}
}
else
{
MessageBox.Show("Invalid form");
}
}
public async Task <JsonResult> UpdateConference(string confId, ConferenceDTO confDetails)
{
if (!IsNumeric(confId))
{
throw new ArgumentNullException($"Null or invalid parameter: {nameof(confId)}");
}
if (!IsConfDatesValid(confDetails.StartTime, confDetails.EndTime))
{
throw new ArgumentOutOfRangeException($"Null or invalid parameter: {nameof(confDetails.StartTime)}, {nameof(confDetails.EndTime)}");
}
var oldConf = await _dbContext.FindAsync <Conference>(Int32.Parse(confId));
oldConf = Conference.RefreshConference(oldConf, confDetails);
_dbContext.Update <Conference>(oldConf);
_dbContext.SaveChanges();
await Task.Yield();
return(Json("Conference updated"));
}
public ConferenceDTO ModifyDescription(int idUser, ConferenceDTO conferenceDTO)
{
using (var uow = new UnitOfWork())
{
//verific daca userul care modifica conferinta este cel care a propus, daca nu -> returnez null
var userConferenceRepo = uow.getRepository <User_Conference>();
var isUserProposer =
userConferenceRepo.getAll()
.Any(userConference => userConference.UserId == idUser &&
userConference.Role == UserRole.Chair &&
userConference.ConferenceId == conferenceDTO.Id);
if (!isUserProposer)
{
return(null);
}
var conferenceRepo = uow.getRepository <Conference>();
conferenceRepo.update(conferenceDTO.Id, converter.convertToPOCOModel(conferenceDTO));
uow.saveChanges();
return(conferenceDTO);
}
}
/*
* verifica daca userul curent este chair sau co-chair pentru conferinta primita ca parametru, adica daca are permisiunea sa faca update la deadlineuri sau nu
* daca este chair sau co-chair la conferinta primita ca parametru, returneaza true
* altfel, returneaza false
*/
private bool updateAllowed(ConferenceDTO conferenceDTO)
{
var allowedConferences1 = ctrl.getRelevantConferences(conferenceDTO.Id, "Chair");
foreach (var conf in allowedConferences1)
{
if (conf.Id == conferenceDTO.Id)
{
return(true);
}
}
var allowedConferences2 = ctrl.getRelevantConferences(conferenceDTO.Id, "CoChair");
foreach (var conf in allowedConferences2)
{
if (conf.Id == conferenceDTO.Id)
{
return(true);
}
}
return(false);
}
public ConferenceDTO AddConference(int idUser, ConferenceDTO conferenceDTO)
{
using (var uow = new UnitOfWork())
{
//adaugare in tabela conferinta
var conferenceRepo = uow.getRepository <Conference>();
conferenceDTO.Edition = conferenceRepo.getAll().Count(c => c.Name.Equals(conferenceDTO.Name)) + 1;
var conference = conferenceRepo.save(converter.convertToPOCOModel(conferenceDTO));
conferenceDTO.Id = conference.Id;
//adaugare in tabela de legatuara
var userConfereceRepo = uow.getRepository <User_Conference>();
var userConference = new User_Conference
{
ConferenceId = conferenceDTO.Id,
Role = UserRole.Chair,
UserId = idUser
};
userConfereceRepo.save(userConference);
uow.saveChanges();
return(conferenceDTO);
}
}
public ConferenceDTO updateConference(ConferenceDTO conferenceDTO)
{
return(_userConferenceService.updateConference(conferenceDTO));
}
public ConferenceDTO ModifyDescription(int idUser, ConferenceDTO conference)
{
return(_userConferenceService.ModifyDescription(idUser, conference));
}
