public DetailViewModel(OrganizerService OrganizerService)
{
Title = "Organizer detail";
Subtitle = "In this section you can see the detailed data of an organizer.";
this.OrganizerService = OrganizerService;
}
public List <TacheModelView> GetContacts(DateTime afterDate)
{
using (ITacheService Ts = new TacheService())
{
IOrganizerService Os = new OrganizerService();
List <Tache> listtache = Ts.GetAll().Where(a => a.DeadlineTache > afterDate).OrderByDescending(a => a.DeadlineTache).ToList();
List <TacheModelView> lists = new List <TacheModelView>();
// List<Tache> liststache = new List<Tache>();
// listtache = Ts.GetAll().Where(x => x.IsDeleted == false).ToList();
foreach (var item in listtache)
{
TacheModelView dvm = new TacheModelView();
dvm.IdTache = item.IdTache;
dvm.Nom = (EventManage.Models.NomTache)item.Nom;
if (item.DescTache.Length > 50)
{
var des = item.DescTache.Substring(0, 23) + " ...";
dvm.DescTache = des;
}
else
{
dvm.DescTache = item.DescTache;
}
dvm.DeadlineTache = item.DeadlineTache;
dvm.EtatdeTache = (EventManage.Models.EtatTache)item.EtatdeTache;
dvm.OrgNom = Os.GetById(item.OragnisateurFk).FirstName;
//dvm.Etat.Equals(item.Etat);
lists.Add(dvm);
}
return(lists);
}
}
public ListViewModel(OrganizerService OrganizerService)
{
Title = "Organizer dashboard";
Subtitle = "In this section you can see the list of organizers registered in the database.";
this.OrganizerService = OrganizerService;
}
public OrganizerController(
IRequestFieldExtractor extractor = null,
IOrganizerClient orgClient = null)
{
requestFieldExtractor = extractor;
orgService = new OrganizerService(orgClient);
}
public EditViewModel(OrganizerService OrganizerService)
{
Title = "Edit organizer";
Subtitle = "In this section, you can edit an organizer's data.";
this.OrganizerService = OrganizerService;
}
public async Task ShouldGetOrganizerById()
{
CreateOrganizers();
OrganizerService organizerService = new OrganizerService(_dbContext, _userManager);
OrganizerController organizerController = new OrganizerController(organizerService);
ActionResult <OrganizerVm> result1 = await organizerController.GetOrganizerAsync(1);
OrganizerVm returnedOrganizer1 = result1.Value;
Assert.AreEqual(1, returnedOrganizer1.Id);
Assert.AreEqual("Organizer 1", returnedOrganizer1.Name);
Assert.AreEqual("123456", returnedOrganizer1.OrgNumber);
Assert.AreEqual("Description", returnedOrganizer1.Description);
ActionResult <OrganizerVm> result2 = await organizerController.GetOrganizerAsync(2);
OrganizerVm returnedOrganizer2 = result2.Value;
Assert.AreEqual(2, returnedOrganizer2.Id);
Assert.AreEqual(_orgName1, returnedOrganizer2.Name);
Assert.AreEqual(_orgNummer1, returnedOrganizer2.OrgNumber);
Assert.AreEqual(_decsr1, returnedOrganizer2.Description);
}
public CreateViewModel(OrganizerService OrganizerService)
{
Title = "Create organizer";
Subtitle = "In this section you can create a new organizer.";
this.OrganizerService = OrganizerService;
}
public ActionResult Create(int id_event, EventOrganizer eventOrg)
{
OrganizerService orgs = new OrganizerService();
orgs.ParticipateToAnEvent(id_event, 2, eventOrg);
TempData["notice"] = "Participatioin to an event Send to President";
return(RedirectToAction("Index"));
}
// GET: Organizer/Delete/5
public ActionResult Delete(int id)
{
OrganizerService orgS = new OrganizerService();
orgS.removeParticipation(id, 2);
TempData["notice"] = "Participatioin to an event Successfully deleted";
return(RedirectToAction("Index"));
}
public async Task RunOrganizer_FivePhotos()
{
/// Description
/// Generates JPEG files and runs the organizer service
/// Expectation
/// The generated JPEG files are found, sorted and added to the database
var files = 5;
// Create temp JPEG files
var tempDirectory = PathHelper.GetTemporaryDirectory();
var filenames = new List <string>();
for (var i = 0; i < files; i++)
{
// Generate faux JPEG files and save names
var filepath = PathHelper.CreateImageFile(tempDirectory, ImageFormat.Jpeg);
filenames.Add(Path.GetFileName(filepath));
}
// Mock ISortService
var sortServiceMock = new Mock <ISortService>();
// Setup SortPhoto method
sortServiceMock.Setup(mock => mock.SortPhoto(It.IsAny <Photo>(), It.IsAny <string>()))
.Verifiable();
// Fetch mocked objects
var sortService = sortServiceMock.Object;
// Create IConfiguration
var configuration = CreateInMemoryConfiguration("MD5");
// Setup DbContextOptions
using var dbContext = new PhotoContext(DbOptions);
await dbContext.Database.EnsureDeletedAsync();
// Init and call OrganizerService
var organizerService = new OrganizerService(logger, configuration, sortService, dbContext);
await organizerService.RunOrganizerAsync(tempDirectory);
// Verify mock call
sortServiceMock.Verify(mock => mock.SortPhoto(It.IsAny <Photo>(), It.IsAny <string>()), Times.Exactly(files));
// Assert database is not empty and contains the generated files
Assert.NotEmpty(dbContext.Photos);
foreach (var fn in filenames)
{
Assert.NotNull(dbContext.Photos.Find(fn));
}
}
public override async Task PreRender()
{
Sponsors = await SponsorService.GetAllSponsorsAsync();
Organizers = await OrganizerService.GetAllOrganizersAsync();
Event = await EventService.GetEventByIdAsync();
await MakeCalendarSessions();
await base.PreRender();
}
public void ShouldNotGetOrganizerByIdIfDoesntExist()
{
OrganizerService organizerService = new OrganizerService(_dbContext, _userManager);
OrganizerController organizerController = new OrganizerController(organizerService);
var ex = Assert.ThrowsAsync <HttpException>(async() =>
{
ActionResult <OrganizerVm> result1 = await organizerController.GetOrganizerAsync(123);
});
Assert.That(ex.Message == "Fant ingen arrangører med id: 123");
}
public DefaultViewModel(
SponsorService SponsorService,
OrganizerService OrganizerService,
EventService EventService,
SessionService SessionService)
{
Title = "Hello from DotVVM!";
this.SponsorService = SponsorService;
this.OrganizerService = OrganizerService;
this.EventService = EventService;
this.SessionService = SessionService;
}
// GET: Organizer
public ActionResult Index()
{
OrganizerService evs = new OrganizerService();
var list = evs.getFuturEvent();
List <bool> checkexislist = new List <bool>();
foreach (var item in list)
{
checkexislist.Add(evs.checkpaticipation(item.id, 2));
}
ViewBag.listCheckParicipation = checkexislist;
return(View(list));
}
public async Task ShouldGetAdmins()
{
OrganizerService organizerService = new OrganizerService(_dbContext, _userManager);
OrganizerController organizerController = new OrganizerController(organizerService);
CreateOrganizers();
ActionResult <List <OrgAdminVm> > result = await organizerController.GetOrgAdminsAsync(3);
List <OrgAdminVm> returnedAdmins = (List <OrgAdminVm>)((OkObjectResult)result.Result).Value;
Assert.AreEqual(_user2.Entity.Id, returnedAdmins[0].Id);
}
public async Task ShoulSetOrganizerContact()
{
OrganizerService organizerService = new OrganizerService(_dbContext, _userManager);
OrganizerController organizerController = new OrganizerController(organizerService);
CreateOrganizers();
ActionResult <OrganizerVm> contact = await organizerController.SetOrganizerContactAsync(1, _user1.Entity.Id);
Organizer org1 = _dbContext.Organizers.Find(1);
Assert.AreEqual(_user1.Entity.Id, org1.ContactId);
}
public async Task ShouldGetOrganizerContact()
{
OrganizerService organizerService = new OrganizerService(_dbContext, _userManager);
OrganizerController organizerController = new OrganizerController(organizerService);
CreateOrganizers();
ActionResult <List <OrganizerVm> > result = await organizerController.GetOrganizerContactAsync(2);
List <OrganizerVm> returnedContacts = (List <OrganizerVm>)((OkObjectResult)result.Result).Value;
Assert.AreEqual(1, returnedContacts.Count);
Assert.AreEqual("Test Testesen", returnedContacts[0].ContactName);
Assert.AreEqual(_orgNummer1, returnedContacts[0].OrgNumber);
}
public void ShouldNotUpdateOrganizerWithInvalidId()
{
OrganizerService organizerService = new OrganizerService(_dbContext, _userManager);
OrganizerController organizerController = new OrganizerController(organizerService);
CreateOrganizers();
var ex = Assert.ThrowsAsync <HttpException>(async() =>
{
await organizerController.UpdateOrganizerAsync(new OrganizerVm {
Id = 123, Name = _orgName1, OrgNumber = _orgNummer1, Description = _decsr1
});
});
Assert.That(ex.Message == "Fant ikke arrangøren");
}
public async Task ShouldGetOrgsWhereUserIsAdmin()
{
OrganizerService organizerService = new OrganizerService(_dbContext, _userManager);
OrganizerController organizerController = new OrganizerController(organizerService);
CreateOrganizers();
SetUser(organizerController, _user2.Entity.Id);
ActionResult <List <OrganizerListVm> > org = await organizerController.GetOrgsWhereUserIsAdminAsync();
List <OrganizerListVm> returnedOrgs = (List <OrganizerListVm>)((OkObjectResult)org.Result).Value;
Assert.AreEqual(3, returnedOrgs[0].Id);
Assert.AreEqual(_orgName2, returnedOrgs[0].Name);
Assert.AreEqual(_orgNummer2, returnedOrgs[0].OrgNumber);
}
public void ShouldNotCreateOrganizerIfAlreadyExists()
{
OrganizerService organizerService = new OrganizerService(_dbContext, _userManager);
OrganizerController organizerController = new OrganizerController(organizerService);
CreateOrganizers();
var ex = Assert.ThrowsAsync <HttpException>(async() =>
{
await organizerController.CreateOrganizerAsync(new OrganizerVm {
Id = 2, Name = _orgName1, OrgNumber = _orgNummer1, Description = _decsr1
});
});
Assert.That(ex.Message == "Arrangøren: Org 2 eksisterer allerede");
}
public async Task ShoulRemoveOrgAdmin()
{
OrganizerService organizerService = new OrganizerService(_dbContext, _userManager);
OrganizerController organizerController = new OrganizerController(organizerService);
CreateOrganizers();
await organizerController.RemoveOrgAdminAsync(3, _user2.Entity.Id);
Organizer org = _dbContext.Organizers.Find(3);
// Check that Organizer nas no admins
Assert.IsFalse(org.Admins.Contains(_user2.Entity));
Assert.IsFalse(org.Admins.Contains(_user1.Entity));
Assert.IsFalse(org.Admins.Contains(_createdUser1.Entity));
Assert.IsFalse(org.Admins.Contains(_createdUser2.Entity));
}
public async Task ShouldSetOrgAdmin()
{
UserStore <ApplicationUser> store = new UserStore <ApplicationUser>(_dbContext);
UserManager <ApplicationUser> userManager = new UserManager <ApplicationUser>(store, null, new PasswordHasher <ApplicationUser>(), null, null, null, null, null, null);
OrganizerService organizerService = new OrganizerService(_dbContext, userManager);
OrganizerController organizerController = new OrganizerController(organizerService);
CreateOrganizers();
await organizerController.SetOrgAdminAsync(3, _user1.Entity.Id);
// Check that Admins contains only _user1 and do not contain _createdUser
Organizer org = _dbContext.Organizers.Find(3);
Assert.That(org.Admins.Contains(_user1.Entity));
Assert.IsFalse(org.Admins.Contains(_createdUser1.Entity));
}
public HttpResponseMessage Create(OrganizerCreateModel model)
{
if (model == null)
{
ModelState.AddModelError("", "You did not send any data!");
}
if (!ModelState.IsValid)
{
return(Request.CreateErrorResponse(
HttpStatusCode.BadRequest,
ModelState
));
}
IOrganizerService organizerService = new OrganizerService();
int id = organizerService.Create(model);
return(Request.CreateResponse(HttpStatusCode.Created, id));
}
public async Task ShouldUpdateOrganizer()
{
CreateOrganizers();
string newName = "Org 4";
string newOrgNummer = "4";
string decsr = "Org Descr 4";
EntityEntry <ApplicationUser> user4 = _dbContext.ApplicationUsers.Add(
new ApplicationUser
{
FirstName = "Test",
MiddleName = "",
LastName = "Testesen",
Address = "Testing gate 123",
DateOfBirth = DateTime.Now,
IsAllergic = false
}
);
OrganizerService organizerService = new OrganizerService(_dbContext, _userManager);
OrganizerController organizerController = new OrganizerController(organizerService);
OrganizerVm organizerVm = new OrganizerVm {
Id = 2, Name = newName, OrgNumber = newOrgNummer, Description = decsr, ContactName = user4.Entity.Id
};
await organizerController.UpdateOrganizerAsync(organizerVm);
// Check that only one has been changed
Organizer organizer1 = _dbContext.Organizers.Find(2);
Assert.AreEqual(newName, organizer1.Name);
Assert.AreEqual(newOrgNummer, organizer1.OrgNumber);
Assert.AreEqual(decsr, organizer1.Description);
Assert.AreEqual(user4.Entity.Id, organizer1.ContactId);
Organizer organizer2 = _dbContext.Organizers.Find(1);
Assert.AreEqual("Organizer 1", organizer2.Name);
Assert.AreEqual("123456", organizer2.OrgNumber);
Assert.AreEqual("Description", organizer2.Description);
}
private async Task GetLeagues()
{
try
{
IsRefreshing = true;
var Token = Settings.Token;
if (!string.IsNullOrWhiteSpace(Token))
{
var leagues = await OrganizerService.GetLeaguesForOrganizer(Token);
Leagues = new ObservableCollection <League>(leagues.Leagues);
}
IsRefreshing = false;
}
catch (Exception e)
{
throw e.InnerException;
}
}
public async Task ShouldGetOrganizers()
{
CreateOrganizers();
OrganizerService organizerService = new OrganizerService(_dbContext, _userManager);
OrganizerController organizerController = new OrganizerController(organizerService);
SetUser(organizerController, _createdUser1.Entity.Id);
ActionResult <List <OrganizerListVm> > result = await organizerController.GetOrganizersAsync();
List <OrganizerListVm> returnedOrganizers = result.Value;
Assert.AreEqual(3, returnedOrganizers.Count);
Assert.AreEqual(1, returnedOrganizers[0].Id);
Assert.AreEqual("Organizer 1", returnedOrganizers[0].Name);
Assert.AreEqual("123456", returnedOrganizers[0].OrgNumber);
Assert.AreEqual(2, returnedOrganizers[1].Id);
Assert.AreEqual(_orgName1, returnedOrganizers[1].Name);
Assert.AreEqual(_orgNummer1, returnedOrganizers[1].OrgNumber);
}
public async Task ShouldCreateOrganizer()
{
CreateOrganizers();
string orgName = "Org 5";
string orgNummer = "56322";
string decsr = "Org Descr 5";
EntityEntry <ApplicationUser> user = _dbContext.ApplicationUsers.Add(
new ApplicationUser
{
FirstName = "Test",
MiddleName = "",
LastName = "Testesen",
Address = "Testing gate 123",
DateOfBirth = DateTime.Now,
IsAllergic = false
}
);
OrganizerService organizerService = new OrganizerService(_dbContext, _userManager);
OrganizerController organizerController = new OrganizerController(organizerService);
OrganizerVm organizerVm = new OrganizerVm {
Name = orgName, OrgNumber = orgNummer, Description = decsr, ContactName = user.Entity.Id
};
await organizerController.CreateOrganizerAsync(organizerVm);
ActionResult <List <OrganizerListVm> > organizers = await organizerController.GetOrganizersAsync();
List <OrganizerListVm> returnedOrganizers = organizers.Value;
Organizer newOrganizer = _dbContext.Organizers.Find(4);
Assert.That(returnedOrganizers, Has.Exactly(1).Matches <OrganizerListVm>(organizer => organizer.Id == newOrganizer.Id &&
organizer.Name == newOrganizer.Name &&
organizer.OrgNumber == newOrganizer.OrgNumber
));
}
public async Task RunOrganizer_NoPhotos()
{
/// Description
/// Test the organizer with no photos
/// Expectation
/// ISortService.SortPhoto is never called. Database is empty.
// Mock ISortService
var sortServiceMock = new Mock <ISortService>();
// Setup SortPhoto method
sortServiceMock.Setup(mock => mock.SortPhoto(It.IsAny <Photo>(), It.IsAny <string>()))
.Verifiable();
// Fetch mocked objects
var sortService = sortServiceMock.Object;
// Create IConfiguration
var configuration = CreateInMemoryConfiguration("MD5");
// Create workdirectory in Temp
var tempDirectory = PathHelper.GetTemporaryDirectory();
// Setup DbContextOptions
using var dbContext = new PhotoContext(DbOptions);
await dbContext.Database.EnsureDeletedAsync();
// Init and call OrganizerService
var organizerService = new OrganizerService(logger, configuration, sortService, dbContext);
await organizerService.RunOrganizerAsync(tempDirectory);
// Verify mock call
sortServiceMock.Verify(mock => mock.SortPhoto(It.IsAny <Photo>(), It.IsAny <string>()), Times.Never);
// Assert database is empty
Assert.Empty(dbContext.Photos);
}
public async Task <HttpResponseMessage> CreateAudioFile(int songId)
{
var filesReadToProvider = await Request.Content.ReadAsMultipartAsync();
//var audioFilename = @"C:\Users\allan\Documents\musicLibrary\" + Guid.NewGuid().ToString("N") +".wav";
var stream = filesReadToProvider.Contents.First();
var fileBytes = await stream.ReadAsByteArrayAsync();
var ext = "";
var contentType = stream.Headers.ContentType.MediaType;
if (contentType == "audio/mp3")
{
ext = ".mp3";
}
else if (contentType == "audio/wav")
{
ext = ".wav";
}
else if (contentType == "audio/x-m4a")
{
ext = ".m4a";
}
else
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, "unsupported file type"));
}
var audioFileName = @"C:\Users\allan\Documents\musicLibrary\" + Guid.NewGuid().ToString("N") + ext;
File.WriteAllBytes(audioFileName, fileBytes);
IOrganizerService organizerService = new OrganizerService();
int id = organizerService.CreateAudioFile(songId, audioFileName);
return(Request.CreateResponse(HttpStatusCode.Created, id));
}
async Task SaveLeague()
{
IsBusy = true;
if (String.IsNullOrWhiteSpace(SelectedSport.Name) || String.IsNullOrWhiteSpace(SelectedSport.Id))
{
UserDialogs.Instance.Alert("Please Select a Sport", "Wrong Input");
}
else if (String.IsNullOrWhiteSpace(SelectedLeagueType.Name) || String.IsNullOrWhiteSpace(SelectedLeagueType.Id))
{
UserDialogs.Instance.Alert("Please Select a League Type", "Wrong Input");
}
else if (String.IsNullOrWhiteSpace(LeagueName))
{
UserDialogs.Instance.Alert("Please enter a Name", "Wrong Input");
}
else if (selectedStartDate > selectedEndDate)
{
UserDialogs.Instance.Alert("Start date can't be larger than End date", "Wrong Input");
}
else
{
var token = Newtonsoft.Json.JsonConvert.DeserializeObject <Token>(Settings.Token);
var organizerCity = Cities.FirstOrDefault(c => c.Id == token.Organizer.CityRefId);
var createLeagueDto = new CreateLeagueDto
{
Name = LeagueName,
Description = Description,
LeagueType = SelectedLeagueType,
Organizer = token.Organizer,
Requirements = Requirements,
RecLeagueEnd = SelectedEndDate,
RecLeagueStart = SelectedStartDate,
Sport = SelectedSport,
City = organizerCity
};
var response = await OrganizerService.CreateLeague(createLeagueDto, token.AuthToken);
if (response.Success)
{
ClearAddOrganizerPage();
await Navigation.PopAsync();
Leagues = new ObservableCollection <League>(response.Leagues);
var notificator = DependencyService.Get <IToastNotificator>();
var options = new NotificationOptions()
{
Title = "Success",
Description = "League has been Added",
};
var result = await notificator.Notify(options);
}
else
{
UserDialogs.Instance.Alert("An error occured while adding the league!", "Error");
}
}
IsBusy = false;
}
