public void TestMatchByAddress()
        {
            PermitFilter filter = new PermitFilter();
            filter.Address = "825 NW 129 Ave Miami, FL 33182";
            IOpenPermitAdapter adapter = new SQLOpenPermitAdapter();

            List<Permit> permits = adapter.SearchPermits(filter);

            Assert.AreEqual(permits.Count, 1);
        }
        public void TestNoFilterMatchStatusMultipleStatuses()
        {
            PermitFilter filter = new PermitFilter();

            filter.Status = new List <StatusChoices>(new StatusChoices[] { StatusChoices.Applied, StatusChoices.Closed });
            IOpenPermitAdapter adapter = new SQLOpenPermitAdapter();
            List <Permit>      permits = adapter.SearchPermits(filter);

            Assert.AreEqual(15, permits.Count);
        }
        public List <Permit> SearchPermits(PermitFilter filter)
        {
            // Only Page Filter support at the moment
            if (filter.Page == null)
            {
                return(this.GetSocrataPermits());
            }

            return(this.GetSocrataPermits(filter.Page.Limmit, filter.Page.Offset));
        }
        public void TestNoFilterMatchMechanical()
        {
            PermitFilter filter = new PermitFilter();

            filter.Types = new List <TypeChoices>(new TypeChoices[] { TypeChoices.Mechanical });
            IOpenPermitAdapter adapter = new SQLOpenPermitAdapter();
            List <Permit>      permits = adapter.SearchPermits(filter);

            Assert.AreEqual(6, permits.Count);
        }
        public List<Permit> SearchPermits(PermitFilter filter)
        {
            // Only Page Filter support at the moment
            if (filter.Page == null)
            {
                return this.GetSocrataPermits();
            }

            return this.GetSocrataPermits(filter.Page.Limmit, filter.Page.Offset);
        }
        public void TestMatchBadAddress()
        {
            PermitFilter filter = new PermitFilter();
            filter.Address = "WE$R@cdfg45";
            IOpenPermitAdapter adapter = new SQLOpenPermitAdapter();

            List<Permit> permits = adapter.SearchPermits(filter);

            Assert.IsNull(permits);

        }
        public void TestMatchByAddress()
        {
            PermitFilter filter = new PermitFilter();

            filter.Address = "825 NW 129 Ave Miami, FL 33182";
            IOpenPermitAdapter adapter = new SQLOpenPermitAdapter();

            List <Permit> permits = adapter.SearchPermits(filter);

            Assert.AreEqual(permits.Count, 1);
        }
        public void TestMatchBadAddress()
        {
            PermitFilter filter = new PermitFilter();

            filter.Address = "WE$R@cdfg45";
            IOpenPermitAdapter adapter = new SQLOpenPermitAdapter();

            List <Permit> permits = adapter.SearchPermits(filter);

            Assert.IsNull(permits);
        }
        public void TestNoFilterMatchTimeFrameClosed()
        {
            PermitFilter filter = new PermitFilter();

            filter.TimeFrame = new Tuple <StatusChoices, DateTime, DateTime>(StatusChoices.Closed,
                                                                             Convert.ToDateTime("01/01/2013"), Convert.ToDateTime("01/01/2014"));
            IOpenPermitAdapter adapter = new SQLOpenPermitAdapter();
            List <Permit>      permits = adapter.SearchPermits(filter);

            Assert.AreEqual(8, permits.Count);
        }
        public void TestNoMatchByAddress()
        {
            PermitFilter filter = new PermitFilter();

            filter.Address = "9672 SW 158th Ave Miami, FL 33196";
            IOpenPermitAdapter adapter = new SQLOpenPermitAdapter();

            List <Permit> permits = adapter.SearchPermits(filter);

            Assert.AreEqual(permits.Count, 0);
        }
        public void TestNoMatchByAddress()
        {
            PermitFilter filter = new PermitFilter();
            filter.Address = "9672 SW 158th Ave Miami, FL 33196";
            IOpenPermitAdapter adapter = new SQLOpenPermitAdapter();

            List<Permit> permits = adapter.SearchPermits(filter);

            Assert.AreEqual(permits.Count, 0);

        }
        public void TestSocrataPermitSearch()
        {
            IOpenPermitAdapter adapter = new SocrataOpenPermitAdapter();
            Page page = new Page();
            page.Offset = 0;
            page.Limmit = 10;
            PermitFilter filter = new PermitFilter();
            filter.Page = page;
            List<Permit> permits = adapter.SearchPermits(filter);

            Assert.AreEqual(permits.Count, 10);
        }
