void IAddModifyViewForm.Add(IDTO pNewBanner)
 {
     this.txtName.Text        = String.Empty;
     this.txtDescription.Text = String.Empty;
     this.Text            = "Agregar nuevo Banner";
     this.iOriginalBanner = (AdminBannerDTO)pNewBanner;
 }
        public AdminBannerDTO GetBanner(int pId)
        {
            AdminBannerDTO lResult = new AdminBannerDTO();

            lResult = Mapper.Map <Banner, AdminBannerDTO>(iServ.Read(pId));
            return(lResult);
        }
        public IList <AdminBannerDTO> ListBanner()
        {
            IList <AdminBannerDTO> lResult = new List <AdminBannerDTO>();

            foreach (var banner in iServ.GetAll())
            {
                AdminBannerDTO lDto = Mapper.Map <Banner, AdminBannerDTO>(banner);
                lResult.Add(lDto);
            }
            return(lResult);
        }
        public void Save_AddingNewBanner_ReturnsBannerId()
        {
            // Arrange
            int    lDiId              = 1;
            int    lStid              = 1;
            int    lRssId             = 1;
            string lBannerName        = "Cosas varias";
            string lBannerDescription = "Distintas informaciones durante la mañana";


            IService <Banner>     lController    = BusinessServiceLocator.Resolve <BannerService>();
            IService <StaticText> lStController  = BusinessServiceLocator.Resolve <StaticTextService>();
            IService <Schedule>   lDiController  = BusinessServiceLocator.Resolve <ScheduleService>();
            IService <RssSource>  lRssController = BusinessServiceLocator.Resolve <RssSourceService>();


            AdminBannerDTO lResult;
            ScheduleDTO    lDiDto;
            StaticTextDTO  lStDto;
            RssSourceDTO   lRssDto;

            // Act
            lDiDto  = Mapper.Map <Schedule, ScheduleDTO>(lDiController.Get(lDiId));
            lRssDto = Mapper.Map <RssSource, RssSourceDTO>(lRssController.Get(lRssId));
            lStDto  = Mapper.Map <StaticText, StaticTextDTO>(lStController.Get(lStid));



            AdminBannerDTO lDto = new AdminBannerDTO()
            {
                Name        = lBannerName,
                Description = lBannerDescription,
                RssSources  = new List <RssSourceDTO>()
                {
                    lRssDto
                },
                ActiveIntervals = new List <ScheduleDTO>()
                {
                    lDiDto
                },
                Texts = new List <StaticTextDTO>()
                {
                    lStDto
                }
            };

            lDto.Id = lController.Save(Mapper.Map <AdminBannerDTO, Banner>(lDto));

            // Assert
            lResult = Mapper.Map <Banner, AdminBannerDTO> (lController.Get(lDto.Id));
            AssertAreEqual(lDto, lResult);
        }
            public IList <StaticTextDTO> Resolve(Banner source, AdminBannerDTO destination, IList <StaticTextDTO> destMember, ResolutionContext context)
            {
                IList <StaticTextDTO> lResult = new List <StaticTextDTO>();

                foreach (var baseItem in source.Items)
                {
                    if (baseItem.Type == "Text")
                    {
                        lResult.Add(Mapper.Map <StaticTextDTO>((StaticText)baseItem));
                    }
                }

                return(lResult);
            }
 private void btnView_Click(object sender, EventArgs e)
 {
     try
     {
         DataGridViewRow row     = dgvBanner.CurrentRow;
         AdminBannerDTO  banner  = (AdminBannerDTO)dgvBanner.GetItem(row.Index);
         BannerView      ventana = new BannerView();
         ventana.View(banner);
     }
     catch (EntidadNulaException ex)
     {
         MessageBox.Show(ex.Message, "Entidad nula", MessageBoxButtons.OK, MessageBoxIcon.Error);
     }
 }
 void IAddModifyViewForm.Modify(IDTO pBanner)
 {
     if (pBanner == null)
     {
         throw new EntidadNulaException("El Banner indicado es nulo");
         //TODO excepcion argumentexception creo
     }
     else
     {
         this.iOriginalBanner     = (AdminBannerDTO)pBanner;
         this.txtName.Text        = iOriginalBanner.Name;
         this.txtDescription.Text = iOriginalBanner.Description;
         this.Text = "Modificar Banner";
     }
 }
