Пример #1
0
        public void TestInitialize()
        {
            webApiMapper = new WebApiMapper();
            typeReq      = new TypeReqEntity
            {
                Id               = 1234,
                Name             = "Taxi - Acoso",
                TopicEntityId    = 1,
                AdditionalFields = new List <AdditionalFieldEntity> {
                    new AdditionalFieldEntity()
                }
            };
            typeReqModelOut = new TypeReqModelOut
            {
                Id   = 1234,
                Name = "Taxi - Acoso",
            };
            typeReqModelIn = new TypeReqModelIn
            {
                Id   = 1234,
                Name = "Taxi - Acoso",
            };
            additionalField = new AdditionalFieldEntity
            {
                Id              = 1234,
                Name            = "Matrícula",
                Type            = AdditionalFieldType.TEXTO.ToString(),
                Range           = "Radio Taxi - Taxi aeropuerto - Fono Taxi",
                TypeReqEntityId = 1
            };

            typeReqLogicMock  = new Mock <ITypeReqLogic>();
            typeReqController = new TypeReqController(typeReqLogicMock.Object, webApiMapper);
        }
Пример #2
0
 public void TestInitialize()
 {
     xmlImporter = new XmlImporter();
     firstArea   = new AreaEntity
     {
         Name = "Area_One",
     };
     secondArea = new AreaEntity
     {
         Name = "Area_Two",
     };
     firstTopic = new TopicEntity
     {
         Name         = "Topic_One",
         AreaEntityId = 2,
     };
     secondTopic = new TopicEntity
     {
         Name         = "Topic_Two",
         AreaEntityId = 2,
     };
     firstTypeReq = new TypeReqEntity
     {
         Name          = "TypeReq_One",
         TopicEntityId = 1,
     };
     secondTypeReq = new TypeReqEntity
     {
         Name          = "TypeReq_Two",
         TopicEntityId = 2,
     };
 }
Пример #3
0
        public void TestInitialize()
        {
            testTypeReqEntity = new TypeReqEntity
            {
                Id               = 1234,
                Name             = "Taxi - Acoso",
                AdditionalFields = new List <AdditionalFieldEntity>()
            };

            testAFEntity = new AdditionalFieldEntity
            {
                Id              = 1234,
                Name            = "Matrícula",
                Type            = "TEXTO",
                Range           = "Radio Taxi-Taxi aeropuerto-Fono Taxi",
                TypeReqEntityId = 1
            };

            typeReqRepository = new Mock <IRepository <TypeReqEntity> >(MockBehavior.Strict);
            topicRepository   = new Mock <IRepository <TopicEntity> >(MockBehavior.Strict);
            aFRepository      = new Mock <IRepository <AdditionalFieldEntity> >(MockBehavior.Strict);
            unitOfWork        = new Mock <IUnitOfWork>();
            unitOfWork.Setup(r => r.TypeReqRepository).Returns(typeReqRepository.Object);
            unitOfWork.Setup(r => r.TopicRepository).Returns(topicRepository.Object);
            unitOfWork.Setup(r => r.AdditionalFieldRepository).Returns(aFRepository.Object);
            typeReqLogic = new TypeReqLogic(unitOfWork.Object);
        }
Пример #4
0
        public ICollection <TypeReqEntity> GetTypeReqs(ICollection <Parameter> parameters)
        {
            try
            {
                var            pathJsonFile = parameters.OfType <Parameter>().FirstOrDefault().Value;
                var            jsonText     = File.ReadAllText(pathJsonFile);
                JObject        dataIn       = JObject.Parse(jsonText);
                IList <JToken> results      = dataIn["TypeReqEntity"].Children().ToList();

                var result = new List <TypeReqEntity>();
                foreach (JToken typeReqIn in results)
                {
                    TypeReqEntity newType = new TypeReqEntity();
                    newType.Name          = typeReqIn.ToObject <TypeReqEntity>().Name;
                    newType.TopicEntityId = typeReqIn.ToObject <TypeReqEntity>().TopicEntityId;
                    result.Add(newType);
                }

                return(result);
            }
            catch (ArgumentException)
            {
                throw new ArgumentException("Path invalido");
            }
        }