示例#13
0
        public void TestSocrataPermitSearch()
        {
            IOpenPermitAdapter adapter = new SocrataOpenPermitAdapter();
            Page page = new Page();

            page.Offset = 0;
            page.Limmit = 10;
            PermitFilter filter = new PermitFilter();

            filter.Page = page;
            List <Permit> permits = adapter.SearchPermits(filter);

            Assert.AreEqual(permits.Count, 10);
        }
        public void TestBadBox()
        {
            PermitFilter filter = new PermitFilter();
            Box          box    = new Box();

            box.MinX           = -85;
            box.MaxX           = -84;
            box.MinY           = 20;
            box.MaxY           = 21;
            filter.BoundingBox = box;
            IOpenPermitAdapter adapter = new SQLOpenPermitAdapter();
            List <Permit>      permits = adapter.SearchPermits(filter);

            Assert.AreEqual(0, permits.Count);
        }
        private List <Permit> GetBoxPermits(List <TypeChoices> types, FieldChoices fields = FieldChoices.All)
        {
            PermitFilter filter = new PermitFilter();
            Box          box    = new Box();

            box.MinX           = -81;
            box.MaxX           = -80;
            box.MinY           = 25;
            box.MaxY           = 26;
            filter.BoundingBox = box;
            filter.Types       = types;
            filter.Fields      = fields;
            IOpenPermitAdapter adapter = new SQLOpenPermitAdapter();
            List <Permit>      permits = adapter.SearchPermits(filter);

            return(permits);
        }
        private List<Permit> GetBoxPermits(List<TypeChoices> types, FieldChoices fields = FieldChoices.All)
        {
            PermitFilter filter = new PermitFilter();
            Box box = new Box();

            box.MinX = -81;
            box.MaxX = -80;
            box.MinY = 25;
            box.MaxY = 26;
            filter.BoundingBox = box;
            filter.Types = types;
            filter.Fields = fields;
            IOpenPermitAdapter adapter = new SQLOpenPermitAdapter();
            List<Permit> permits = adapter.SearchPermits(filter);

            return permits;
        }
示例#17
0
        public List <Permit> SearchPermits(PermitFilter filter)
        {
            var recordFilter = new RecordFilter();

            if (filter.PermitNumber != null)
            {
                recordFilter.customId = filter.PermitNumber;
            }
            else if (filter.Address != null)
            {
                Address   address       = new Address();
                UsAddress parsedAddress = this.ParseAddress(filter.Address);
                int       strNo;
                int.TryParse(parsedAddress.AddressNumber, out strNo);
                address.streetStart = strNo;
                address.streetName  = parsedAddress.StreetName;

                // address.xCoordinate = -82.458328247070312;
                // address.yCoordinate = 27.938003540039063;
                recordFilter.address = address;
            }

            ResultDataPaged <Record> page = this.recApi.SearchRecords(null, recordFilter, null, 0, 1000, null, null, "addresses");

            var result = new List <Permit>();

            if (page.Data != null)
            {
                foreach (var record in page.Data)
                {
                    Permit permit = this.ToPermit(record);
                    result.Add(permit);
                }
            }

            return(result);
        }
