public void TestExistingSpaces(string stringGuid)
{
var userId = Guid.Parse(stringGuid);
var expected = new Space()
{
SpaceId = userId
};
var expectedServiceResult = new List <Space>()
{
expected
};
//mocking repositories
var mockSpaceRepository = new Mock <Repository <Space> >();
//mocking repositories methods
mockSpaceRepository
.Setup(n => n.Get(It.IsAny <Expression <Func <Space, bool> > >(), It.IsAny <Func <IQueryable <Space>, IOrderedQueryable <Space> > >(), string.Empty))
.Returns(expectedServiceResult);
var temporarySpaceService = new SpaceService(_dbContext.Object);
var result = temporarySpaceService.GetSpace(userId);
Assert.Equal(expected, result);
}
public IHttpActionResult Search(SpaceQuery query)
{
query.Count = true;
var result = SpaceService.Search(query);
return(Ok(new ScrollableList <Space>(result, Request.RequestUri)));
}
public string IsValidTarget(NWCreature user, NWItem item, NWObject target, Location targetLocation)
{
NWArea area = user.Area;
if (area.GetLocalInt("BUILDING_TYPE") != (int)Enumeration.BuildingType.Starship)
{
return("This repair kit may only be used inside a starship");
}
string structureID = area.GetLocalString("PC_BASE_STRUCTURE_ID");
Guid structureGuid = new Guid(structureID);
PCBaseStructure pcbs = DataService.PCBaseStructure.GetByID(structureGuid);
BaseStructure structure = DataService.BaseStructure.GetByID(pcbs.BaseStructureID);
if (structure.Durability == pcbs.Durability)
{
return("This starship is already fully repaired.");
}
bool canRepair = (PerkService.GetCreaturePerkLevel(new NWPlayer(user), PerkType.CombatRepair) >= 1);
PCBase pcBase = DataService.PCBase.GetByID(pcbs.PCBaseID);
if (!canRepair && SpaceService.IsLocationSpace(pcBase.ShipLocation))
{
return("You need the Combat Repair perk to repair ships in space.");
}
return("");
}
public SpaceController(SpaceService spaceService, SpaceTreeService spaceTreeService, IHttpRequestProvider requestProvider, ContextService contextService)
{
_spaceService = spaceService;
_spaceTreeService = spaceTreeService;
_requestProvider = requestProvider;
_contextService = contextService;
}
public async void Update_ErrorsOccurred_ShouldReturnErrorResponse()
{
var mock = new ServiceMockFacade <ISpaceService, ISpaceRepository>();
var model = new ApiSpaceServerRequestModel();
var validatorMock = new Mock <IApiSpaceServerRequestModelValidator>();
validatorMock.Setup(x => x.ValidateUpdateAsync(It.IsAny <int>(), It.IsAny <ApiSpaceServerRequestModel>())).Returns(Task.FromResult(new ValidationResult(new List <ValidationFailure>()
{
new ValidationFailure("text", "test")
})));
mock.RepositoryMock.Setup(x => x.Get(It.IsAny <int>())).Returns(Task.FromResult(new Space()));
var service = new SpaceService(mock.LoggerMock.Object,
mock.MediatorMock.Object,
mock.RepositoryMock.Object,
validatorMock.Object,
mock.DALMapperMockFactory.DALSpaceMapperMock,
mock.DALMapperMockFactory.DALSpaceSpaceFeatureMapperMock);
UpdateResponse <ApiSpaceServerResponseModel> response = await service.Update(default(int), model);
response.Should().NotBeNull();
response.Success.Should().BeFalse();
validatorMock.Verify(x => x.ValidateUpdateAsync(It.IsAny <int>(), It.IsAny <ApiSpaceServerRequestModel>()));
mock.MediatorMock.Verify(x => x.Publish(It.IsAny <SpaceUpdatedNotification>(), It.IsAny <CancellationToken>()), Times.Never());
}
public async Task Creating_An_Uncreatable_Space_Fails()
{
// arrange
var spaceRepository = new Mock <ISpaceRepository>();
spaceRepository.Setup(c => c.Add(It.IsAny <ISpace>()))
.Throws(new UnableToCreateSpaceException("nah", new Exception()));
var entityFactory = new InMemoryEntityFactory();
var spaceService = new SpaceService(entityFactory, spaceRepository.Object);
var createSpacePresenter = new CreateSpacePresenter();
var useCase = new Application.UseCases.CreateSpace(createSpacePresenter, spaceService);
var input = new CreateSpaceInput(new SpaceName("Demo"));
// act
await useCase.Execute(input);
// assert
Assert.Single(createSpacePresenter.UnableToCreate);
Assert.Empty(createSpacePresenter.CreatedSpaces);
Assert.Empty(createSpacePresenter.AlreadyExisting);
spaceRepository.Verify(c => c.Add(It.Is <ISpace>(s => s.Name.ToString() == "Demo")));
spaceRepository.VerifyNoOtherCalls();
}
public override void OnPhysicalAttacked(NWCreature self)
{
base.OnPhysicalAttacked(self);
NWCreature attacker = _.GetLastAttacker();
SpaceService.OnPhysicalAttacked(self, attacker);
}
public string PostBuilding(string value)
{
try
{
//set activity user async
ActivityFactory.SetActivityAsync(User.Identity.GetUserId());
var building = JsonConvert.DeserializeObject <Building>(value);
SpaceService service = new SpaceService(User.Identity.GetUserId());
if (!db.Buildings.Where(b => b.Id == building.Id).Any())
{
building = (Building)EntityService.OnCreateEntity(building, User.Identity.GetUserId());
db.Buildings.Add(building);
db.SaveChanges();
return(JsonConvert.SerializeObject(new { error = false, data = building }));
}
else
{
db.Entry(building).State = EntityState.Modified;
db.SaveChanges();
return(JsonConvert.SerializeObject(new { error = false, data = building }));
}
}
catch (Exception ex)
{
logger.Error(ex.Message);
return(JsonConvert.SerializeObject(new { error = true, errorMessage = "ServerError" }));
}
}
public string GetBuildings()
{
try
{
//set activity user async
ActivityFactory.SetActivityAsync(User.Identity.GetUserId());
var Buildings = new List <Building>();
SpaceService service = new SpaceService(User.Identity.GetUserId());
Buildings = db.Buildings.Where(a => a.DeletedOn == null && a.SpaceId == service.Space.Id).OrderByDescending(a => a.CreatedOn).ToList();
var BuildingsSerialized = JsonConvert.SerializeObject(new { data = Buildings },
new JsonSerializerSettings
{
ReferenceLoopHandling = ReferenceLoopHandling.Ignore
});
return(BuildingsSerialized);
}
catch (Exception ex)
{
logger.Error(ex.Message);
return(JsonConvert.SerializeObject(new { error = true, errorMessage = "ServerError" }));
}
}
/// <summary>
/// Display latest <see cref="Post"/> objects in current space.
/// </summary>
/// <param name="app">The app</param>
/// <param name="query">An object with query parameters for search, paging etc.</param>
public override ActionResult Get(Posts app, Query query)
{
var model = new PostsViewModel();
if (!IsEmbedded)
{
model.Members = SpaceService.GetMembers(WeavyContext.Current.Space.Id, new MemberQuery {
Top = 6, OrderBy = "Random", Count = true
});
model.ExternalMemberCount = SpaceService.GetMembers(WeavyContext.Current.Space.Id, new MemberQuery {
External = true, CountOnly = true
}).TotalCount ?? 0;
model.InviteCount = InviteService.Search(new InviteQuery()
{
Top = 6, OrderBy = "Random", SpaceId = app.SpaceId, CountOnly = true
}).TotalCount ?? 0;
}
query.Top = PageSizes[0] / 5; // NOTE: reduced number of items/page for better perf.
model.Posts = PostService.GetPosts(app.Id, opts: query);
if (Request.IsAjaxRequest())
{
// infinite scroll, return partial view
return(PartialView("_Posts", model.Posts));
}
// REVIEW: can we do this automagically?
return(View(IsEmbedded ? "Get.Embedded": null, model));
}
public override PlayerDialog SetUp(NWPlayer player)
{
string header;
DialogPage mainOptions;
if (!SpaceService.IsLocationSpace(SpaceService.GetShipLocation(player.Area)))
{
header = "You can only crew the guns while the ship is in space.";
mainOptions = new DialogPage(header);
}
else
{
SpaceService.CreateShipInSpace(player.Area);
header = "Crewing the ship's guns allows the ship to fire in any direction using the gunner's Piloting skill. " +
"If the target is in front of the ship, both the pilot's and the gunner's skills are added to the shot. " +
"Unlike the pilot, the gunner can select targets using the quickbar option. To stop crewing the guns, " +
"type /exit or use the quickbar button.";
mainOptions = new DialogPage(header, "Crew the guns!");
}
PlayerDialog dialog = new PlayerDialog("MainPage");
dialog.AddPage("MainPage", mainOptions);
return(dialog);
}
public void ChoosesCorrectTarget()
{
ClosestOpponentTargeter targeter = new ClosestOpponentTargeter(new Distance(1.0));
Hero attacker = new Hero(new TeamId(0), _initialHp);
Hero teammate = new Hero(new TeamId(0), _initialHp);
Hero deadOpponent = new Hero(new TeamId(1), new HitPoints(0));
Hero farOpponent = new Hero(new TeamId(2), _initialHp);
Hero closeOpponent = new Hero(new TeamId(3), _initialHp);
HeroService heroService = new HeroService(new[] { attacker, teammate, deadOpponent, farOpponent, closeOpponent });
SpaceService spaceService = new SpaceService();
spaceService.SetHeroPosition(attacker, new Position(0.0, 0.0));
spaceService.SetHeroPosition(teammate, new Position(0.1, 0.0));
spaceService.SetHeroPosition(deadOpponent, new Position(0.0, 0.2));
spaceService.SetHeroPosition(farOpponent, new Position(0.0, 0.9));
spaceService.SetHeroPosition(closeOpponent, new Position(0.3, 0.4));
GameContext context = new GameContext(heroService, new InputService(), new TimeService(), spaceService, new RandomService(new Random()));
Hero[] targets = targeter.EnumerateTargets(attacker, context).ToArray();
targets.Should().HaveCount(1);
targets.Should().HaveElementAt(0, closeOpponent);
}
public ListSpacesTest()
{
var context = new InMemoryContext();
var entityFactory = new InMemoryEntityFactory();
_spaceRepository = new SpaceRepository(context);
_spaceService = new SpaceService(entityFactory, _spaceRepository);
}
/// <summary>
/// DocumentController
/// </summary>
/// <param name="documentService"></param>
/// <param name="spaceService"></param>
public UploadController(DocumentService documentService,
SpaceService spaceService,
IHttpRequestProvider requestProvider,
IStorePolicy storePolicy)
{
_documentService = documentService;
_spaceService = spaceService;
_requestProvider = requestProvider;
}
public GitFixtures()
{
_entityFactory = new GitEntityFactory();
SpaceRepository = new SpaceRepository(_configuration.Configuration);
PageRepository = new PageRepository();
SpaceService = new SpaceService(SpaceFactory, SpaceRepository);
}
public override void DoAction(NWPlayer player, string pageName, int responseID)
{
if (responseID == 1)
{
SpaceService.DoCrewGuns(player, player.Area);
}
EndConversation();
}
private void LoadBaseDetailsPage()
{
var data = BaseService.GetPlayerTempData(GetPC());
PCBase pcBase = DataService.PCBase.GetByID(data.PCBaseID);
Area dbArea = DataService.Area.GetByResref(pcBase.AreaResref);
var owner = DataService.Player.GetByID(pcBase.PlayerID);
bool canExtendLease = BasePermissionService.HasBasePermission(GetPC(), pcBase.ID, BasePermission.CanExtendLease);
bool canCancelLease = BasePermissionService.HasBasePermission(GetPC(), pcBase.ID, BasePermission.CanCancelLease);
int dailyUpkeep = dbArea.DailyUpkeep + (int)(dbArea.DailyUpkeep * (owner.LeaseRate * 0.01f));
string header = ColorTokenService.Green("Location: ") + dbArea.Name + " (" + pcBase.Sector + ")\n\n";
header += ColorTokenService.Green("Owned By: ") + owner.CharacterName + "\n";
header += ColorTokenService.Green("Purchased: ") + pcBase.DateInitialPurchase + "\n";
header += ColorTokenService.Green("Rent Due: ") + pcBase.DateRentDue + "\n";
header += ColorTokenService.Green("Daily Upkeep: ") + dailyUpkeep + " credits\n\n";
header += "Daily upkeep may be paid up to 30 days in advance.\n";
// Starships have slightly different setups. They only pay rent when in a public starport and
// the cost is set by the starport.
if (pcBase.PCBaseTypeID == (int)Enumeration.PCBaseType.Starship)
{
canCancelLease = false;
if (SpaceService.IsLocationPublicStarport(pcBase.ShipLocation))
{
var shipLocationGuid = new Guid(pcBase.ShipLocation);
SpaceStarport starport = DataService.SpaceStarport.GetByID(shipLocationGuid);
header = ColorTokenService.Green("Location: ") + starport.Name + " (" + starport.Planet + ")\n";
header += ColorTokenService.Green("Rent Due: ") + pcBase.DateRentDue + "\n";
header += ColorTokenService.Green("Daily Upkeep: ") + starport.Cost + " credits\n\n";
}
else
{
header = "This ship has no lease currently. You only need to pay when in a starport.";
canExtendLease = false;
}
}
SetPageHeader("BaseDetailsPage", header);
const int MaxAdvancePay = 30;
DateTime newRentDate = pcBase.DateRentDue.AddDays(1);
TimeSpan ts = newRentDate - DateTime.UtcNow;
bool canPayRent = ts.TotalDays < MaxAdvancePay;
SetResponseVisible("BaseDetailsPage", 1, canPayRent && canExtendLease);
newRentDate = pcBase.DateRentDue.AddDays(7);
ts = newRentDate - DateTime.UtcNow;
canPayRent = ts.TotalDays < MaxAdvancePay;
SetResponseVisible("BaseDetailsPage", 2, canPayRent && canExtendLease);
SetResponseVisible("BaseDetailsPage", 3, canCancelLease);
}
public IHttpActionResult UpdateMember(int id, int userid, [FromBody] Access access)
{
var space = SpaceService.Get(id);
if (space == null)
{
ThrowResponseException(HttpStatusCode.NotFound, $"Space with id {id} not found.");
}
return(Ok(SpaceService.AddMember(id, userid, access)));
}
// GET: Spaces
public string GetSpaceForCurrentUser()
{
SpaceService spaceService = new SpaceService(User.Identity.GetUserId());
if (spaceService.Space != null)
{
return(JsonConvert.SerializeObject(spaceService.Space));
}
return("");
}
public HomeController(DocumentService documentService,
SpaceService spaceService,
SpaceTreeService spaceTreeService,
ContextService contextService)
{
_documentService = documentService;
_spaceService = spaceService;
_spaceTreeService = spaceTreeService;
_contextService = contextService;
}
public Space GetSpace(int id)
{
var space = SpaceService.Get(id);
if (space == null)
{
ThrowResponseException(HttpStatusCode.NotFound, "Space with id " + id + " not found");
}
return(space);
}
public IHttpActionResult RemoveMember(int id, int userid)
{
var space = SpaceService.Get(id);
if (space == null)
{
ThrowResponseException(HttpStatusCode.NotFound, $"Space with id {id} not found.");
}
return(Ok(SpaceService.RemoveMember(id, userid)));
}
public ViewController(DocumentService documentService,
SpaceService spaceService,
IStorePolicy storePolicy,
ContextService contextService)
{
_documentService = documentService;
_spaceService = spaceService;
_contextService = contextService;
_storePolicy = storePolicy;
_storePolicy = storePolicy;
}
public IHttpActionResult Delete(int id)
{
var space = SpaceService.Get(id, trashed: true);
if (space == null)
{
ThrowResponseException(HttpStatusCode.NotFound, $"Space with id {id} not found.");
}
space = SpaceService.Delete(id);
return(Ok(space));
}
public IHttpActionResult GetMembers(int id)
{
var space = SpaceService.Get(id);
if (space == null)
{
ThrowResponseException(HttpStatusCode.NotFound, $"Space with id {id} not found.");
}
var members = SpaceService.GetMembers(id);
return(Ok(members));
}
public IHttpActionResult Insert(int id, App model)
{
var space = SpaceService.Get(id);
if (space == null)
{
ThrowResponseException(HttpStatusCode.NotFound, $"Space with id {id} not found.");
}
var app = AppService.Insert(model, space);
return(Created($"{WeavyContext.Current.ApplicationPath}api/apps/{app.Id}", app));
}
public DocumentController(DocumentService documentService,
SpaceService spaceService,
SpaceTreeService spaceTreeService,
IStorePolicy storePolicy,
IHttpRequestProvider requestProvider,
ContextService contextService)
{
_documentService = documentService;
_spaceService = spaceService;
_spaceTreeService = spaceTreeService;
_requestProvider = requestProvider;
_contextService = contextService;
_storePolicy = storePolicy;
}
public InMemoryFixtures()
{
Context = new InMemoryContext();
var entityFactory = new InMemoryEntityFactory();
SpaceFactory = entityFactory;
PageFactory = entityFactory;
SpaceRepository = new SpaceRepository(Context);
PageRepository = new PageRepository(Context);
SpaceService = new SpaceService(SpaceFactory, SpaceRepository);
}
public IHttpActionResult Update(int id, Delta <Space> model)
{
var space = SpaceService.Get(id);
if (space == null)
{
ThrowResponseException(HttpStatusCode.NotFound, $"Space with id {id} not found.");
}
// patch the original space
model.Patch(space);
space = SpaceService.Update(space);
return(Ok(space));
}
public async void Get_null_record()
{
var mock = new ServiceMockFacade <ISpaceRepository>();
mock.RepositoryMock.Setup(x => x.Get(It.IsAny <int>())).Returns(Task.FromResult <Space>(null));
var service = new SpaceService(mock.LoggerMock.Object,
mock.RepositoryMock.Object,
mock.ModelValidatorMockFactory.SpaceModelValidatorMock.Object,
mock.BOLMapperMockFactory.BOLSpaceMapperMock,
mock.DALMapperMockFactory.DALSpaceMapperMock);
ApiSpaceResponseModel response = await service.Get(default(int));
response.Should().BeNull();
mock.RepositoryMock.Verify(x => x.Get(It.IsAny <int>()));
}