Exemple #8
0
 public void View(AdminBannerDTO pBanner)
 {
     if (pBanner == null)
     {
         throw new EntidadNulaException("El Banner indicado es nulo");
         //TODO excepcion argumentexception creo
     }
     else
     {
         this.txtName.Text        = pBanner.Name;
         this.txtDescription.Text = pBanner.Description;
         this.Text = "Banner: " + pBanner.Name;
         this.dgvIntervals.SetSource(pBanner.ActiveIntervals);
         this.dgvSources.SetSource(pBanner.RssSources);
         this.dgvTexts.SetSource(pBanner.Texts);
         this.ShowDialog();
     }
 }
 private void BtnAdd_Click(object sender, EventArgs e)
 {
     try
     {
         using (var controller = this.iFactory.GetController <ManageBannerHandler>())
         {
             AdminBannerDTO         banner  = new AdminBannerDTO();
             AgregarModificarBanner ventana = new AgregarModificarBanner(this.iFactory);
             if (this.dgvBanner.Add(ventana, banner))
             {
                 controller.AddBanner(banner);
                 this.CargarDataGrid();
             }
         }
     }
     catch (Exception)
     {
         //TODO faltan excepciones en business logic
         throw;
     }
 }
 private void dgvBanner_CellContentDoubleClick(object sender, DataGridViewCellEventArgs e)
 {
     try
     {
         using (var controller = this.iFactory.GetController <ManageBannerHandler>())
         {
             DataGridViewRow        row     = dgvBanner.CurrentRow;
             AdminBannerDTO         banner  = dgvBanner.GetItem(row.Index);
             AgregarModificarBanner ventana = new AgregarModificarBanner(this.iFactory);
             if (this.dgvBanner.Modify(ventana, banner))
             {
                 controller.ModifyBanner(banner);
                 this.CargarDataGrid();
             }
         }
     }
     catch (Exception)
     {
         //TODO faltan excepciones en business logic
         throw;
     }
 }
        /* {
         *   using (var serv = BusinessServiceLocator.Resolve<BannerService>())
         *   {
         *       Banner lBanner = Mapper.Map<AdminBannerDTO, Banner>(pDto);
         *       serv.Save(lBanner);
         *   }
         * }*/

        public void ModifyBanner(AdminBannerDTO pDto)
        {
        }
 public void AddBanner(AdminBannerDTO pDto)
 {
 }
 private void AssertAreEqual(AdminBannerDTO lDto, AdminBannerDTO lResult)
 {
     AssertAreEqualBase(lDto, lResult);
 }
        private void AssertAreEqualBase(AdminBannerDTO lDto, AdminBannerDTO lResult)
        {
            Assert.AreEqual(lDto.Id, lResult.Id);
            Assert.AreEqual(lDto.Name, lResult.Name);
            Assert.AreEqual(lDto.Description, lResult.Description);

            Assert.AreEqual(lDto.RssSources.Count, lResult.RssSources.Count);
            Assert.AreEqual(lDto.Texts.Count, lResult.Texts.Count);
            Assert.AreEqual(lDto.ActiveIntervals.Count, lResult.ActiveIntervals.Count);

            int i = 0;
            int j = 0;

            while ((i < lDto.RssSources.Count) && (j < lResult.RssSources.Count))
            {
                //Assert.AreEqual(lDto.RssSources[i].Id, lResult.RssSources[i].Id);
                Assert.AreEqual(lDto.RssSources[i].Title, lResult.RssSources[i].Title);
                Assert.AreEqual(lDto.RssSources[i].URL, lResult.RssSources[i].URL);
                Assert.AreEqual(lDto.RssSources[i].Description, lResult.RssSources[i].Description);

                i++;
                j++;
            }

            i = 0; j = 0;
            while ((i < lDto.Texts.Count) && (j < lResult.Texts.Count))
            {
                // Assert.AreEqual(lDto.Texts[i].Id, lResult.Texts[i].Id);
                Assert.AreEqual(lDto.Texts[i].Title, lResult.Texts[i].Title);
                Assert.AreEqual(lDto.Texts[i].Text, lResult.Texts[i].Text);
                Assert.AreEqual(lDto.Texts[i].Description, lResult.Texts[i].Description);

                i++;
                j++;
            }

            i = 0; j = 0;
            while ((i < lDto.ActiveIntervals.Count) && (j < lResult.ActiveIntervals.Count))
            {
                //  Assert.AreEqual(lDto.ActiveIntervals[i].Id, lResult.ActiveIntervals[j].Id);
                Assert.AreEqual(lDto.ActiveIntervals[i].Name, lResult.ActiveIntervals[j].Name);
                //  Assert.AreEqual(lDto.ActiveIntervals[i].CreationDate, lResult.ActiveIntervals[j].CreationDate);
                Assert.AreEqual(lDto.ActiveIntervals[i].ActiveFrom, lResult.ActiveIntervals[j].ActiveFrom);
                Assert.AreEqual(lDto.ActiveIntervals[i].ActiveUntil, lResult.ActiveIntervals[j].ActiveUntil);

                Assert.AreEqual(lDto.ActiveIntervals[i].Days.Count, lResult.ActiveIntervals[j].Days.Count);
                Assert.AreEqual(lDto.ActiveIntervals[i].ActiveHours.Count, lResult.ActiveIntervals[j].ActiveHours.Count);

                int k = 0; int l = 0;
                while ((k < lDto.ActiveIntervals[i].Days.Count) && (l < lResult.ActiveIntervals[j].Days.Count))
                {
                    Assert.AreEqual(lDto.ActiveIntervals[i].Days[k], lResult.ActiveIntervals[j].Days[l]);
                    k++; l++;
                }

                k = 0; l = 0;
                while ((k < lDto.ActiveIntervals[i].ActiveHours.Count) && (l < lResult.ActiveIntervals[j].ActiveHours.Count))
                {
                    //    Assert.AreEqual(lDto.ActiveIntervals[k].ActiveHours[i].Id, lResult.ActiveIntervals[j].ActiveHours[l].Id);
                    //   Assert.AreEqual(lDto.ActiveIntervals[k].ActiveHours[i].CreationDate, lResult.ActiveIntervals[j].ActiveHours[l].CreationDate);
                    Assert.AreEqual(lDto.ActiveIntervals[i].ActiveHours[k].StartTime, lResult.ActiveIntervals[j].ActiveHours[l].StartTime);
                    Assert.AreEqual(lDto.ActiveIntervals[i].ActiveHours[k].EndTime, lResult.ActiveIntervals[j].ActiveHours[l].EndTime);
                    k++; l++;
                }

                i++;
                j++;
            }
        }