示例#18
0
        public List <Permit> SearchPermits(PermitFilter filter)
        {
            string fields     = "*";
            string conditions = string.Empty;

            switch (filter.Fields)
            {
            case FieldChoices.Geo:
                fields = "PermitNum,Latitude,Longitude";
                break;

            case FieldChoices.Recommended:
                fields = "PermitNum,MasterPermitNum,Location,Description,IssuedDate,CompletedDate" +
                         ",StatusCurrent,OriginalAddress1,OriginalAddress2,OriginalCity,OriginalState" +
                         ",OriginalZip,Jurisdiction,PermitClass,PermitClassMapped,StatusCurrentMapped" +
                         ",AppliedDate,WorkClass,WorkClassMapped,PermitType,PermitTypeMapped,PermitTypeDesc" +
                         ",StatusDate,TotalSqFt,Link,Latitude,Longitude,EstProjectCost,HousingUnits" +
                         ",PIN,ContractorCompanyName,ContractorTrade,ContractorTradeMapped,ContractorLicNum" +
                         ",ContractorStateLic";
                break;

            case FieldChoices.Optional:
                fields = "PermitNum,MasterPermitNum,Location,Description,IssuedDate,CompletedDate" +
                         ",StatusCurrent,OriginalAddress1,OriginalAddress2,OriginalCity,OriginalState" +
                         ",OriginalZip,Jurisdiction,PermitClass,PermitClassMapped,StatusCurrentMapped" +
                         ",AppliedDate,WorkClass,WorkClassMapped,PermitType,PermitTypeMapped,PermitTypeDesc" +
                         ",StatusDate,TotalSqFt,Link,Latitude,Longitude,EstProjectCost,HousingUnits" +
                         ",PIN,ContractorCompanyName,ContractorTrade,ContractorTradeMapped,ContractorLicNum" +
                         ",ContractorStateLic ,ProposedUse,AddedSqFt,RemovedSqFt,ExpiresDate,COIssuedDate" +
                         ",HoldDate,VoidDate,ProjectName,ProjectId,TotalFinishedSqFt,TotalUnfinishedSqFt" +
                         ",TotalHeatedSqFt,TotalUnheatedSqFt,TotalAccSqFt,TotalSprinkledSqFt,ExtraFields" +
                         ",Publisher,Fee,ContractorFullName,ContractorCompanyDesc,ContractorPhone" +
                         ",ContractorAddress1,ContractorAddress2,ContractorCity,ContractorState,ContractorZip" +
                         ",ContractorEmail";
                break;
            }

            if (filter.Types != null)
            {
                foreach (TypeChoices type in filter.Types)
                {
                    switch (type)
                    {
                    case TypeChoices.Master:
                        conditions += "MasterPermitNum = '0' and ";
                        break;

                    case TypeChoices.Electrical:
                        conditions += "PermitType in ('ELEC', 'MELE') and ";
                        break;

                    case TypeChoices.Plumbing:
                        conditions += "PermitType in ('PLUM', 'MPLU') and ";
                        break;

                    case TypeChoices.Mechanical:
                        conditions += "PermitType in ('MECH', 'MMEC') and ";
                        break;

                    case TypeChoices.Fire:
                        conditions += "PermitType in ('FIRE', 'MFIR') and ";
                        break;

                    case TypeChoices.Building:
                        conditions += "PermitType in ('BLDG', 'MBLD') and ";
                        break;
                    }
                }
            }

            if (filter.Status != null && filter.Status.Count > 0)
            {
                conditions += "StatusCurrentMapped IN (";

                foreach (StatusChoices status in filter.Status)
                {
                    switch (status)
                    {
                    case StatusChoices.Applied:
                        conditions += "'Application Accepted',";
                        break;

                    case StatusChoices.PlanReview:
                        conditions += "'In Review',";
                        break;

                    case StatusChoices.Issued:
                        conditions += "'Permit Issued',";
                        break;

                    case StatusChoices.Inspections:
                        conditions += "'Inspection Phase',";
                        break;

                    case StatusChoices.Closed:
                        conditions += "'Permit Finaled',";
                        break;

                    case StatusChoices.Expired:
                        conditions += "'Permit Cancelled',";
                        break;
                    }
                }

                conditions  = conditions.Remove(conditions.Length - 1);
                conditions += ") and ";
            }

            if (filter.TimeFrame != null)
            {
                switch (filter.TimeFrame.Item1)
                {
                case StatusChoices.Applied:
                    string range = "AppliedDate > '{0}' and AppliedDate < '{1}' and ";
                    conditions += string.Format(
                        range,
                        filter.TimeFrame.Item2.ToString(),
                        filter.TimeFrame.Item3.ToString());
                    break;

                case StatusChoices.Issued:
                    range       = "IssuedDate > '{0}' and IssuedDate < '{1}' and ";
                    conditions += string.Format(
                        range,
                        filter.TimeFrame.Item2.ToString(),
                        filter.TimeFrame.Item3.ToString());
                    break;

                case StatusChoices.Closed:
                    range       = "CompletedDate > '{0}' and CompletedDate < '{1}' and ";
                    conditions += string.Format(
                        range,
                        filter.TimeFrame.Item2.ToString(),
                        filter.TimeFrame.Item3.ToString());
                    break;

                case StatusChoices.Expired:
                    range       = "ExpiresDate > '{0}' and ExpiresDate < '{1}' and ";
                    conditions += string.Format(
                        range,
                        filter.TimeFrame.Item2.ToString(),
                        filter.TimeFrame.Item3.ToString());
                    break;
                }
            }

            if (filter.PermitNumber != null)
            {
                using (var db = new Database(this.connectionString, this.provider))
                {
                    return(db.Fetch <Permit>("SELECT * FROM Permit WHERE PermitNum=@0", filter.PermitNumber));
                }
            }
            else if (filter.Address != null)
            {
                dynamic addr = this.ParseAddress(filter.Address);
                if (addr == null)
                {
                    return(null);
                }

                string addressLine = addr.addressLine;
                string city        = addr.locality;
                string state       = addr.adminDistrict;
                string zip         = addr.postalCode;

                using (var db = new Database(this.connectionString, this.provider))
                {
                    string queryText = "SELECT {0} FROM Permit WHERE {1} OriginalAddress1=@0 AND " +
                                       "OriginalCity=@1 AND OriginalState=@2 AND OriginalZip=@3";
                    queryText = string.Format(queryText, fields, conditions);
                    return(db.Fetch <Permit>(
                               queryText,
                               addressLine,
                               city,
                               state,
                               zip));
                }
            }
            else if (filter.BoundingBox != null)
            {
                string wkt = this.BoundingBoxToWkt(filter.BoundingBox);
                using (var db = new Database(this.connectionString, this.provider))
                {
                    string queryBase = "SELECT {0} FROM Permit " +
                                       "WHERE {1} Location.Filter(geography::STGeomFromText('" + wkt + "', 4326))=1";

                    return(db.Fetch <Permit>(string.Format(queryBase, fields, conditions)));
                }
            }
            else
            {
                // No Filter means get all permits
                using (var db = new Database(this.connectionString, this.provider))
                {
                    string queryText = "SELECT {0} FROM Permit {1}";
                    string whereText = string.Empty;

                    if (conditions != string.Empty)
                    {
                        if (conditions.EndsWith(" and "))
                        {
                            conditions = conditions.Substring(0, conditions.Length - 5);
                        }

                        whereText = string.Format("WHERE {0}", conditions);
                    }

                    queryText = string.Format(queryText, fields, whereText);
                    return(db.Fetch <Permit>(queryText));
                }
            }
        }
        public void TestNoFilterMatchTimeFrameClosed()
        {
            PermitFilter filter = new PermitFilter();
            filter.TimeFrame = new Tuple<StatusChoices, DateTime, DateTime>(StatusChoices.Closed,
                Convert.ToDateTime("01/01/2013"), Convert.ToDateTime("01/01/2014"));
            IOpenPermitAdapter adapter = new SQLOpenPermitAdapter();
            List<Permit> permits = adapter.SearchPermits(filter);
            Assert.AreEqual(8, permits.Count);

        }
        public void TestNoFilterMatchStatusMultipleStatuses()
        {
            PermitFilter filter = new PermitFilter();
            filter.Status = new List<StatusChoices>(new StatusChoices[] { StatusChoices.Applied, StatusChoices.Closed });
            IOpenPermitAdapter adapter = new SQLOpenPermitAdapter();
            List<Permit> permits = adapter.SearchPermits(filter);
            Assert.AreEqual(15, permits.Count);

        }
        public void TestNoFilterMatchMechanical()
        {   
            PermitFilter filter = new PermitFilter();
            filter.Types = new List<TypeChoices>(new TypeChoices[] { TypeChoices.Mechanical });
            IOpenPermitAdapter adapter = new SQLOpenPermitAdapter();
            List<Permit> permits = adapter.SearchPermits(filter);
            Assert.AreEqual(6, permits.Count);

        }
        public void TestBadBox()
        {
            PermitFilter filter = new PermitFilter();
            Box box = new Box();

            box.MinX = -85;
            box.MaxX = -84;
            box.MinY = 20;
            box.MaxY = 21;
            filter.BoundingBox = box;
            IOpenPermitAdapter adapter = new SQLOpenPermitAdapter();
            List<Permit> permits = adapter.SearchPermits(filter);
            Assert.AreEqual(0, permits.Count);
        }