Пример #5
0
        public TypeReqEntity GetByName(string name)
        {
            if (!TypeNameExists(name))
            {
                throw new ArgumentException($"Type with name: {name} doesn't exist");
            }

            TypeReqEntity ret = unitOfWork.TypeReqRepository.FirstOrDefault(u => u.Name == name && !u.IsDeleted);

            return(ret);
        }
Пример #6
0
        public TypeReqEntity GetById(int id)
        {
            if (!TypeExists(id))
            {
                throw new ArgumentException($"Type with Id: {id} doesn't exist");
            }

            TypeReqEntity ret = unitOfWork.TypeReqRepository.FirstOrDefault(u => u.Id == id && !u.IsDeleted);

            return(ret);
        }
Пример #7
0
        private void getFathersNames(RequestEntity request)
        {
            TypeReqEntity typeReq = unitOfWork.TypeReqRepository.FirstOrDefault(t => t.Id == request.RequestTypeEntityId);

            request.TypeName = typeReq.Name;
            TopicEntity topic = unitOfWork.TopicRepository.FirstOrDefault(t => t.Id == typeReq.TopicEntityId);

            request.TopicName = topic.Name;
            AreaEntity area = unitOfWork.AreaRepository.FirstOrDefault(a => a.Id == topic.AreaEntityId);

            request.AreaName = area.Name;
        }
Пример #8
0
        public void Update(TypeReqEntity tr)
        {
            if (!TypeExists(tr.Id))
            {
                throw new ArgumentException($"Type with id: {tr.Id} doesn't exist");
            }

            TypeReqEntity trToUpdate = unitOfWork.TypeReqRepository.FirstOrDefault(u => u.Id == tr.Id && !tr.IsDeleted);

            trToUpdate.Name = tr.Name;
            if (tr.AdditionalFields == null)
            {
                tr.AdditionalFields = new List <AdditionalFieldEntity>();
            }
            unitOfWork.TypeReqRepository.Update(trToUpdate);
            unitOfWork.Save();
        }
Пример #9
0
        public IEnumerable <AdditionalFieldEntity> GetAdditionalFields(int typeId)
        {
            if (!TypeExists(typeId))
            {
                throw new ArgumentException($"Type with id: {typeId} doesn't exist");
            }
            List <AdditionalFieldEntity>        result       = new List <AdditionalFieldEntity>();
            IEnumerable <AdditionalFieldEntity> addFEntities = unitOfWork.AdditionalFieldRepository.GetAll().Where(add => !add.IsDeleted);

            foreach (var entity in addFEntities)
            {
                TypeReqEntity typeReqEntity = unitOfWork.TypeReqRepository.FirstOrDefault(u => u.Id.Equals(entity.TypeReqEntityId) && !u.IsDeleted);
                if (typeReqEntity != null && typeId == typeReqEntity.Id)
                {
                    result.Add(entity);
                }
            }
            return(result);
        }
Пример #10
0
        public void TestInitialize()
        {
            testTypeReqEntity = new TypeReqEntity
            {
                Id               = 1234,
                Name             = "Taxi - Acoso",
                AdditionalFields = new AdditionalFieldEntity[] { new AdditionalFieldEntity() }
            };

            testRequestEntity = new RequestEntity
            {
                Detail              = "Un contenedor roto en la esquina de Av. Italia y Bolivia",
                ApplicantName       = "Federico Jacobo",
                Mail                = "*****@*****.**",
                Phone               = "098555666",
                RequestTypeEntityId = 1,
                TypeName            = "Contenedor roto",
                Status              = "CREADA"
            };

            testUserEntity = new UserEntity
            {
                CompleteName = "Nahuel Kleiman",
                Mail         = "*****@*****.**",
                Password     = "******",
                Requests     = new List <RequestEntity>()
            };

            requestRepository = new Mock <IRepository <RequestEntity> >(MockBehavior.Strict);
            typeReqRepository = new Mock <IRepository <TypeReqEntity> >(MockBehavior.Strict);
            userRepository    = new Mock <IRepository <UserEntity> >(MockBehavior.Strict);
            addFRepository    = new Mock <IRepository <AdditionalFieldEntity> >(MockBehavior.Strict);
            topicRepository   = new Mock <IRepository <TopicEntity> >(MockBehavior.Strict);
            areaRepository    = new Mock <IRepository <AreaEntity> >(MockBehavior.Strict);
            unitOfWork        = new Mock <IUnitOfWork>();
            unitOfWork.Setup(u => u.RequestRepository).Returns(requestRepository.Object);
            unitOfWork.Setup(r => r.TypeReqRepository).Returns(typeReqRepository.Object);
            unitOfWork.Setup(r => r.UserRepository).Returns(userRepository.Object);
            unitOfWork.Setup(r => r.AdditionalFieldRepository).Returns(addFRepository.Object);
            unitOfWork.Setup(r => r.TopicRepository).Returns(topicRepository.Object);
            unitOfWork.Setup(r => r.AreaRepository).Returns(areaRepository.Object);
            requestLogic = new RequestLogic(unitOfWork.Object);
        }
