public void VisitMonument(Monument monument)
{
//string result = $"<html>\n\t<body>\n\t\t<p>{monument.Name}</p>\n\t\t<p>{monument.DateOfCreate}</p>\n\t</body>\n</html>";
string result = $"<html>\n <body>\n <p>{monument.Name}</p>\n <p>{monument.DateOfCreate}</p>\n </body>\n</html>\n";
Console.WriteLine(result);
}
public EditMonument(ObservableCollection <Type> types, ObservableCollection <Tag> tags,
onEditMonument editMonumentCallback, Monument oldMonument,
onAddType addTypeCallback, onAddTag addTagCallback)
{
InitializeComponent();
Root.DataContext = this;
this.OldMonument = oldMonument;
this.NewMonument = new Monument();
this.copyOldMonument();
this.initializeEraList();
this.initializeTouristicList();
this.DateCollection = getDateCollection();
this.Tags = tags;
this.TagListBox.ItemsSource = this.Tags;
this.Types = types;
this.AddTypeCallBack = addTypeCallback;
this.AddTagCallback = addTagCallback;
this.EditMonumentCallback = editMonumentCallback;
setTagFlags();
setEraComboBoxValue();
setTouristicComboBoxValue();
setDiscoveryDate();
TextCompositionManager.AddTextInputHandler(this,
new TextCompositionEventHandler(OnTextComposition));
}
public void AssignMonuments(List <string> monumentsArgs)
{
var monumentType = monumentsArgs[0];
Monument curreMonument = this.GetMonument(monumentsArgs);
this.nations[monumentType].AddMonument(curreMonument);
}
public void FacadeUpdateCallCount()
{
//Arrange
MockRepository mockRepository = new MockRepository();
MonumentController monumentController = new MonumentController(mockRepository);
Monument dummyMonument = new Monument()
{
Id = 1, MonumentNaam = "Manneke pis"
};
//Act
monumentController.Post(dummyMonument);
dummyMonument.MonumentNaam = "Eifeltoren";
monumentController.Put((int)dummyMonument.Id, dummyMonument);
Monument result = monumentController.Get(1);
//Assert
Assert.AreEqual(1, mockRepository.NumberOfTimesAddCalled);
Assert.AreEqual(1, mockRepository.NumberOfTimesUpdateCalled);
Assert.AreEqual(dummyMonument, result);
}
public void AssignMonument(List <string> monumentArgs)
{
var type = monumentArgs[0];
var name = monumentArgs[1];
var affinity = int.Parse(monumentArgs[2]);
Monument monument = null;
switch (type)
{
case "Air":
monument = new AirMonument(name, affinity);
break;
case "Earth":
monument = new EarthMonument(name, affinity);
break;
case "Fire":
monument = new FireMonument(name, affinity);
break;
case "Water":
monument = new WaterMonument(name, affinity);
break;
default:
throw new ArgumentException();
}
nations[type].monuments.Add(monument);
}
private static void SeedMonuments(MbDbContext dbContext)
{
if (dbContext.Monuments.Any())
{
return;
}
int start = dbContext.Oblasts.OrderBy(x => x.Id).First().Id;
int end = dbContext.Oblasts.OrderBy(x => x.Id).Last().Id;
int counter = 1;
for (int i = start; i <= end; i++)
{
if (dbContext.Oblasts.Any(x => x.Id == i))
{
var monument = new Monument
{
Name = MonumentDefaultName + counter++,
OblastId = i,
ImageUrl = MonumentDefaultImageUrl,
Description = DefaultDescription,
};
dbContext.Monuments.Add(monument);
}
}
dbContext.SaveChanges();
}
public void AssignMonument(List <string> monumentArgs)
{
var type = monumentArgs[1];
Monument monument = ManumentFactory.CreateMonument(monumentArgs);
this.nations.Where(n => n.Name == type).FirstOrDefault().Monuments.Add(monument);
}
public static UIMonumentObserver InitializeMonumentObserverScript()
{
UIMonumentObserver ub = Instantiate(Resources.Load <GameObject>("UIPrefs/monumentObserver"), mycanvas.rightPanel.transform).GetComponent <UIMonumentObserver>();
Monument.SetObserver(ub);
return(ub);
}
public void RepositoryRemoveMonumentAndNotFindingIt()
{
//Arrange
IRepository <Monument, long> monumentenRepository = new MonumentenRepository();
Monument dummyMonument = new Monument()
{
Id = 1, MonumentNaam = "Manneke pis"
};
List <Monument> expectedList = new List <Monument> {
dummyMonument
};
monumentenRepository.Add(dummyMonument);
//Act
monumentenRepository.Remove((int)dummyMonument.Id);
var monumentenList = monumentenRepository.FindAll();
//Assert
Assert.IsInstanceOfType(monumentenList as List <Monument>, typeof(List <Monument>));
CollectionAssert.DoesNotContain(monumentenList as List <Monument>, dummyMonument);
}
public async Task <ActionResult <Monument> > PostMonument(Monument monument)
{
_context.Monument.Add(monument);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetMonument", new { id = monument.Id }, monument));
}
public void AssignMonument(List <string> monumentArgs)
{
string type = monumentArgs[0];
string name = monumentArgs[1];
int affinity = int.Parse(monumentArgs[2]);
Monument monument = null;
switch (type)
{
case "Air":
monument = new AirMonument(name, affinity);
break;
case "Water":
monument = new WaterMonument(name, affinity);
break;
case "Fire":
monument = new FireMonument(name, affinity);
break;
case "Earth":
monument = new EarthMonument(name, affinity);
break;
}
monuments.Add(new KeyValuePair <string, Monument>(type, monument));
}
public void AssignMonument(List <string> monumentArgs)
{
Monument monument = MonumentFactory.CreateMonument(monumentArgs);
string monumentName = monument.GetTypeName();
this.nations[monumentName].AddMonument(monument);
}
public static Monument MakeMonument(string type, string name, int affinity)
{
Monument monument = null;
switch (type)
{
case "Air":
monument = new AirMonument(name, affinity);
break;
case "Water":
monument = new WaterMonument(name, affinity);
break;
case "Fire":
monument = new FireMonument(name, affinity);
break;
case "Earth":
monument = new EarthMonument(name, affinity);
break;
}
return(monument);
}
public ActionResult Create(Monument monument, IEnumerable <HttpPostedFileBase> uploads)
{
if (ModelState.IsValid)
{
if (uploads != null)
{
foreach (var file in uploads)
{
if (file != null)
{
// получаем имя файла
string fileName = System.IO.Path.GetFileName(file.FileName);
// сохраняем файл в папку Files в проекте
try
{
file.SaveAs(Server.MapPath("~/Files/" + fileName));
unit.Pictures.Create(new Picture("/Images/" + fileName, monument));
}
catch
{
unit.Pictures.Create(new Picture("/Images/" + fileName, monument));
}
}
}
}
monument.City = unit.Cities.GetById(monument.IdCity);
unit.Monuments.Create(monument);
unit.Save();
return(RedirectToAction("Index"));
}
return(View(monument));
}
public Monument CreateMonument(List <string> monumentArgs)
{
var type = monumentArgs[0];
var name = monumentArgs[1];
var affinity = int.Parse(monumentArgs[2]);
Monument newMonument = null;
switch (type)
{
case "Air":
newMonument = new AirMonument(name, affinity);
break;
case "Water":
newMonument = new WaterMonument(name, affinity);
break;
case "Fire":
newMonument = new FireMonument(name, affinity);
break;
case "Earth":
newMonument = new EarthMonument(name, affinity);
break;
default:
throw new NotSupportedException();
}
return(newMonument);
}
public void AssignMonument(List <string> monumentArgs)
{
var monumentType = monumentArgs[1];
var monumentName = monumentArgs[2];
var affinity = int.Parse(monumentArgs[3]);
Monument currMonument = null;
switch (monumentType)
{
case "Air":
currMonument = new AirMonument(monumentName, affinity);
airNation.Add(currMonument);
break;
case "Fire":
currMonument = new FireMonument(monumentName, affinity);
fireNation.Add(currMonument);
break;
case "Water":
currMonument = new WaterMonument(monumentName, affinity);
waterNation.Add(currMonument);
break;
case "Earth":
currMonument = new EarthMonument(monumentName, affinity);
earthNation.Add(currMonument);
break;
}
}
public static Monument CreateMonument(List <string> monumentArgs)
{
Monument monument = null;
string name = monumentArgs[2];
int affinity = int.Parse(monumentArgs[3]);
switch (monumentArgs[1])
{
case "Air":
monument = new AirMonument(name, affinity);
break;
case "Water":
monument = new WaterMonument(name, affinity);
break;
case "Fire":
monument = new FireMonument(name, affinity);
break;
case "Earth":
monument = new EarthMonument(name, affinity);
break;
}
return(monument);
}
public void FacadeInsertAMonumentAndRemoveContentCheck()
{
//Arrange
MockRepository mockRepository = new MockRepository();
MonumentController monumentController = new MonumentController(mockRepository);
Monument dummyMonument = new Monument()
{
Id = 1, MonumentNaam = "Manneke pis"
};
//Act
monumentController.Post(dummyMonument);
monumentController.Delete((int)dummyMonument.Id);
List <Monument> result = (List <Monument>)monumentController.Get();
//Assert
Assert.AreEqual(1, mockRepository.NumberOfTimesAddCalled);
Assert.AreEqual(1, mockRepository.NumberOfTimesRemoveCalled);
CollectionAssert.DoesNotContain(result, dummyMonument);
}
private void ListView_MouseMove(object sender, MouseEventArgs e)
{
if (this.Cursor != ((TextBlock)((ResourceDictionary)Resources["resourceDictionary"])["CursorGrabbing"]).Cursor)
{
Point mousePos = e.GetPosition(null);
Vector diff = startPoint - mousePos;
e.Handled = true;
if (e.LeftButton == MouseButtonState.Pressed &&
(Math.Abs(diff.X) > SystemParameters.MinimumHorizontalDragDistance ||
Math.Abs(diff.Y) > SystemParameters.MinimumVerticalDragDistance))
{
// Get the dragged ListViewItem
MonumentPin monumentPin = sender as MonumentPin;
Canvas listViewItem =
FindAncestor <Canvas>((DependencyObject)e.OriginalSource);
Grid a = (Grid)monumentPin.Parent;
var b = a.Parent;
// Find the data behind the ListViewItem
Monument monument = monumentPin.MyMonument;
// Initialize the drag & drop operation
DataObject dragData = new DataObject("myFormat", monument);
DragDrop.DoDragDrop(listViewItem, dragData, DragDropEffects.Move);
}
}
}
public void RepositoryUpdateById()
{
//Arrange
IRepository <Monument, long> monumentenRepository = new MonumentenRepository();
Monument dummyMonument = new Monument()
{
Id = 1, MonumentNaam = "Manneke pis"
};
monumentenRepository.Add(dummyMonument);
//Act
dummyMonument.MonumentNaam = "Eifeltoren";
monumentenRepository.Update(dummyMonument);
var monument = monumentenRepository.Find(dummyMonument.Id);
//Assert
Assert.IsNotNull(monument);
Assert.AreEqual(monument, dummyMonument);
}
public async Task PostDeleteIntegrationTest()
{
// Arrange
var _server = new TestServer(new WebHostBuilder()
.UseStartup <Startup>());
var _client = _server.CreateClient();
// Act
var response = await _client.DeleteAsync("http://localhost:28311/api/v1/Monument/10");
response.EnsureSuccessStatusCode();
Monument dom = new Monument()
{
Id = 10, MonumentNaam = "Dom"
};
var stringPayload = JsonConvert.SerializeObject(dom);
var httpContent = new StringContent(stringPayload, Encoding.UTF8, "application/json");
var response2 = await _client.PostAsync("http://localhost:28311/api/v1/Monument", httpContent);
response2.EnsureSuccessStatusCode();
var getResponse = await _client.GetAsync("http://localhost:28311/api/v1/Monument");
getResponse.EnsureSuccessStatusCode();
var responseString = await getResponse.Content.ReadAsStringAsync();
// Assert
Assert.AreEqual("[{\"id\":11,\"monumentNaam\":\"Martinitoren\"},{\"id\":12,\"monumentNaam\":\"Don Jon\"},{\"id\":10,\"monumentNaam\":\"Dom\"}]", responseString);
}
public async Task <IActionResult> PutMonument(int id, Monument monument)
{
if (id != monument.Id)
{
return(BadRequest());
}
_context.Entry(monument).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!MonumentExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public IActionResult Details(int monumentId)
{
Monument monument = this.monumentsService.GetById(monumentId);
var viewModel = this.mapper.Map <MonumentDetailsViewModel>(monument);
if (this.User.Identity.IsAuthenticated)
{
viewModel.HasReview = this.monumentReviewsService.CheckForExistingReview(monument.Id, this.User.Identity.Name);
}
var reviews = this.mapper.Map <MonumentReviewsViewModel>(monument);
viewModel.Reviews = reviews;
List <MonumentComment> dbComments =
this.monumentCommentsService.GetAllForMonumentOrderedByDateDescending(monumentId).ToList();
var comments = new List <MonumentCommentViewModel>();
foreach (MonumentComment comment in dbComments)
{
var commentModel = this.mapper.Map <MonumentCommentViewModel>(comment);
commentModel.IsLiked = comment.Likes.Any(x => x.User.UserName == this.User.Identity.Name);
comments.Add(commentModel);
}
viewModel.Comments = comments;
return(base.View(viewModel));
}
public void AssignMonument(List <string> args)
{
Monument monument = CreateMonument(args);
string type = args[1];
nations[type].AddMonument(monument);
}
public void VerwijderenMonumentViewResultModelContentCheck()
{
//Arrange
var dummyList = _CreateDummyList();
var monumentenController = new MonumentenMockController(
new MockMonumentAgent()
);
monumentenController.setList(dummyList);
Monument pizzahut = new Monument()
{
MonumentNaam = "Pizzahut"
};
monumentenController.Toevoegen(pizzahut);
//Act
IActionResult result = monumentenController.Verwijderen(pizzahut);
var resultModel = (List <Monument>)(result as ViewResult).Model;
//Assert
Assert.IsNotNull(resultModel);
Assert.IsInstanceOfType(resultModel, typeof(List <Monument>));
CollectionAssert.DoesNotContain(resultModel, pizzahut);
}
public MonumentDetailPage(MonumentDetailViewModel viewModel)
{
InitializeComponent();
BindingContext = this.viewModel = viewModel;
this.Monument = viewModel.Monument;
}
public bool ScrollToSelected()
{
if (EnlargenedMonuments.Count == 0)
{
return(false);
}
int Id = EnlargenedMonuments[0];
int idx;
Monument selectedMonument = FilteredMonuments.SingleOrDefault(x => x.Id == Id);
if (selectedMonument == null)
{
selectedMonument = Monuments.SingleOrDefault(x => x.Id == Id);
if (selectedMonument == null)
{
return(false);
}
idx = FilteredMonuments.Count + Monuments.IndexOf(selectedMonument);
}
else
{
idx = FilteredMonuments.IndexOf(selectedMonument);
}
Scroller.ScrollToVerticalOffset(idx * 84);
return(true);
}
override public void ShutOff()
{
isObserving = false;
//
if (selectedSlotIndex != -1)
{
slots[selectedSlotIndex].GetComponent <Image>().overrideSprite = null;
selectedSlotIndex = -1;
}
observingMonument = null;
if (listHolder.activeSelf)
{
if (listSelectedItem != -1)
{
items[listSelectedItem].GetComponent <Image>().overrideSprite = null;
listSelectedItem = -1;
}
listHolder.SetActive(false);
}
if (ids != null)
{
ids.Clear();
}
//
Building.buildingObserver.ShutOff();
gameObject.SetActive(false);
}
//type (string), name (string), affinity (int).
public void AssignMonument(List <string> monumentArgs)
{
string monumentType = monumentArgs[0];
Monument currentMonument = MonumentFactory.MakeMonument(monumentArgs);
this.nations[monumentType].AddMonument(currentMonument);
}
public void VerwijderenMonumentViewResultModelSizeCheck()
{
//Arrange
var dummyList = _CreateDummyList();
var monumentenController = new MonumentenMockController(
new MockMonumentAgent()
);
monumentenController.setList(dummyList);
Monument dummyMonument = new Monument();
monumentenController.Toevoegen(dummyMonument);
//Act
IActionResult result = monumentenController.Verwijderen(dummyMonument);
var resultModel = (List <Monument>)(result as ViewResult).Model;
//Assert
Assert.IsNotNull(resultModel);
Assert.IsInstanceOfType(resultModel, typeof(List <Monument>));
Assert.AreEqual(1, resultModel.Count);
}
public virtual bool has(Monument monument)
{
throw new NotImplementedException();
}
