/// <summary> /// Validates the meter given by object ID. Returns JSON in the following format: /// { /// isValid: (bool), /// errors: (string[]) /// } /// </summary> /// <param name="meterInstId"></param> /// <returns></returns> public JsonResult IsMeterValid(int objectId) { var errors = new List<string>(); var gdalc = new GisDalc(); var meter = gdalc.GetMeterByObjectId(objectId); if (meter == null) { errors.Add("Specified meter not found; OBJECTID: " + objectId); } else { // Begin validation. // 1. Inst date must be in the past. // inst_date should be stored in local server time zone, where this app also resides, // so time zones should not be an issue. if (!meter.inst_date.HasValue || meter.inst_date.Value > DateTime.Now) { errors.Add("The installation date must be equal to the current day or before."); } if (!meter.read_date.HasValue || meter.read_date.Value > DateTime.Now) { errors.Add("The initial reading date must be equal to the current day or before."); } // 20111130: Grandfathered manufacturers/models are not validated for associations. if (!string.IsNullOrEmpty(meter.Model) && !string.IsNullOrEmpty(meter.Manufacturer)) { if (!new MeterManufacturerDalc().IsMeterAssociatedWithManufacturer(meter.Model, meter.Manufacturer)) { errors.Add("The model " + HttpUtility.HtmlEncode(meter.Model) + " is not available for manufacturer " + HttpUtility.HtmlEncode(meter.Manufacturer) + "."); } } Action<string, List<string>> validateSerial = (serial, errorList) => { if (string.IsNullOrWhiteSpace(serial)) { errorList.Add("The serial number must be entered."); } }; Action<string, string, List<string>> validateSize = (size, errorLabel, errorList) => { if (string.IsNullOrWhiteSpace(size)) { errorList.Add(string.Format("The {0} must be entered.", errorLabel)); } }; Action<double?, List<string>> validateInitialReading = (initialReading, errorList) => { if (!initialReading.HasValue) { errorList.Add("The meter installation must have an initial reading."); } }; // 20111130: Special case "Alternate Reporting" manufacturer does not // require serial/size validation. if (!meter.Manufacturer.ToLower().StartsWith("alternate reporting")) { validateSerial(meter.Serial, errors); validateSize(meter.Size, "size", errors); // Require at least one meter installation reading. validateInitialReading(meter.InitialReading, errors); } else { // Alternate reporting meters require special kinds of validation // depending on the meter name. // 20111209: This is hardcoded, because we don't expect them to change // and this should only be valid/useful for about a year after deployment. // If these end up changing, consider moving this to a config table in the database. switch (meter.Model.ToLower()) { case "alternate: electric": case "alternate: natural gas": // electric and nat gas validates serial and initial reading. validateSerial(meter.Serial, errors); validateInitialReading(meter.InitialReading, errors); break; case "alternate: nozzle package": validateSize(meter.Size, "rate", errors); validateInitialReading(meter.InitialReading, errors); break; case "alternate: third party": // Third party validates none of this. break; } } // Require: (manu && model) || (gf_manu && gf_model) if ((string.IsNullOrWhiteSpace(meter.Manufacturer) || string.IsNullOrWhiteSpace(meter.Model)) && (string.IsNullOrWhiteSpace(meter.Gf_Manu) || string.IsNullOrWhiteSpace(meter.Gf_Model))) { errors.Add("You must choose a Manufacturer/Model or enter a Grandfathered Manufacturer/Model."); } if (string.IsNullOrEmpty(meter.Application)) { errors.Add("The meter application field cannot be blank."); } } return Json(new { isValid = errors.Count == 0, errors = errors }, JsonRequestBehavior.AllowGet); }
/// <summary> /// Returns the meter whose meterInstId corresponds to the given meterId. /// </summary> /// <param name="meterInstId"></param> /// <returns></returns> public JsonResult GetMeter(int meterInstId) { var m = new GisDalc().GetMeter(meterInstId); if (m == null) { return Json(new JsonResponse(false, "The specified meter ID (" + meterInstId.ToString() + ") does not exist.")); } return Json(new JsonResponse(true, m), JsonRequestBehavior.AllowGet); }
/// <summary> /// Returns all property descriptions associated with the given contiguous acres id. /// </summary> /// <param name="CAId"></param> /// <returns></returns> public JsonResult GetAssociatedOwners(int CAObjectId) { // CAId here is actually OBJECTID. var caId = new GisDalc().GetContiguousAcresIdFromOBJECTID(CAObjectId); return Json(new JsonResponse(true, new { PropertyDescriptions = new PropertyDalc().GetAssociatedPropertyDescriptions(caId) }), JsonRequestBehavior.AllowGet); }
/// <summary> /// Associates contiguous acres with parcel/county combo specified in form. /// This method deletes any existing associations, so only those parcels/counties /// specified here will be associated after the function returns. /// </summary> /// <param name="form"></param> /// <returns></returns> public JsonResult AssociateContiguousAcresWithParcels(FormCollection form) { try { int OBJECTID = form["contiguousAcresObjectId"].ToInteger(); int contiguousAcresId = new GisDalc().GetContiguousAcresIdFromOBJECTID(OBJECTID); string authTicket = form["authTicket"].GetString(); var user = GetUserFromAuthTicket(authTicket); if (user == null) { return Json(new JsonResponse(false, "Invalid auth ticket - unable to find user.")); } if (contiguousAcresId <= 0) { return Json(new JsonResponse(false, "Unable to find a contiguous acres definition corresponding to OBJECTID " + OBJECTID)); } string[] parcelIds = GetArrayFromFormParameter(form, "parcelIds"); string[] counties = GetArrayFromFormParameter(form, "counties"); if (parcelIds.Length == 0 || counties.Length == 0 || parcelIds.Length != counties.Length) { return Json(new JsonResponse(false, string.Format( "You must specify at least one parcel and county, and the length of the parcelIds and counties arrays must be the same (parcelIds.Length == {0}, counties.Length == {1})", parcelIds.Length, counties.Length ))); } var propDalc = new PropertyDalc(); var parcelCounties = new List<Tuple<string, string>>(); for (int i = 0; i < parcelIds.Length; i++) { parcelCounties.Add(new Tuple<string, string>(parcelIds[i], counties[i])); } propDalc.AssociateContiguousAcres(contiguousAcresId, parcelCounties, user.Id, user.ActingAsUserId ?? user.Id); return Json(new JsonResponse(true)); } catch (Exception ex) { return Json(new JsonResponse(false, ex.Message)); } }
public JsonResult EmailCAOwner(int caId, string message) { if (ActualUser == null) { return Json(new JsonResponse(false, "You are not authorized to perform that action.")); } if (string.IsNullOrWhiteSpace(message)) { return Json(new JsonResponse(false, "You must specify a message to send.")); } var ca = new GisDalc().GetContiguousAcres(caId); if (ca == null) { return Json(new JsonResponse(false, "No CA corresponding to CA ID " + caId + " was found.")); } var owner = new UserDalc().GetUser(ca.OwnerClientId); if (owner == null) { return Json(new JsonResponse(false, "No owner information found for CA ID " + caId + " (owner ID " + ca.OwnerClientId + ").")); } // Prepend some boilerplate to each message explaining to the owner // what in the world this thing is message = @"This message has been sent from the High Plains Water District website on behalf of " + ActingUser.DisplayName.Trim() + " (" + ActingUser.Email + @") regarding the contiguous acres described as '" + ca.Description + @"', which our records indicate you own. To respond, you can reply directly to this email. " + ActingUser.DisplayName.Trim() + @"'s original message follows. -------- " + message; MailHelper.Send(owner.Email, ActingUser.Email, "HPWD: Message for owner of " + ca.Description, message); return Json(new JsonResponse(true)); }
/// <summary> /// Creates a dynamic object representing the page state. /// This method will attempt to load and deserialize JSON /// from the database if it exists for this user (updating /// relevant properties appropriately), and if no existing /// JSON exists will construct a new object with which the /// user can report water usage. /// </summary> /// <returns></returns> protected dynamic GetPageStateJson(User user) { // Only update the _current_ reporting year or unsubmitted var pageStateJson = new ReportingDalc().GetReportingSummary(user.IsAdmin ? (user.ActingAsUserId ?? user.Id) : user.Id); ReportingSummary pageState = null; try { pageState = JsonConvert.DeserializeObject<ReportingSummary>(pageStateJson); } catch (Exception ex) { // There was a problem deserializing. // TODO: Notify user, possibly admins! throw; } if (pageState == null) { pageState = new ReportingSummary(); } /// Returns the volume (Item1) and a bool indicating whether rollover occurred (Item2) /// Args: meterInstallationId, meterreadings Func<int, IEnumerable<JsonMeterReading>, Tuple<int, bool>> calculateVolume = (meterInstallationId, readings) => { double runningTotal = 0d; if (readings.Count() == 0) { return new Tuple<int, bool>((int)runningTotal, false); } bool rolledOver = false; var prevReading = readings.First(); foreach (var currentReading in readings.Skip(1)) { double delta = 0; if (currentReading.reading.GetValueOrDefault() < prevReading.reading.GetValueOrDefault()) { // Rollover occurred rolledOver = true; // Retrieve the rollover value for this meter installation var rollover = new MeterDalc().GetMeterInstallations(meterInstallationId).First().RolloverValue; delta = (rollover - prevReading.reading.Value) + currentReading.reading.Value; } else { delta = currentReading.reading.GetValueOrDefault() - prevReading.reading.GetValueOrDefault(); } runningTotal += delta * (prevReading.rate.HasValue ? prevReading.rate.Value : 1); prevReading = currentReading; } return new Tuple<int, bool>((int)runningTotal, rolledOver); }; // Only show Approved CAs unless the user is an admin var contigAcres = new GisDalc().GetContiguousAcres(user, true).Where(ca => user.IsAdmin || ca.IsApproved); // Key: CA ID, Value: well ids var wellIds = new Dictionary<int, HashSet<int>>(); Dictionary<int, ContiguousAcres> validAcres = new Dictionary<int, ContiguousAcres>(); // There may be load errors that got persisted from a previous page load, but we // only want to show current ones so clear the list. pageState.loadErrors.Clear(); if (contigAcres.Count() > 0) { // Only create the service if contigAcres has stuff, because SOAP takes time var service = new GisServiceSoapClient(); foreach (var ca in contigAcres) { string result = ""; // This call is prone to failure whenever the GIS service is down. try { result = service.GetWellIDsByCA(ca.OBJECTID); } catch (Exception ex) { pageState.loadErrors.Add("Unable to load well associations for any CAs: the GIS service appears to be down!"); } try { int[] ids = JsonConvert.DeserializeObject<int[]>(result.Trim('{', '}')); wellIds[ca.caID] = new HashSet<int>(ids); validAcres[ca.caID] = ca; } catch (JsonException ex) { pageState.loadErrors.Add("Error loading CA ID " + ca.caID + ": " + ex.Message + " Service response: " + result); } } } var mdalc = new MeterDalc(); var rptgDalc = new ReportingDalc(); var wellDalc = new WellDalc(); var wells = wellDalc.GetWells(wellIds.SelectMany(x => x.Value).ToArray()); var meterInstallations = mdalc.GetMeterInstallations(wells.SelectMany(x => x.MeterInstallationIds).ToArray()).GroupBy(x => x.Id).Select(x => x.First()).ToDictionary(x => x.Id, x => x); // In addition to the wells retrieved by the spatial query, we also need to // retrieve wells attached to the meters on that initial set. wells = wells.Concat(wellDalc.GetWellsByMeterInstallationIds(meterInstallations.Select(x => x.Key).ToArray())) .Distinct((a,b) => a.WellId == b.WellId); Func<int, Dictionary<int, JsonBankedWaterRecord>> getBankedWaterTable = caId => { return rptgDalc.GetHistoricalBankedWater(caId).ToDictionary(x => x.year, x => x); }; // func to populate a JsonCA in the current reporting year Func<ContiguousAcres, JsonContiguousAcres> createNewJsonCA = ca => { ca.Wells = wellDalc.GetWells(wellIds[ca.caID].ToArray()).ToArray(); var reportedVolumes = mdalc.GetReportedVolumeGallons(ca.Wells.SelectMany(w => w.MeterInstallationIds), ca.caID, CurrentReportingYear); JsonContiguousAcres ret = new JsonContiguousAcres(ca, CurrentReportingYear); ReportedVolume rvol; ret.meterReadings = new Dictionary<int, JsonMeterReadingContainer>(); MeterInstallation meter = null; foreach (var miid in ret.wells.SelectMany(x => x.meterInstallationIds).Distinct()) { meterInstallations.TryGetValue(miid, out meter); var container = new JsonMeterReadingContainer() { meterInstallationId = miid, calculatedVolumeGallons = reportedVolumes.TryGetValue(miid, out rvol) ? rvol.CalculatedVolumeGallons : 0, acceptCalculation = rvol == null || !rvol.UserRevisedVolumeUnitId.HasValue, userRevisedVolume = rvol != null && rvol.UserRevisedVolume.HasValue ? rvol.UserRevisedVolume.Value : 0, userRevisedVolumeUnitId = rvol != null && rvol.UserRevisedVolumeUnitId.HasValue ? rvol.UserRevisedVolumeUnitId.Value : new int?(), totalVolumeAcreInches = 0, isNozzlePackage = meter != null ? meter.MeterType.Description().ToLower() == "nozzle package" : false, isElectric = meter != null ? meter.MeterType.Description().ToLower() == "electric" : false, isNaturalGas = meter != null ? meter.MeterType.Description().ToLower() == "natural gas" : false, isThirdParty = meter != null ? meter.MeterType.Description().ToLower() == "bizarro-meter" : false, depthToRedbed = -99999, //squeezeValue = 0, unitId = meter != null ? meter.UnitId : null, county = meter != null ? meter.County : "", rolloverValue = meter != null ? meter.RolloverValue : 0, countyId = meter != null ? meter.CountyId : -1, meterType = meter != null ? meter.MeterType.Description() : "", nonStandardUnits = meter != null && meter.MeterType != HPEntities.Entities.Enums.MeterType.standard ? new MeterDalc().GetUnits(meter.MeterType).Description() : "", meterMultiplier = meter.Multiplier != 0 ? meter.Multiplier : 1.0d // Make sure multiplier is not 0. NULL value is already converted to 1.0d in Dalc }; // Add depth to redbed if the meter is of 1) natural gas or 2) electric if (container.isNaturalGas || container.isElectric) { /* //ned skip this lookup until we really need to implement it var service1 = new GisServiceSoapClient(); string depthInString = service1.GetDepthToRedbedByMeter(miid); string depthInString = "Implement this later" double depth = -99999; if (!Double.TryParse(depthInString, out depth)) depth = -99999; */ double depth = 100; //take this out when the above works container.depthToRedbed = depth; } container.readings = (from mr in mdalc.GetReadings(miid, CurrentReportingYear).Reverse() // By default, they're ordered by reading date desc select new JsonMeterReading() { reading = mr.Reading, rate = mr.Rate, isValidBeginReading = ReportingDalc.IsMeterReadingValidBeginReading(mr, CurrentReportingYear), isValidEndReading = ReportingDalc.IsMeterReadingValidEndReading(mr, CurrentReportingYear), isAnnualTotalReading = ReportingDalc.IsMeterReadingAnnualTotal(mr, CurrentReportingYear), meterInstalltionReadingID = mr.MeterInstallationReadingId }).ToArray(); ret.meterReadings[miid] = container; } ret.meterInstallationErrors = GetMeterInstallationErrors(ca, wellIds[ca.caID]); ret.bankedWaterHistory = getBankedWaterTable(ca.caID); JsonBankedWaterRecord bankedWaterLastYear; ret.annualUsageSummary = new JsonAnnualUsageSummary() { contiguousArea = ca.AreaInAcres, annualVolume = 0, // this will only be populated after submittal allowableApplicationRate = rptgDalc.GetAllowableProductionRate(CurrentReportingYear), bankedWaterFromPreviousYear = ret.bankedWaterHistory.TryGetValue(CurrentReportingYear - 1, out bankedWaterLastYear) ? bankedWaterLastYear.bankedInches : 0 }; ret.isSubmitted = rptgDalc.IsSubmitted(ca.caID, CurrentReportingYear); ret.ownerClientId = ca.OwnerClientId; ret.isCurrentUserOwner = (this.ActualUser.ActingAsUserId ?? this.ActualUser.Id) == ca.OwnerClientId; return ret; }; JsonReportingYear year; if (pageState.years.TryGetValue(CurrentReportingYear, out year)) { // Check the existing year object and update as necessary // For now, wholly reload any CAs that have not yet been submitted. List<JsonContiguousAcres> removals = year.contiguousAcres.Where(ca => !ca.isSubmitted).ToList(); HashSet<int> submittedCaIds = new HashSet<int>(year.contiguousAcres.Where(ca => ca.isSubmitted).Select(x => x.number)); // Ensure that all the CAs are still applicable to this account - the CA IDs need // to match what's presently associated with the user account, else they're removed. foreach (var ca in removals) { year.contiguousAcres.Remove(ca); } // Add any CAs that were missing from the original state foreach (var kv in validAcres) { if (!submittedCaIds.Contains(kv.Value.caID)) { year.contiguousAcres.Add(createNewJsonCA(kv.Value)); } for (int i = 0; i < year.contiguousAcres.Count; i++) { if (year.contiguousAcres[i].number == kv.Value.caID) { year.contiguousAcres[i].meterInstallationErrors = GetMeterInstallationErrors(kv.Value, wellIds[kv.Value.caID]); year.contiguousAcres[i].wells = kv.Value.Wells.Select(w => new JsonWell(w)).ToArray(); } } //year.contiguousAcres.Where(jca => jca.number == kv.Value.caID).First().meterInstallationErrors = GetMeterInstallationErrors(kv.Value, wellIds[kv.Value.caID]); } foreach (var ca in year.contiguousAcres) { // This is used on the frontend to decide whether to show the user an editable form. // Only CA owners get the editable form. ca.isCurrentUserOwner = (this.ActualUser.ActingAsUserId ?? this.ActualUser.Id) == ca.ownerClientId; } } else { // No existing year record exists; create a new one year = new JsonReportingYear(); year.contiguousAcres = validAcres.Values.Select(ca => { return createNewJsonCA(ca); }).ToList(); pageState.years[CurrentReportingYear] = year; } // Populate meterInstallations by retrieving metadata for all used meter installations HashSet<int> meterInstallationIds = new HashSet<int>((from y in pageState.years from ca in y.Value.contiguousAcres from w in ca.wells select w.meterInstallationIds).SelectMany(x => x)); // Converting this directly to a dictionary will fail in the event that a meter // is associated with wells in multiple counties. However, that case doesn't really // make any sense and would break all sorts of other things (such as meter unit conversion factors // that are specific to counties), so we're going to assume that there's always // a single county. pageState.meterInstallations = mdalc.GetMeterInstallations(meterInstallationIds.ToArray()) .GroupBy(x => x.Id) .Select(mi => new JsonMeterInstallation(mi.First())) .ToDictionary( x => x.id, x => x ); pageState.currentReportingYear = CurrentReportingYear; pageState.isReportingAllowed = IsReportingAllowed; pageState.adminOverride = ((!IsReportingAllowed) && this.ActualUser.IsAdmin); pageState.cafoLookups = rptgDalc.GetCafoLookups(); // Go through and check all the submittal states of the CAs foreach (var ca in pageState.years[CurrentReportingYear].contiguousAcres) { ca.isSubmitted = rptgDalc.IsSubmitted(ca.number, CurrentReportingYear); if (ca.isSubmitted) { // If it was a submitted CA, the banked water history table // still needs to be loaded because it wasn't set above. ca.bankedWaterHistory = getBankedWaterTable(ca.number); } } return pageState; }