Пример #11
0
        public void TestInitialize()
        {
            area = new AreaEntity
            {
                Id     = 1,
                Name   = "Limpieza",
                Topics = new List <TopicEntity>()
            };

            topic = new TopicEntity
            {
                Id           = 1,
                Name         = "Contenedores de basura",
                AreaEntityId = 1,
                RequestTypes = new List <TypeReqEntity>()
            };

            type = new TypeReqEntity
            {
                Id               = 1,
                Name             = "Roto",
                AdditionalFields = new List <AdditionalFieldEntity>(),
                TopicEntityId    = 1
            };

            unitOfWork      = new Mock <IUnitOfWork>();
            areaRepository  = new Mock <IRepository <AreaEntity> >();
            topicRepository = new Mock <IRepository <TopicEntity> >();
            typeRepository  = new Mock <IRepository <TypeReqEntity> >();
            unitOfWork.Setup(u => u.AreaRepository).Returns(areaRepository.Object);
            unitOfWork.Setup(u => u.TopicRepository).Returns(topicRepository.Object);
            unitOfWork.Setup(u => u.TypeReqRepository).Returns(typeRepository.Object);

            var configuration = new Mock <IConfiguration>();

            configuration.Setup(c => c["DataImport:Path"]).Returns(".\\Assemblies\\DataImport");
            areaLogic   = new AreaLogic(unitOfWork.Object);
            topicLogic  = new TopicLogic(unitOfWork.Object);
            typeLogic   = new TypeReqLogic(unitOfWork.Object);
            importLogic = new ImportLogic(unitOfWork.Object, configuration.Object, areaLogic, topicLogic, typeLogic);
        }
Пример #12
0
        public int Add(TypeReqEntity tr)
        {
            if (TypeExists(tr.Id))
            {
                throw new ArgumentException($"Type with id: {tr.Id} already exist");
            }
            if (!TopicExists(tr))
            {
                throw new ArgumentException($"Topic does not exist");
            }

            /*if(tr.TopicEntityId<1 || tr.TopicEntityId > 18)
             *  throw new ArgumentException($"Topic with id: {tr.TopicEntityId} does not exist");*/
            if (TypeNameExistsInTopic(tr))
            {
                throw new ArgumentException($"There is already a type with name {tr.Name} in the topic with id: {tr.TopicEntityId}");
            }
            unitOfWork.TypeReqRepository.Add(tr);
            unitOfWork.Save();
            return(this.GetByName(tr.Name).Id);
        }
Пример #13
0
        public void Delete(int id)
        {
            if (!unitOfWork.TypeReqRepository.Exists(a => !a.IsDeleted && a.Id == id))
            {
                throw new ArgumentException($"Type with id: {id} doesn't exist");
            }

            TypeReqEntity typeReqEntity = unitOfWork.TypeReqRepository.FirstOrDefault(tr => !tr.IsDeleted && tr.Id == id);

            typeReqEntity.IsDeleted = true;
            unitOfWork.TypeReqRepository.Update(typeReqEntity);

            List <AdditionalFieldEntity> aF = GetAdditionalFieldFromType(typeReqEntity.Id);

            foreach (var a in aF)
            {
                a.IsDeleted = true;
                unitOfWork.AdditionalFieldRepository.Update(a);
            }

            unitOfWork.Save();
        }
