Beispiel #1
0
        public string UpdateAllFlatType(UpdateFlatTypeModel model)
        {
            FlatService fs = new FlatService();

            if (model.TowerID == 0)
            {
                if (model.FloorID == 0)
                {
                    return("0");
                }
                else
                {
                    fs.UpdateFlatTypeAllTowerPerFloor(model);
                }
            }
            else
            {
                if (model.FloorID == 0)
                {
                    fs.UpdateFlatTypePerTowerAllFloor(model);
                }
                else
                {
                    fs.UpdateFlatTypePerTowerPerFloor(model);
                }
            }
            return("1");
        }
Beispiel #2
0
        public string GetFlatDetails(int flatid)
        {
            FlatService fservice = new FlatService();
            var         model    = fservice.GetFlatDetails(flatid);

            return(Newtonsoft.Json.JsonConvert.SerializeObject(model));
        }
        public async Task EditFlat_NullViewModel_Warning()
        {
            var flatRepoMoq = new Mock <IFlatRepository>();
            var controller  = new FlatService(flatRepoMoq.Object);
            var response    = await controller.EditFlat(null);

            Assert.Equal(ResponseStatuses.Warning, response.Status);
        }
        public async Task DeleteFlat_EmptyIdentifier_Warning()
        {
            var flatRepoMoq = new Mock <IFlatRepository>();

            var controller     = new FlatService(flatRepoMoq.Object);
            var actualResponse = await controller.DeleteFlat(0);

            Assert.Equal(ResponseStatuses.Warning, actualResponse.Status);
        }
        public async Task GetFlatFullInformation_EmptyId_Warning()
        {
            var flatRepoMoq = new Mock <IFlatRepository>();

            var controller     = new FlatService(flatRepoMoq.Object);
            var actualResponse = await controller.GetFlatFullInformation(0);

            Assert.Equal(ResponseStatuses.Warning, actualResponse.Status);
        }
        public async Task EditFlat_EmptyIdentifier_Warning()
        {
            var flatRepoMoq = new Mock <IFlatRepository>();
            var controller  = new FlatService(flatRepoMoq.Object);
            var response    = await controller.EditFlat(new ViewModels.FlatFullInformationViewModel
            {
                Id = 0
            });

            Assert.Equal(ResponseStatuses.Warning, response.Status);
        }
        public async Task EditFlat_KitchenAreaMoreThanFull_Warning(int full, int kitchen)
        {
            var flatRepoMoq = new Mock <IFlatRepository>();
            var controller  = new FlatService(flatRepoMoq.Object);
            var response    = await controller.EditFlat(new ViewModels.FlatFullInformationViewModel
            {
                Id          = 0,
                FullArea    = full,
                KitchenArea = kitchen
            });

            Assert.Equal(ResponseStatuses.Warning, response.Status);
        }
        public async Task DeleteFlat_NonEmptyIdentifier_OkResponse(int id)
        {
            var flatRepoMoq = new Mock <IFlatRepository>();

            flatRepoMoq
            .Setup(m => m.Delete(id))
            .Returns(Task.FromResult(true));

            var controller     = new FlatService(flatRepoMoq.Object);
            var actualResponse = await controller.DeleteFlat(id);

            Assert.Equal(ResponseStatuses.Ok, actualResponse.Status);
        }
Beispiel #9
0
        public IHttpActionResult Delete(int id)
        {
            bool result = new FlatService().Remove(id);

            if (result)
            {
                return(Ok());
            }
            else
            {
                return(Conflict());
            }
        }
Beispiel #10
0
        public async Task GetFlatFullInformation_ShouldThrowException()
        {
            var flatRepoMoq = new Mock <IFlatRepository>();

            flatRepoMoq
            .Setup(m => m.GetFullFlatInformation(12345))
            .Returns(Task.FromResult(new Flat
            {
                House = null
            }));

            var controller = new FlatService(flatRepoMoq.Object);
            await Assert.ThrowsAnyAsync <Exception>(async() => await controller.GetFlatFullInformation(12345));
        }
Beispiel #11
0
        public async Task EditFlat_NoFlatInRepository_Warning()
        {
            var flatRepoMoq = new Mock <IFlatRepository>();

            flatRepoMoq
            .Setup(m => m.GetById(1))
            .Returns(Task.FromResult <Flat>(null));

            var controller = new FlatService(flatRepoMoq.Object);
            var response   = await controller.EditFlat(new ViewModels.FlatFullInformationViewModel
            {
                Id = 1
            });

            Assert.Equal(ResponseStatuses.Warning, response.Status);
        }
Beispiel #12
0
        public async Task GetAllFlatsSummary_ShouldReturnException()
        {
            var flatRepoMoq = new Mock <IFlatRepository>();

            flatRepoMoq
            .Setup(m => m.GetAllFlatsWithHouseInfo())
            .Returns(Task.FromResult <IEnumerable <Flat> >
                     (
                         new List <Flat>
            {
                new Flat
                {
                    Id    = 23,
                    House = null,
                }
            }
                     ));
            var controller = new FlatService(flatRepoMoq.Object);
            await Assert.ThrowsAnyAsync <Exception>(controller.GetAllFlatsSummary);
        }
Beispiel #13
0
        public async Task GetFlatFullInformation_NonEmptyIdentifier_OkResponse(int id)
        {
            var flatRepoMoq = new Mock <IFlatRepository>();

            flatRepoMoq
            .Setup(m => m.GetFullFlatInformation(id))
            .Returns(Task.FromResult(new Flat
            {
                House    = new House {
                },
                Region   = new Region {
                },
                District = new District {
                },
            }));

            var controller     = new FlatService(flatRepoMoq.Object);
            var actualResponse = await controller.GetFlatFullInformation(id);

            Assert.Equal(ResponseStatuses.Ok, actualResponse.Status);
        }
Beispiel #14
0
        public async Task GetAllFlatsSummary_ShouldReturnOk()
        {
            var flatRepoMoq = new Mock <IFlatRepository>();

            flatRepoMoq
            .Setup(m => m.GetAllFlatsWithHouseInfo())
            .Returns(Task.FromResult <IEnumerable <Flat> >
                     (
                         new List <Flat>
            {
                new Flat
                {
                    House = new House(),
                }
            }
                     ));
            var controller = new FlatService(flatRepoMoq.Object);

            var response = await controller.GetAllFlatsSummary();

            Assert.Equal(ResponseStatuses.Ok, response.Status);
        }
Beispiel #15
0
        public async Task EditFlat_ShouldReturnOkResult()
        {
            var flatRepoMoq = new Mock <IFlatRepository>();

            flatRepoMoq
            .Setup(m => m.GetById(1))
            .Returns(Task.FromResult(new Flat
            {
            }));

            var controller = new FlatService(flatRepoMoq.Object);
            var response   = await controller.EditFlat(new ViewModels.FlatFullInformationViewModel
            {
                Id          = 1,
                FullArea    = 3,
                KitchenArea = 3,
                Floor       = 2,
                Cost        = 232424
            });

            Assert.Equal(ResponseStatuses.Ok, response.Status);
        }
 public FlatController(FlatService flatService)
 {
     _flatService = flatService;
 }
 public FlatApiController(FlatService flatService, ILogger <FlatApiController> logger)
 {
     _flatService = flatService;
     _logger      = logger;
 }
 public HomeController(FlatService flatService)
 {
     _flatService = flatService;
 }