public void UpdateFarmDetails(FarmDetails fd)
{
FarmData userData = _ctx.HttpContext.Session.GetObjectFromJson <FarmData>("FarmData");
userData.unsaved = true;
userData.farmDetails.farmName = fd.farmName;
userData.farmDetails.farmRegion = fd.farmRegion;
userData.farmDetails.soilTests = fd.soilTests;
userData.farmDetails.testingMethod = fd.testingMethod;
userData.farmDetails.manure = fd.manure;
userData.farmDetails.year = fd.year;
//change the year associated with the array
YearData yd = userData.years.FirstOrDefault();
if (yd == null)
{
YearData ny = new YearData();
ny.year = fd.year;
userData.years.Add(ny);
}
else
{
yd.year = fd.year;
}
_ctx.HttpContext.Session.SetObjectAsJson("FarmData", userData);
}
public void UpdateFieldCrop(string fldName, FieldCrop updtCrop)
{
FarmData userData = _ctx.HttpContext.Session.GetObjectFromJson <FarmData>("FarmData");
userData.unsaved = true;
YearData yd = userData.years.FirstOrDefault(y => y.year == userData.farmDetails.year);
Field fld = yd.fields.FirstOrDefault(f => f.fieldName == fldName);
FieldCrop crp = fld.crops.FirstOrDefault(m => m.id == updtCrop.id);
crp.cropId = updtCrop.cropId;
crp.yield = updtCrop.yield;
crp.reqK2o = updtCrop.reqK2o;
crp.reqN = updtCrop.reqN;
crp.stdN = updtCrop.stdN;
crp.reqP2o5 = updtCrop.reqP2o5;
crp.remK2o = updtCrop.remK2o;
crp.remN = updtCrop.remN;
crp.remP2o5 = updtCrop.remP2o5;
crp.crudeProtien = updtCrop.crudeProtien;
crp.prevCropId = updtCrop.prevCropId;
crp.cropOther = updtCrop.cropOther;
crp.coverCropHarvested = updtCrop.coverCropHarvested;
_ctx.HttpContext.Session.SetObjectAsJson("FarmData", userData);
}
public void UpdateFieldSoilTest(Field updtFld)
{
FarmData userData = _ctx.HttpContext.Session.GetObjectFromJson <FarmData>("FarmData");
userData.unsaved = true;
YearData yd = userData.years.FirstOrDefault(y => y.year == userData.farmDetails.year);
Field fld = yd.fields.FirstOrDefault(f => f.fieldName == updtFld.fieldName);
if (fld.soilTest == null)
{
fld.soilTest = new SoilTest();
}
if (updtFld.soilTest == null)
{
fld.soilTest = null;
}
else
{
fld.soilTest.sampleDate = updtFld.soilTest.sampleDate;
fld.soilTest.ValP = updtFld.soilTest.ValP;
fld.soilTest.valK = updtFld.soilTest.valK;
fld.soilTest.valNO3H = updtFld.soilTest.valNO3H;
fld.soilTest.valPH = updtFld.soilTest.valPH;
fld.soilTest.ConvertedKelownaK = updtFld.soilTest.ConvertedKelownaK;
fld.soilTest.ConvertedKelownaP = updtFld.soilTest.ConvertedKelownaP;
}
_ctx.HttpContext.Session.SetObjectAsJson("FarmData", userData);
}
public void UpdateFieldCrop(string fldName, FieldCrop updtCrop)
{
FarmData userData = _ctx.HttpContext.Session.GetObjectFromJson <FarmData>("FarmData");
userData.unsaved = true;
YearData yd = userData.years.FirstOrDefault(y => y.year == userData.farmDetails.year);
Field fld = yd.fields.FirstOrDefault(f => f.fieldName == fldName);
FieldCrop crp = fld.crops.FirstOrDefault(m => m.id == updtCrop.id);
crp.cropId = updtCrop.cropId;
crp.yield = updtCrop.yield;
crp.reqK2o = updtCrop.reqK2o;
crp.reqN = updtCrop.reqN;
crp.stdN = updtCrop.stdN;
crp.reqP2o5 = updtCrop.reqP2o5;
crp.remK2o = updtCrop.remK2o;
crp.remN = updtCrop.remN;
crp.remP2o5 = updtCrop.remP2o5;
crp.crudeProtien = updtCrop.crudeProtien;
crp.prevCropId = updtCrop.prevCropId;
crp.cropOther = updtCrop.cropOther;
crp.coverCropHarvested = updtCrop.coverCropHarvested;
// cannot be modified in the UI
crp.prevYearManureAppl_volCatCd = _sd.GetCropPrevYearManureApplVolCatCd(Convert.ToInt32(crp.cropId));
crp.yieldHarvestUnit = updtCrop.yieldHarvestUnit;
crp.yieldByHarvestUnit = updtCrop.yieldByHarvestUnit;
_ctx.HttpContext.Session.SetObjectAsJson("FarmData", userData);
}
public void UpdateFieldNutrientsFertilizer(string fldName, NutrientFertilizer updtFert)
{
FarmData userData = _ctx.HttpContext.Session.GetObjectFromJson <FarmData>("FarmData");
userData.unsaved = true;
YearData yd = userData.years.FirstOrDefault(y => y.year == userData.farmDetails.year);
Field fld = yd.fields.FirstOrDefault(f => f.fieldName == fldName);
NutrientFertilizer nf = fld.nutrients.nutrientFertilizers.FirstOrDefault(m => m.id == updtFert.id);
nf.applDate = updtFert.applDate;
nf.applMethodId = updtFert.applMethodId;
nf.applRate = updtFert.applRate;
nf.applUnitId = updtFert.applUnitId;
nf.fertilizerId = updtFert.fertilizerId;
nf.fertilizerTypeId = updtFert.fertilizerTypeId;
nf.fertK2o = updtFert.fertK2o;
nf.fertN = updtFert.fertN;
nf.fertP2o5 = updtFert.fertP2o5;
nf.customN = updtFert.customN;
nf.customP2o5 = updtFert.customP2o5;
nf.customK2o = updtFert.customK2o;
nf.liquidDensity = updtFert.liquidDensity;
nf.liquidDensityUnitId = updtFert.liquidDensityUnitId;
_ctx.HttpContext.Session.SetObjectAsJson("FarmData", userData);
}
public void AddFieldNutrientsOther(string fldName, NutrientOther newOther)
{
int nextId = 1;
FarmData userData = _ctx.HttpContext.Session.GetObjectFromJson <FarmData>("FarmData");
userData.unsaved = true;
YearData yd = userData.years.FirstOrDefault(y => y.year == userData.farmDetails.year);
Field fld = yd.fields.FirstOrDefault(f => f.fieldName == fldName);
if (fld.nutrients == null)
{
fld.nutrients = new Nutrients();
fld.nutrients.nutrientOthers = new List <NutrientOther>();
}
else
{
if (fld.nutrients.nutrientOthers == null)
{
fld.nutrients.nutrientOthers = new List <NutrientOther>();
}
}
foreach (var f in fld.nutrients.nutrientOthers)
{
nextId = nextId <= f.id ? f.id + 1 : nextId;
}
newOther.id = nextId;
fld.nutrients.nutrientOthers.Add(newOther);
_ctx.HttpContext.Session.SetObjectAsJson("FarmData", userData);
}
public AppliedStoredManure GetAppliedStoredManure(YearData yearData, FarmManure farmManure)
{
var manureStorageSystem = yearData.ManureStorageSystems.SingleOrDefault(mss => mss.Id == farmManure.sourceOfMaterialStoredSystemId);
var appliedStoredManure = GetAppliedManureFromStorageSystem(yearData, manureStorageSystem);
return(appliedStoredManure);
}
private void SaveData()
{
string dataPath = string.Format("{0}/YearData.dat", Application.persistentDataPath);
BinaryFormatter binaryFormatter = new BinaryFormatter();
FileStream fileStream;
/*==== The following lines are where I update what things are to be saved ====*/
YearData yData = new YearData();
if (ovc.inputAmt.text.Length != 0)
{
yData.overallMoney = ovc.GetAmount();
}
else
{
yData.overallMoney = int.MinValue;
}
yData.activeWeeks = ysc.activeWeeks;
yData.moneyEachWeek = new int[52];
for (int i = 0; i < 52; i++)
{
if (ysc.weekControllers[i].GoodInput())
{
yData.moneyEachWeek[i] = ysc.weekControllers[i].amountMadeThisWeek;
}
else
{
yData.moneyEachWeek[i] = int.MinValue;
}
}
/*==== End ====*/
try {
if (File.Exists(dataPath))
{
File.WriteAllText(dataPath, string.Empty);
fileStream = File.Open(dataPath, FileMode.Open);
}
else
{
fileStream = File.Create(dataPath);
}
binaryFormatter.Serialize(fileStream, yData);
fileStream.Close();
/*
* if (Application.platform == RuntimePlatform.WebGLPlayer || Application.isWebPlayer) {
* //SyncFiles();
* }
*/
}
catch (Exception e) {
//PlatformSafeMessage("Failed to Save: " + e.Message);
Debug.Log("Failed To Save: " + e.Message);
}
}
public List <FarmManure> GetFarmManures()
{
FarmData userData = _ctx.HttpContext.Session.GetObjectFromJson <FarmData>("FarmData");
YearData yd = userData.years.FirstOrDefault(y => y.year == userData.farmDetails.year);
if (yd.farmManures == null)
{
yd.farmManures = new List <FarmManure>();
}
foreach (var fm in yd.farmManures)
{
if (!fm.customized)
{
Manure man = _sd.GetManure(fm.manureId.ToString());
fm.ammonia = man.ammonia;
fm.dmid = man.dmid;
fm.manure_class = man.manure_class;
fm.moisture = man.moisture;
fm.name = man.name;
fm.nitrate = (decimal?)null;
fm.nitrogen = man.nitrogen;
fm.nminerizationid = man.nminerizationid;
fm.phosphorous = man.phosphorous;
fm.potassium = man.potassium;
fm.solid_liquid = man.solid_liquid;
}
}
return(yd.farmManures);
}
private void SendYearDataMissive(YearData data)
{
YearDataMissive missive = new YearDataMissive();
missive.data = data;
Missive.Send(missive);
}
public NutrientFertilizer GetFieldNutrientsFertilizer(string fldName, int fertId)
{
FarmData userData = _ctx.HttpContext.Session.GetObjectFromJson <FarmData>("FarmData");
YearData yd = userData.years.FirstOrDefault(y => y.year == userData.farmDetails.year);
Field fld = yd.fields.FirstOrDefault(f => f.fieldName == fldName);
NutrientFertilizer nf = fld.nutrients.nutrientFertilizers.FirstOrDefault(m => m.id == fertId);
return(nf);
}
public NutrientManure GetFieldNutrientsManure(string fldName, int manId)
{
FarmData userData = _ctx.HttpContext.Session.GetObjectFromJson <FarmData>("FarmData");
YearData yd = userData.years.FirstOrDefault(y => y.year == userData.farmDetails.year);
Field fld = yd.fields.FirstOrDefault(f => f.fieldName == fldName);
NutrientManure nm = fld.nutrients.nutrientManures.FirstOrDefault(m => m.id == manId);
return(nm);
}
public FieldCrop GetFieldCrop(string fldName, int cropId)
{
FarmData userData = _ctx.HttpContext.Session.GetObjectFromJson <FarmData>("FarmData");
YearData yd = userData.years.FirstOrDefault(y => y.year == userData.farmDetails.year);
Field fld = yd.fields.FirstOrDefault(f => f.fieldName == fldName);
FieldCrop crp = fld.crops.FirstOrDefault(m => m.id == cropId);
return(crp);
}
public AppliedStoredManure GetAppliedManureFromStorageSystem(YearData yearData, ManureStorageSystem manureStorageSystem)
{
var fieldsAppliedWithStoredManure = yearData.GetFieldsAppliedWithManure(manureStorageSystem);
var farmManureIds = yearData.GetFarmManureIds(manureStorageSystem);
var fieldAppliedManures = new List <FieldAppliedManure>();
foreach (var field in fieldsAppliedWithStoredManure)
{
var nutrientManures = field.nutrients.nutrientManures
.Where(nm => farmManureIds.Any(fm => fm == Convert.ToInt32(nm.manureId)))
.ToList();
foreach (var nutrientManure in nutrientManures)
{
var fieldAppliedManure = new FieldAppliedManure();
if (manureStorageSystem.ManureMaterialType == ManureMaterialType.Liquid)
{
var convertedRate = _manureUnitConversionCalculator
.GetLiquidUSGallonsPerAcreApplicationRate(nutrientManure.rate,
(ApplicationRateUnits)Convert.ToInt32(nutrientManure.unitId));
fieldAppliedManure.USGallonsApplied =
field.area * convertedRate;
}
else
{
var farmManure = yearData.farmManures
.Single(fm => fm.id == Convert.ToInt32(nutrientManure.manureId));
decimal convertedRate;
if (string.IsNullOrWhiteSpace(farmManure.moisture))
{
convertedRate = _manureUnitConversionCalculator
.GetSolidsTonsPerAcreApplicationRate(farmManure.manureId, nutrientManure.rate,
(ApplicationRateUnits)Convert.ToInt32(nutrientManure.unitId));
}
else
{
convertedRate = _manureUnitConversionCalculator
.GetSolidsTonsPerAcreApplicationRate(Convert.ToDecimal(farmManure.moisture),
nutrientManure.rate,
(ApplicationRateUnits)Convert.ToInt32(nutrientManure.unitId));
}
fieldAppliedManure.TonsApplied = field.area * convertedRate;
}
fieldAppliedManures.Add(fieldAppliedManure);
}
}
var appliedStoredManure = new AppliedStoredManure(fieldAppliedManures, manureStorageSystem);
return(appliedStoredManure);
}
public ManureApplicationCalculatorTests()
{
var assembly = Assembly.GetExecutingAssembly();
using (var stream = assembly.GetManifestResourceStream("Agri.CalculateService.Tests.TestData.YearDataMock.json"))
using (var reader = new StreamReader(stream))
{
string json = reader.ReadToEnd();
_yearData = JsonConvert.DeserializeObject <YearData>(json);
}
}
public void DeleteField(string name)
{
FarmData userData = _ctx.HttpContext.Session.GetObjectFromJson <FarmData>("FarmData");
userData.unsaved = true;
YearData yd = userData.years.FirstOrDefault(y => y.year == userData.farmDetails.year);
Field fld = yd.fields.FirstOrDefault(f => f.fieldName == name);
yd.fields.Remove(fld);
_ctx.HttpContext.Session.SetObjectAsJson("FarmData", userData);
}
/// <summary>
/// Resets Year Data
/// </summary>
/// <param name="numYears"></param>
private void InitYears(int numYears)
{
yearDatabase.Clear();
for (int i = 0; i < numYears; ++i)
{
YearData newYear = new YearData();
newYear.Init(1900 + i);
yearDatabase.Add(newYear);
}
mostPopulousYear = yearDatabase[0];
}
private bool LoadData()
{
string dataPath = string.Format("{0}/YearData.dat", Application.persistentDataPath);
try {
if (File.Exists(dataPath))
{
BinaryFormatter binaryFormatter = new BinaryFormatter();
FileStream fileStream = File.Open(dataPath, FileMode.Open);
/*==== The following lines are where I update what things are to be loaded ====*/
YearData newData = (YearData)binaryFormatter.Deserialize(fileStream);
if (newData.overallMoney != int.MinValue)
{
amountForYear = newData.overallMoney;
ovc.inputAmt.text = "" + newData.overallMoney;
}
for (int i = 0; i < 52; i++)
{
if (!newData.activeWeeks[i])
{
ysc.activeWeeks[i] = false;
ysc.weekControllers[i].isActive = false;
}
}
for (int i = 0; i < 52; i++)
{
if (newData.moneyEachWeek[i] != int.MinValue)
{
ysc.weekControllers[i].SetAmount(newData.moneyEachWeek[i]);
}
}
/*==== End ====*/
fileStream.Close();
return(true);
}
else
{
return(false);
}
}
catch (Exception e) {
//PlatformSafeMessage("Failed to Load: " + e.Message);
Debug.Log("Failed To Load: " + e.Message);
return(false);
}
}
public void DeleteFarmManure(int id)
{
FarmData userData = _ctx.HttpContext.Session.GetObjectFromJson <FarmData>("FarmData");
userData.unsaved = true;
YearData yd = userData.years.FirstOrDefault(y => y.year == userData.farmDetails.year);
FarmManure fm = yd.farmManures.FirstOrDefault(f => f.id == id);
yd.farmManures.Remove(fm);
_ctx.HttpContext.Session.SetObjectAsJson("FarmData", userData);
}
protected override void Reload()
{
years.Clear();
Photo [] photos = query.Store.Query((Tag [])null, null, null, null);
Array.Sort(query.Photos);
Array.Sort(photos);
if (!order_ascending)
{
Array.Reverse(query.Photos);
Array.Reverse(photos);
}
if (photos.Length > 0)
{
YearData data = new YearData();
data.Year = 0;
foreach (Photo photo in photos)
{
int current = photo.Time.Year;
if (current != data.Year)
{
data.Year = current;
data.Months = new int [12];
years.Add(data);
//Console.WriteLine ("Found Year {0}", current);
}
if (order_ascending)
{
data.Months [photo.Time.Month - 1] += 1;
}
else
{
data.Months [12 - photo.Time.Month] += 1;
}
}
}
else
{
YearData data = new YearData();
data.Year = DateTime.Now.Year;
data.Months = new int [12];
years.Add(data);
}
if (Changed != null)
{
Changed(this);
}
}
public List <Field> GetFields()
{
FarmData userData = _ctx.HttpContext.Session.GetObjectFromJson <FarmData>("FarmData");
YearData yd = userData.years.FirstOrDefault(y => y.year == userData.farmDetails.year);
if (yd.fields == null)
{
yd.fields = new List <Field>();
}
return(yd.fields);
}
public void DeleteFieldNutrientsFertilizer(string fldName, int id)
{
FarmData userData = _ctx.HttpContext.Session.GetObjectFromJson <FarmData>("FarmData");
userData.unsaved = true;
YearData yd = userData.years.FirstOrDefault(y => y.year == userData.farmDetails.year);
Field fld = yd.fields.FirstOrDefault(f => f.fieldName == fldName);
NutrientFertilizer nf = fld.nutrients.nutrientFertilizers.FirstOrDefault(m => m.id == id);
fld.nutrients.nutrientFertilizers.Remove(nf);
_ctx.HttpContext.Session.SetObjectAsJson("FarmData", userData);
}
private void OnYearData(YearDataMissive missive)
{
if (currentYearData == null)
{
currentYearData = new YearData();
}
sliderText.text = missive.data.yearLabel;
yearSlider.value = missive.data.year;
currentYearData.year = missive.data.year;
sliderText.color = Color.yellow;
CancelInvoke();
Invoke("TimedSliderTextChange", effectTimeLength);
}
public void UpdateField(Field updtFld)
{
FarmData userData = _ctx.HttpContext.Session.GetObjectFromJson <FarmData>("FarmData");
userData.unsaved = true;
YearData yd = userData.years.FirstOrDefault(y => y.year == userData.farmDetails.year);
Field fld = yd.fields.FirstOrDefault(f => f.id == updtFld.id);
fld.fieldName = updtFld.fieldName;
fld.area = updtFld.area;
fld.comment = updtFld.comment;
_ctx.HttpContext.Session.SetObjectAsJson("FarmData", userData);
}
public void SetCurrentTime(YearData data)
{
for (int i = 0; i < yearData.Length; i++)
{
if (data.year == yearData[i].year)
{
currentYear = data.year;
currentYearIndex = i;
return;
}
}
// default if not correct year
currentYear = yearData[0].year;
currentYearIndex = 0;
}
public Field GetFieldDetails(string fieldName)
{
Field fld = new Field();
FarmData userData = _ctx.HttpContext.Session.GetObjectFromJson <FarmData>("FarmData");
YearData yd = userData.years.FirstOrDefault(y => y.year == userData.farmDetails.year);
if (yd.fields == null)
{
yd.fields = new List <Field>();
}
fld = yd.fields.FirstOrDefault(y => y.fieldName == fieldName);
return(fld);
}
public AppliedManure GetAppliedManure(YearData yearData, FarmManure farmManure)
{
AppliedManure appliedManure = null;
if (farmManure.stored_imported == NutrientAnalysisTypes.Stored)
{
//Stored Manure
appliedManure = GetAppliedStoredManure(yearData, farmManure);
}
else if (farmManure.stored_imported == NutrientAnalysisTypes.Imported)
{
appliedManure = GetAppliedImportedManure(yearData, farmManure);
}
return(appliedManure);
}
public void OnEndDrag(BaseEventData eventData)
{
int currentValue = Mathf.RoundToInt(yearSlider.value);
YearData nearest = ControlManager.instance.yearData.OrderBy(x => Mathf.Abs((long)x.year - currentValue)).First();
if (nearest.year != yearSlider.value)
{
SendYearDataMissive(nearest);
ControlManager.instance.SetCurrentTime(nearest);
}
else
{
sliderText.text = nearest.yearLabel;
yearSlider.value = nearest.year;
currentYearData.year = nearest.year;
}
}
public void DeleteFieldCrop(string fldName, int id)
{
FarmData userData = _ctx.HttpContext.Session.GetObjectFromJson <FarmData>("FarmData");
userData.unsaved = true;
YearData yd = userData.years.FirstOrDefault(y => y.year == userData.farmDetails.year);
Field fld = yd.fields.FirstOrDefault(f => f.fieldName == fldName);
FieldCrop crp = fld.crops.FirstOrDefault(m => m.id == id);
fld.crops.Remove(crp);
if (fld.crops.Count() == 0)
{
fld.crops = null;
}
_ctx.HttpContext.Session.SetObjectAsJson("FarmData", userData);
}
private AppliedManure GetAppliedCollectedManure(YearData yearData, FarmManure farmManure)
{
//Since the manures ared grouped and as long as one is used to identify the field
//the farmManure is applied, we can determine the FieldAppliedManures
//We then pass the list of grouped manures in to order to aggregate the total available for application
var fieldAppliedManures = new List <FieldAppliedManure>();
var groupedManures = new List <ManagedManure>();
var farmAnimals = yearData.FarmAnimals
.Where(fa => farmManure.GroupedWithCollectedAnalysisSourceItemIds
.Where(ids => ids.SourceType == NutrientAnalysisTypes.Collected)
.Select(ids => ids.SourceId).Contains(fa.Id.Value))
.Select(fa => fa as ManagedManure)
.ToList();
groupedManures.AddRange(farmAnimals);
var farmAnimalIds = farmAnimals.Select(fa => fa.Id.GetValueOrDefault(0)).ToList();
fieldAppliedManures.AddRange(GetFieldsAppliedCollectedManureForFarmAnimals(farmAnimalIds, farmManure, yearData));
var importedManures = yearData.ImportedManures
.Where(imported => farmManure.GroupedWithCollectedAnalysisSourceItemIds
.Where(ids => ids.SourceType == NutrientAnalysisTypes.Imported)
.Select(ids => ids.SourceId).Contains(imported.Id.Value))
.Select(fa => fa as ManagedManure)
.ToList();
groupedManures.AddRange(importedManures);
var importedManure = importedManures.FirstOrDefault();
if (!fieldAppliedManures.Any() && importedManure != null)
{
fieldAppliedManures.AddRange(CalculateFieldAppliedImportedManure(yearData, farmManure, importedManure as ImportedManure));
}
var appliedCollectedManure = new AppliedGroupedManure(fieldAppliedManures,
groupedManures,
farmManure.Name)
{
ManureMaterialName = farmManure.Name
};
return(appliedCollectedManure);
}
protected override void Reload ()
{
years.Clear ();
Photo [] photos = query.Store.Query ((Tag [])null, null, null, null);
Array.Sort (query.Photos);
Array.Sort (photos);
if (!order_ascending) {
Array.Reverse (query.Photos);
Array.Reverse (photos);
}
if (photos.Length > 0) {
YearData data = new YearData ();
data.Year = 0;
foreach (Photo photo in photos) {
int current = photo.Time.Year;
if (current != data.Year) {
data.Year = current;
data.Months = new int [12];
years.Add (data);
//Console.WriteLine ("Found Year {0}", current);
}
if (order_ascending)
data.Months [photo.Time.Month - 1] += 1;
else
data.Months [12 - photo.Time.Month] += 1;
}
} else {
YearData data = new YearData ();
data.Year = DateTime.Now.Year;
data.Months = new int [12];
years.Add (data);
}
if (Changed != null)
Changed (this);
}
public static List<YearData> GetOverlookDriverNodeData(String CardID, String OrgID, String StartDate, String EndDate)
{
List<YearData> result = new List<YearData>();
try
{
string connectionString = ConfigurationManager.AppSettings["fleetnetbaseConnectionString"];
DataBlock dataBlock = new DataBlock(connectionString, ConfigurationManager.AppSettings["language"]);
int orgId = Convert.ToInt32(OrgID);
int cardId = Convert.ToInt32(CardID);
dataBlock.OpenConnection();
DateTime startDate = DateTime.Parse(StartDate);
DateTime endDate = DateTime.Parse(EndDate);
if (startDate.CompareTo(endDate) >= 0)
{
return null;
}
List<int> years = getYearsList(startDate, endDate);
List<int> blocks = dataBlock.cardsTable.GetAllDataBlockIds_byCardId(cardId);
int count = 0;
foreach (int year in years)
{
double py = 0;
foreach (int block in blocks)
{
py += dataBlock.plfUnitInfo.Statistics_GetYearStatistics(new DateTime(year, 1, 1), block);
}
YearData datay = new YearData();
datay.YearName = year.ToString();
datay.Percent = py.ToString();
datay.key = count;
result.Add(datay);
count++;
if (py == 0)
continue;
List<int> months = getMonthsList(year, startDate, endDate);
foreach (int month in months)
{
double pm = 0;
foreach (int block in blocks)
{
pm += dataBlock.plfUnitInfo.Statistics_GetMonthStatistics(new DateTime(year, month, 1), block);
}
YearData datam = new YearData();
datam.MonthName = getMonthName(month);
datam.Percent = pm.ToString();
datam.key = count;
result.Add(datam);
count++;
if (pm == 0)
continue;
List<int> days = getDaysList(year, month, startDate, endDate);
foreach (int day in days)
{
double p = 0;
foreach (int block in blocks)
{
p += dataBlock.plfUnitInfo.Statistics_GetDayStatistics(new DateTime(year, month, day), block);
}
if (p == 0)
continue;
YearData data = new YearData();
data.DayName = day.ToString();
data.Percent = p.ToString();
data.key = count;
result.Add(data);
count++;
}
}
}
dataBlock.CloseConnection();
if (result.Count == 0)
return null;
}
catch (Exception ex)
{
throw ex;
//return null;
}
return result;
}