Пример #14
0
        public void Put_Expects_Ok()
        {
            TypeReqEntity updatedTypeReq = typeReq;

            updatedTypeReq.Name = "new name";
            typeReqModelIn.Name = "new name";

            typeReqLogicMock.Setup(a => a.Update(typeReq));
            typeReqLogicMock.Setup(a => a.GetById(typeReq.Id)).Returns(updatedTypeReq);


            var result        = typeReqController.Put(typeReq.Id, typeReqModelIn);
            var updatedResult = result as CreatedResult;
            var modelOut      = updatedResult.Value as TypeReqModelOut;

            typeReqLogicMock.VerifyAll();

            Assert.IsNotNull(result);
            Assert.IsNotNull(updatedResult);
            Assert.AreEqual(modelOut.Name, typeReqModelIn.Name);
            Assert.AreEqual(201, updatedResult.StatusCode);
        }
Пример #15
0
        public void UpdateTypeReqTest()
        {
            var testTypeReqEntityUpd = new TypeReqEntity
            {
                Id               = 1234,
                Name             = "Tax",
                AdditionalFields = new AdditionalFieldEntity[] { new AdditionalFieldEntity() }
            };

            typeReqRepository.Setup(u => u.Exists(It.IsAny <Expression <Func <TypeReqEntity, bool> > >())).Returns(true);
            typeReqRepository.Setup(u => u.FirstOrDefault(It.IsAny <Expression <Func <TypeReqEntity, bool> > >())).Returns(testTypeReqEntityUpd);
            typeReqRepository.Setup(u => u.Update(It.IsAny <TypeReqEntity>())).Verifiable();
            typeReqRepository.Setup(u => u.FirstOrDefault(It.IsAny <Expression <Func <TypeReqEntity, bool> > >())).Returns(testTypeReqEntityUpd);
            unitOfWork.Setup(r => r.Save());

            typeReqLogic.Update(testTypeReqEntity);

            var result = typeReqLogic.GetById(testTypeReqEntityUpd.Id);

            typeReqRepository.VerifyAll();
            Assert.IsNotNull(result);
            Assert.AreEqual(testTypeReqEntityUpd.Name, result.Name);
        }
Пример #16
0
        public ICollection <TypeReqEntity> GetTypeReqs(ICollection <Parameter> parameters)
        {
            try
            {
                var         pathXmlFile = parameters.OfType <Parameter>().FirstOrDefault().Value;
                XmlDocument doc         = new XmlDocument();
                doc.Load(pathXmlFile);

                var result = new List <TypeReqEntity>();

                XmlNode node = doc.DocumentElement.SelectSingleNode("Types");
                foreach (XmlNode typeNode in node.ChildNodes)
                {
                    TypeReqEntity newType = new TypeReqEntity();
                    foreach (XmlNode dataNode in typeNode.ChildNodes)
                    {
                        if (dataNode.Name.Equals("Name"))
                        {
                            newType.Name = dataNode.InnerText;
                        }
                        else if (dataNode.Name.Equals("TopicEntityId"))
                        {
                            int id = 0;
                            Int32.TryParse(dataNode.InnerText, out id);
                            newType.TopicEntityId = id;
                        }
                    }
                    result.Add(newType);
                }
                return(result);
            }
            catch (ArgumentException)
            {
                throw new ArgumentException("Path Invalido");
            }
        }
Пример #17
0
        public void TestInitialize()
        {
            var options = new DbContextOptionsBuilder <Context>().UseInMemoryDatabase(databaseName: "TestDatabase").Options;

            context       = new Context(options);
            repository    = new Repository <RequestEntity>(context);
            typeReqEntity = new TypeReqEntity
            {
                Id               = 1,
                Name             = "Contenedor roto",
                AdditionalFields = new List <AdditionalFieldEntity>(),
                TopicEntityId    = 2
            };
            requestEntity = new RequestEntity
            {
                Id                  = 1,
                Detail              = "Contenedor de basura roto",
                ApplicantName       = "Nahuel Kleiman",
                Mail                = "*****@*****.**",
                Phone               = "099565656",
                RequestTypeEntityId = 3,
                Status              = "ACEPTADA"
            };
        }
Пример #18
0
 private bool TypeNameExistsInTopic(TypeReqEntity tr)
 {
     return(unitOfWork.TypeReqRepository.Exists(a => a.Name == tr.Name && !a.IsDeleted && a.TopicEntityId == tr.TopicEntityId));
 }
Пример #19
0
 private bool TopicExists(TypeReqEntity tr)
 {
     return(this.unitOfWork.TopicRepository.Exists(t => t.Id == tr.TopicEntityId));
 }