public List <FAdetailEntities> GetFAdetailEntities()
{
try
{
IFAdetailOperations faDetailOperation = new FAdetailOperations();
List <FAdetail> faDetailList = faDetailOperation.GetFAdetailList();
List <FAdetailEntities> faDetailEntities = MapEntities.MapIEnumerableCollection <FAdetail, FAdetailEntities>(faDetailList).ToList();
for (int faDetailCount = 0; faDetailCount < faDetailEntities.Count(); faDetailCount++)
{
faDetailEntities.ElementAt(faDetailCount).AddressDetailEntities = faDetailList.ElementAt(faDetailCount).FAaddressDetails != null?MapEntities.Map <FAaddressDetail, FAaddressDetailEntities>(faDetailList.ElementAt(faDetailCount).FAaddressDetails.ElementAt(0)) : new FAaddressDetailEntities();
faDetailEntities.ElementAt(faDetailCount).ApprovalEntities = faDetailList.ElementAt(faDetailCount).FAapprovals.ElementAt(0) != null?MapEntities.Map <FAapproval, FAapprovalEntities>(faDetailList.ElementAt(faDetailCount).FAapprovals.ElementAt(0)) : new FAapprovalEntities();
faDetailEntities.ElementAt(faDetailCount).EducationDetailEntityList = MapEntities.MapList <FAeducationDetail, FAeducationDetailEntities>(faDetailList.ElementAt(faDetailCount).FAeducationDetails.ToList());
faDetailEntities.ElementAt(faDetailCount).ExperienceDetailEntityList = MapEntities.MapList <FAexperianceDetail, FAexperianceDetailEntities>(faDetailList.ElementAt(faDetailCount).FAexperianceDetails.ToList());
faDetailEntities.ElementAt(faDetailCount).TargetDetailEntityList = MapEntities.MapList <FAtargetDetail, FAtargetDetailEntities>(faDetailList.ElementAt(faDetailCount).FAtargetDetails.ToList());
faDetailEntities.ElementAt(faDetailCount).UploadedDocumentList = MapEntities.MapList <FAuploadedDocumentDetail, FAuploadedDocumentDetailEntities>(faDetailList.ElementAt(faDetailCount).FAuploadedDocumentDetails.ToList());
faDetailEntities.ElementAt(faDetailCount).StatusName = faDetailList.ElementAt(faDetailCount).FAStatu.FAstatus;
for (int targetMappingCount = 0; targetMappingCount < faDetailEntities.ElementAt(faDetailCount).TargetDetailEntityList.Count(); targetMappingCount++)
{
faDetailEntities.ElementAt(faDetailCount).TargetDetailEntityList.ElementAt(targetMappingCount).TargetCropsEntityMappingList = MapEntities.MapIEnumerableCollection <FAtargetVillageMapping, FAtargetVillageMappingEntities>(faDetailList.ElementAt(faDetailCount).FAtargetDetails.ElementAt(targetMappingCount).FAtargetVillageMappings).ToList();
}
}
return(faDetailEntities);
}
catch (Exception ex)
{
throw ex;
}
}
private void InitiatePolygonalBuilding()
{
if (CurrentPolygonWall == null)
{
// save mouse start position
GlobalManagement.Instance.BuildingStartLocation = MousePosition.PxToMeter();
NewPolygonalBuildingWalls = new List <WallElement>();
}
// create wall of building
CurrentPolygonWall = new WallElement(new Wall()
{
Name = Constants.DefaultWallName
});
Point meterPosition = MousePosition.PxToMeter();
CurrentPolygonWall.X1 = meterPosition.X;
CurrentPolygonWall.Y1 = meterPosition.Y;
CurrentPolygonWall.X2 = meterPosition.X;
CurrentPolygonWall.Y2 = meterPosition.Y;
NewPolygonalBuildingWalls.Add(CurrentPolygonWall);
// add wall to map
MapEntities.Add(CurrentPolygonWall);
}
public FarmerDetailPageUIvalues GetFarmerDetailPageUIvalues()
{
FarmerDetailPageUIvalues pageUIvalues = new FarmerDetailPageUIvalues();
IDealerDetailOperations dealerDetailOperations = new DealerDetailOperations();
pageUIvalues.DealerList = MapEntities.MapIEnumerableCollection <DealerDetail, DealerDetailEntities>(dealerDetailOperations.GetAllDealerList()).ToList();
IfarmerTypeOperations farmerTypeOperations = new FarmerTypeOperations();
pageUIvalues.FarmerTypeList = MapEntities.MapList <FarmerTypeDetail, FarmerTypeEntities>(farmerTypeOperations.GetAllFarmerType().ToList());
IirrigationSourceOperations irrigationSourceOperation = new IrrigationSourceOperations();
pageUIvalues.irrigationSourceList = MapEntities.MapList <IrrigationSource, IrrigationSourceEntities>(irrigationSourceOperation.GetAllIrrigationSources());
ICropInfoOperations cropInfoOperations = new CropInfoOperations();
pageUIvalues.CropList = MapEntities.MapList <CropInfo, CropInfoEntities>(cropInfoOperations.GetAllCrops().ToList());
IPocketInfoOperations pocketInfoOperations = new PocketInfoOperations();
pageUIvalues.PocketList = MapEntities.MapIEnumerableCollection <PocketInfo, PocketInfoEntities>(pocketInfoOperations.GetPocketList(Convert.ToInt32(PocketStatusTypeEnum.Current))).ToList();
IFarmerConsumptionOperation farmerConsumptionOperation = new FarmerConsumptionOperation();
pageUIvalues.farmerConsumptionlist = MapEntities.MapIEnumerableCollection <FarmerConsumption, FarmerConsumptionEntities>(farmerConsumptionOperation.GetFarmerConsumptionList()).ToList();
return(pageUIvalues);
}
public UserInformationEntity PostUserInfo(UserInformationEntity userInfoInsert)
{
try
{
UserInformation userInfo = userInformatinOperations.GetUserInformationuserNameAndPassword(userInfoInsert.UserName, userInfoInsert.Password);
if (userInfo != null)
{
UserInformationEntity userInfoEntity = MapEntities.Map <UserInformation, UserInformationEntity>(userInfo);
userInfoEntity.UserID = userInfo.UserID;
userInfoEntity.UserName = userInfo.UserName;
userInfoEntity.UserTypeID = userInfo.UserTypeID;
//userInfoEntity.UserType.TypeName = userInfo.UserType.TypeName;
userInfoEntity.Password = userInfo.Password;
userInfoEntity.MobileNumber = userInfo.MobileNumber;
return(userInfoEntity);
}
else
{
return(null);
}
}
catch (Exception ex)
{
return(null);
}
}
public int PutPocketDetail(PocketInfoEntities pocketInfoEntities)
{
IPocketInfoOperations pocketOperations = new PocketInfoOperations();
IPocketVillageMappingOperations pocketVillageMappingOperations = new PocketVillageMappingOperations();
IPocketCropsMappingOperations pocketCropMappingOperations = new PocketCropsMappingOperations();
IPocketFertilizerMappingOperations pocketFertilizerMappingOperations = new PocketFertilizerMappingOperations();
PocketInfo pocketInfo = MapEntities.Map <PocketInfoEntities, PocketInfo>(pocketInfoEntities);
List <PocketVillageMapping> pocketVillageEntities = MapEntities.MapList <PocketVillageMappingEntities, PocketVillageMapping>(pocketInfoEntities.PocketVillageMappingList);
List <PocketCropMapping> pocketCropsEntities = MapEntities.MapList <PocketCropMappingEntities, PocketCropMapping>(pocketInfoEntities.PocketCropMappingList);
List <PocketFertilizerMapping> pocketFertilizersEntities = MapEntities.MapList <PocketFertilizerMappingEntities, PocketFertilizerMapping>(pocketInfoEntities.PocketFertilizerMappingList);
int UpdatedRecord = pocketOperations.UpdatePocket(pocketInfo);
pocketVillageEntities.ForEach(x =>
{
x.PocketId = pocketInfo.PocketID;
});
pocketCropsEntities.ForEach(x =>
{
x.PocketId = pocketInfo.PocketID;
});
pocketFertilizersEntities.ForEach(x =>
{
x.PocketId = pocketInfo.PocketID;
});
pocketVillageMappingOperations.UpdatePocketVillageMappingOfPocket(pocketVillageEntities);
pocketCropMappingOperations.UpdateCropsOfPocket(pocketCropsEntities);
pocketFertilizerMappingOperations.UpdateFertilizersOfPocket(pocketFertilizersEntities);
return(UpdatedRecord);
}
// GET: api/CropInfo
public IEnumerable <CropInfoEntities> Get()
{
IEnumerable <CropInfo> cropInfoList = cropInfoOperations.GetAllCrops();
IEnumerable <CropInfoEntities> cropInfoEntityList = MapEntities.MapIEnumerableCollection <CropInfo, CropInfoEntities>(cropInfoList);
return(cropInfoEntityList);
}
public string Search(string query)
{
query = query.Trim();
if (string.IsNullOrEmpty(query))
{
return("<ul>No resutl</ul>");
}
var entities = new MapEntities();
var kq1 = entities.Marker.Where(m => m.Title.Contains(query));
var kq2 = entities.DuAn.Where(m => m.TenDuAn.Contains(query));
string s1 = "";
string s2 = "";
foreach (var item in kq1)
{
s1 += "<li><a href='javascript:void(0)' onclick='gotoSeachPoint(" + item.Position + ");' class='liresult' style='text-decoration: none;'>" + item.Title + "</a></li>";
s2 += item.Position + ";";
}
foreach (var item in kq2)
{
s1 += "<li><a href='javascript:void(0)' onclick='gotoSeachPoint(" + item.ToaDo + ");' class='liresult' style='text-decoration: none;'>" + item.TenDuAn + "</a></li>";
s2 += item.ToaDo + ";";
}
return("<ul>" + s1 + "</ul>" + ";#" + s2);
}
public IEnumerable <FarmerTypeEntities> Get()
{
IEnumerable <FarmerTypeDetail> farmerTypeDetailList = farmerTypeOperation.GetAllFarmerType();
IEnumerable <FarmerTypeEntities> farmerTypeEntities = MapEntities.MapIEnumerableCollection <FarmerTypeDetail, FarmerTypeEntities>(farmerTypeDetailList);
return(farmerTypeEntities);
}
public string Index2(string node)
{
var arr = node.Split(new char[] { '(', ')' }, StringSplitOptions.RemoveEmptyEntries);
if (arr.Length > 4)
{
DataDA obj = new DataDA();
string center = "";
string latLng = "";
for (int i = 0; i < arr.Length; i++)
{
if (i == arr.Length - 1)
{
center = arr[i];
}
else
{
latLng += i == arr.Length - 2 ? arr[i] : arr[i] + ";";
}
}
obj.Center = center;
obj.LatLng = latLng;
var entities = new MapEntities();
entities.DataDA.AddObject(obj);
entities.SaveChanges();
return("Success!");
}
return("Fail!");
}
public string TimDuong(string query)
{
string txtstart = query.Split(new char[] { ';', '#' }, StringSplitOptions.RemoveEmptyEntries)[0];
string txtend = query.Split(new char[] { ';', '#' }, StringSplitOptions.RemoveEmptyEntries)[1];
string start = "";
var entities = new MapEntities();
if (entities.Marker.FirstOrDefault(m => m.Title == txtstart) != null)
{
start = entities.Marker.FirstOrDefault(m => m.Title == txtstart).Position;
}
else
{
start = entities.DuAn.FirstOrDefault(m => m.TenDuAn == txtstart).ToaDo;
}
string end = "";
if (entities.DuAn.FirstOrDefault(m => m.TenDuAn == txtend) != null)
{
end = entities.DuAn.FirstOrDefault(m => m.TenDuAn == txtend).ToaDo;
}
else
{
end = entities.Marker.FirstOrDefault(m => m.Title == txtend).Position;
}
return(start + ";#" + end);
}
public UserInformationEntity Post(UserInformationEntity userInfoInsert)
{
try
{
UserInformationEntity inserteduserInfo = new UserInformationEntity();
UserInformation userInfoToInsert = MapEntities.Map <UserInformationEntity, UserInformation>(userInfoInsert);
UserInformation existingUserInfo = new UserInformation();
existingUserInfo = userInformatinOperations.CheckUserInformationExistByUserName(userInfoToInsert.UserName);
if (existingUserInfo != null && existingUserInfo.UserID > 0)
{
inserteduserInfo = MapEntities.Map <UserInformation, UserInformationEntity>(existingUserInfo);
inserteduserInfo.ErrorMessage = "User Already Exists";
}
else
{
userInfoToInsert = userInformatinOperations.InsertUserInformation(userInfoToInsert);
inserteduserInfo = MapEntities.Map <UserInformation, UserInformationEntity>(userInfoToInsert);
}
return(inserteduserInfo);
}
catch (Exception ex)
{
throw ex;
}
}
public int PostPocketDetail(PocketInfoEntities pocketInfoEntities)
{
IPocketInfoOperations pocketOperations = new PocketInfoOperations();
IPocketVillageMappingOperations pocketVillageMappingOperations = new PocketVillageMappingOperations();
IPocketCropsMappingOperations pocketCropMappingOperations = new PocketCropsMappingOperations();
IPocketFertilizerMappingOperations pocketFertilizerMappingOperations = new PocketFertilizerMappingOperations();
PocketInfo pocketInfo = MapEntities.Map <PocketInfoEntities, PocketInfo>(pocketInfoEntities);
List <PocketVillageMapping> pocketVillageEntities = MapEntities.MapList <PocketVillageMappingEntities, PocketVillageMapping>(pocketInfoEntities.PocketVillageMappingList);
List <PocketCropMapping> pocketCropsEntities = MapEntities.MapList <PocketCropMappingEntities, PocketCropMapping>(pocketInfoEntities.PocketCropMappingList);
List <PocketFertilizerMapping> pocketFertilizersEntities = MapEntities.MapList <PocketFertilizerMappingEntities, PocketFertilizerMapping>(pocketInfoEntities.PocketFertilizerMappingList);
int pocketId = pocketOperations.InsertPocket(pocketInfo);
pocketVillageEntities.ForEach(x => { x.PocketId = pocketId; });
pocketCropsEntities.ForEach(x => { x.PocketId = pocketId; });
pocketFertilizersEntities.ForEach(x => { x.PocketId = pocketId; });
pocketVillageMappingOperations.InsertPocketVillageMappingOfPocket(pocketVillageEntities);
pocketCropMappingOperations.InsertCropsOfPocket(pocketCropsEntities);
pocketFertilizerMappingOperations.InsertFertilizersOfPocket(pocketFertilizersEntities);
return(pocketId);
}
public int PostFAdetailEntities(FAdetailEntities faDetailEntities)
{
try
{
IFAdetailOperations faDetailOperations = new FAdetailOperations();
IFAaddressDetailOperations faAddressDetailOperation = new FAaddressDetailOperations();
IFAeducationDetailOperations faEducationDetailOperation = new FAeducationDetailOperations();
IFAexperianceDetailOperations faExperienceDetailOperation = new FAexperianceDetailOperations();
IFAtargetOperations faTargetOperation = new FAtargetOperations();
IFAtargetVillageMappingOperations targetVillageMappingOperation = new FAtargetVillageMappingOperations();
IFAapprovalOperations faApprovalOperation = new FAapprovalOperations();
IFAuploadedDocumentDetailOperations faUploadDocumentDetailOperations = new FAuploadedDocumentDetailOperations();
FAdetail faDetail = new FAdetail();
faDetail = MapEntities.Map <FAdetailEntities, FAdetail>(faDetailEntities);
int faDetailId = faDetailOperations.InsertFAdetail(faDetail);
FAaddressDetail faAddressDetail = new FAaddressDetail();
faAddressDetail = MapEntities.Map <FAaddressDetailEntities, FAaddressDetail>(faDetailEntities.AddressDetailEntities);
faAddressDetail.FAdetailId = faDetailId;
int faAddressDetailId = faAddressDetailOperation.InsertFAAddressDetail(faAddressDetail);
IEnumerable <FAeducationDetail> faEducationDetailList = new List <FAeducationDetail>();
faEducationDetailList = MapEntities.MapIEnumerableCollection <FAeducationDetailEntities, FAeducationDetail>(faDetailEntities.EducationDetailEntityList);
faEducationDetailList.ToList().ForEach(x => x.FAid = faDetailId);
faEducationDetailList = faEducationDetailOperation.InsertFAeducationDetail(faEducationDetailList);
IEnumerable <FAexperianceDetail> faExperienceDetailList = new List <FAexperianceDetail>();
faExperienceDetailList = MapEntities.MapIEnumerableCollection <FAexperianceDetailEntities, FAexperianceDetail>(faDetailEntities.ExperienceDetailEntityList);
faExperienceDetailList.ToList().ForEach(x => x.FAid = faDetailId);
faExperienceDetailList = faExperienceDetailOperation.InsertFAexperienceDetail(faExperienceDetailList);
IEnumerable <FAtargetDetail> faTargetDetailList = new List <FAtargetDetail>();
faTargetDetailList = MapEntities.MapIEnumerableCollection <FAtargetDetailEntities, FAtargetDetail>(faDetailEntities.TargetDetailEntityList);
faTargetDetailList.ToList().ForEach(x => x.FAid = faDetailId);
for (int faTargetEntityCount = 0; faTargetEntityCount < faDetailEntities.TargetDetailEntityList.Count(); faTargetEntityCount++)
{
faTargetDetailList.ElementAt(faTargetEntityCount).FAtargetVillageMappings = MapEntities.MapIEnumerableCollection <FAtargetVillageMappingEntities, FAtargetVillageMapping>(faDetailEntities.TargetDetailEntityList.ElementAt(faTargetEntityCount).TargetCropsEntityMappingList).ToList();
}
faTargetDetailList = faTargetOperation.InsertTargetsForFA(faTargetDetailList);
FAapproval faApproval = new FAapproval();
faApproval = MapEntities.Map <FAapprovalEntities, FAapproval>(faDetailEntities.ApprovalEntities);
faApproval.FAid = faDetailId;
faApproval = faApprovalOperation.InsertFAapproval(faApproval);
IEnumerable <FAuploadedDocumentDetail> fauploadDetailList = new List <FAuploadedDocumentDetail>();
fauploadDetailList = MapEntities.MapIEnumerableCollection <FAuploadedDocumentDetailEntities, FAuploadedDocumentDetail>(faDetailEntities.UploadedDocumentList);
fauploadDetailList.ToList().ForEach(x => x.FAid = faDetailId);
fauploadDetailList = faUploadDocumentDetailOperations.InsertUploadedDocumentDetailIst(fauploadDetailList);
return(faDetailId);
}
catch (Exception ex)
{
throw ex;
}
}
private PocketInfoEntities MapToBusinessEntityForUpdate(PocketInfo pocketInfo)
{
IStateInfoOperations stateOperations = new StateInfoOperations();
IDistrictInfoOperations districtOperations = new DistrictInfoOperations();
IsubDistrictInfoOperations subDistrictOperations = new SubDistrictInfoOperations();
IVillageInfoOperations villageOperations = new VillageInfoOperations();
ICropInfoOperations cropOperations = new CropInfoOperations();
IFertilizerInfoOperations fertilizerOperations = new FertilizerInfoOperations();
IPocketInfoOperations pocketOperations = new PocketInfoOperations();
List <CropInfoEntities> crops = MapEntities.MapList <CropInfo, CropInfoEntities>(cropOperations.GetAllCrops().ToList());
List <FertilizerInfoEntities> fertilizers = MapEntities.MapList <FertilizerInfo, FertilizerInfoEntities>(fertilizerOperations.GetFertilizerList());
PocketInfoEntities pocketInfoEntities = MapEntities.Map <PocketInfo, PocketInfoEntities>(pocketInfo);
pocketInfoEntities.StateName = pocketInfo.StateInfo.StateName;
pocketInfoEntities.DistrictName = pocketInfo.DistrictInfo.DistrictName;
pocketInfoEntities.PocketVillageMappingList = MapEntities.MapList <PocketVillageMapping, PocketVillageMappingEntities>(pocketInfo.PocketVillageMappings.ToList());
pocketInfoEntities.PocketCropMappingList = MapEntities.MapList <PocketCropMapping, PocketCropMappingEntities>(pocketInfo.PocketCropMappings.ToList());
pocketInfoEntities.PocketFertilizerMappingList = MapEntities.MapList <PocketFertilizerMapping, PocketFertilizerMappingEntities>(pocketInfo.PocketFertilizerMappings.ToList());
pocketInfoEntities.states = MapEntities.MapList <StateInfo, StateInfoEntities>(stateOperations.GetAllStates());
pocketInfoEntities.districts = MapEntities.MapList <DistrictInfo, DistrictInfoEntities>(districtOperations.GetDistrictListByStateId(pocketInfoEntities.StateID.Value));
pocketInfoEntities.pocketStatusList = MapEntities.MapList <PocketStatu, PocketStatusEntities>(pocketOperations.GetpocketStatusList());
pocketInfoEntities.pocketStatus = MapEntities.Map <PocketStatu, PocketStatusEntities>(pocketInfo.PocketStatu);
PocketVillageMapping pocketMappingTemp;
pocketInfoEntities.PocketVillageMappingList.ForEach(y =>
{
pocketMappingTemp = pocketInfo.PocketVillageMappings.Select(r => r).Where(r => r.Id == y.Id).FirstOrDefault();
y.SubDistrictName = pocketMappingTemp.SubDistrictInfo.SubDistrictName;
y.VillageName = pocketMappingTemp.VillageInfo.VILLAGE;
y.subDistricts = MapEntities.MapList <SubDistrictInfo, SubDistrictInfoEntities>(subDistrictOperations.GetSubDistrictByDistrictId(pocketInfoEntities.DistrictId.Value));
y.villages = MapEntities.MapList <VillageInfo, VillageInfoEntities>(villageOperations.GetAllVillagesBySubDistrictId(y.SubDistrictId.Value));
});
PocketCropMapping pocketCropMappingTemp;
pocketInfoEntities.PocketCropMappingList.ForEach(y =>
{
pocketCropMappingTemp = pocketInfo.PocketCropMappings.Select(r => r).Where(r => r.id == y.id).FirstOrDefault();
y.CropInfoEntity = MapEntities.Map <CropInfo, CropInfoEntities>(pocketInfo.PocketCropMappings.Select(r => r).Where(r => r.id == y.id).FirstOrDefault().CropInfo);
y.Crops = crops;
});
PocketFertilizerMapping pocketFertilizerMappingTemp;
pocketInfoEntities.PocketFertilizerMappingList.ForEach(y =>
{
pocketFertilizerMappingTemp = pocketInfo.PocketFertilizerMappings.Select(r => r).Where(r => r.Id == y.Id).FirstOrDefault();
y.FertilizerInfoEntity = MapEntities.Map <FertilizerInfo, FertilizerInfoEntities>(pocketInfo.PocketFertilizerMappings.Select(r => r).Where(r => r.Id == y.Id).FirstOrDefault().FertilizerInfo);
y.Fertilizers = fertilizers;
});
return(pocketInfoEntities);
}
public int PostException(ProjectExceptionEntities generatedException)
{
IProjectExceptionOperations exceptionOperations = new ProjectExceptionOperations();
ProjectException exceptionToInsert = MapEntities.Map <ProjectExceptionEntities, ProjectException>(generatedException);
exceptionOperations.LogException(exceptionToInsert);
return(exceptionToInsert.Id);
}
public List <DistrictInfoEntities> GetDistrictOfState(int id)
{
try
{
IDistrictInfoOperations districtInfo = new DistrictInfoOperations();
List <DistrictInfoEntities> districts = MapEntities.MapList <DistrictInfo, DistrictInfoEntities>(districtInfo.GetDistrictListByStateId(id));
return(districts);
}
catch (Exception ex)
{
throw ex;
}
}
public List <VillageInfoEntities> GetVillageInfoBySubDistrictId(int subDistrictId)
{
try
{
IVillageInfoOperations villageInfoOperation = new VillageInfoOperations();
List <VillageInfoEntities> villageList = MapEntities.MapIEnumerableCollection <VillageInfo, VillageInfoEntities>(villageInfoOperation.GetAllVillagesBySubDistrictId(subDistrictId)).ToList();
return(villageList);
}
catch (Exception ex)
{
throw;
}
}
public List <SubDistrictInfoEntities> GetSubDistrictsOfDistrict(int id)
{
try
{
IsubDistrictInfoOperations subDistrictInfoOperations = new SubDistrictInfoOperations();
List <SubDistrictInfoEntities> subDistricts = MapEntities.MapList <SubDistrictInfo, SubDistrictInfoEntities>(subDistrictInfoOperations.GetSubDistrictByDistrictId(id));
return(subDistricts);
}
catch (Exception ex)
{
throw ex;
}
}
public List <SubDistrictInfoEntities> GetAllSubDistrictList()
{
try
{
IsubDistrictInfoOperations subDistrictInfoOperations = new SubDistrictInfoOperations();
List <SubDistrictInfoEntities> subDisrictList = MapEntities.MapIEnumerableCollection <SubDistrictInfo, SubDistrictInfoEntities>(subDistrictInfoOperations.GetAllSubDistrictList()).ToList();
return(subDisrictList);
}
catch (Exception ex)
{
throw ex;
}
}
// PUT: api/FarmerDetail/5
public UserInformationEntity Put(UserInformationEntity userInfoUpdated)
{
try
{
UserInformation userInfoToUpdate = MapEntities.Map <UserInformationEntity, UserInformation>(userInfoUpdated);
userInfoToUpdate = userInformatinOperations.UpdateUserInformation(userInfoToUpdate);
return(MapEntities.Map <UserInformation, UserInformationEntity>(userInfoToUpdate));
}
catch (Exception ex)
{
throw ex;
}
}
public List <StateInfoEntities> GetAllStates()
{
try
{
IStateInfoOperations stateInfo = new StateInfoOperations();
List <StateInfoEntities> states = MapEntities.MapList <StateInfo, StateInfoEntities>(stateInfo.GetAllStates());
return(states);
}
catch (Exception ex)
{
throw ex;
}
}
// PUT: api/FarmerDetail/5
public int Put(FarmerDetailEntities farmerDetailUpdated)
{
try
{
FarmerDetail farmerDetailToUpdate = MapEntities.Map <FarmerDetailEntities, FarmerDetail>(farmerDetailUpdated);
farmerDetailToUpdate = farmerDetailOperations.UpdateFarmerDetail(farmerDetailToUpdate);
return(farmerDetailToUpdate.Id);
}
catch (Exception ex)
{
throw ex;
}
}
public int Index_ToaNha(int query)
{
var lst = new MapEntities().DuAn.ToList();
for (int i = 0; i < lst.Count; i++)
{
if (lst[i].ID == query)
{
return(i);
}
}
return(-1);
}
private void InitiateRectangularBuilding()
{
GlobalManagement.Instance.BuildingStartLocation = MousePosition.PxToMeter();
GlobalManagement.Instance.NewRectangleBuilding = new VisualRectangularBuilding(new RectangularBuilding()
{
X = GlobalManagement.Instance.BuildingStartLocation.X,
Y = GlobalManagement.Instance.BuildingStartLocation.Y,
Width = 0,
Height = 0,
Id = CurrentMap.GetNewId(),
Name = Constants.DefaultHouseName
});
MapEntities.Add(GlobalManagement.Instance.NewRectangleBuilding);
}
public FarmerDetailPageUIvalues GetPocketMappingData(int id)
{
FarmerDetailPageUIvalues pageUIvalues = new FarmerDetailPageUIvalues();
ICropInfoOperations cropInfoOperations = new CropInfoOperations();
pageUIvalues.CropList = MapEntities.MapList <CropInfo, CropInfoEntities>(cropInfoOperations.GetCropListOfPocket(id).ToList());
IVillageInfoOperations villageOperation = new VillageInfoOperations();
pageUIvalues.villageList = MapEntities.MapList <VillageInfo, VillageInfoEntities>(villageOperation.GetVillageListOfPocket(id)).ToList();
return(pageUIvalues);
}
//GET: api/FarmerDetail
public IEnumerable <FarmerDetailEntities> Get()
{
try
{
IEnumerable <FarmerDetail> farmerDetailList = farmerDetailOperations.GetFarmerDetailList();
List <FarmerDetailEntities> farmerDetailEntityList = MapEntities.MapIEnumerableCollection <FarmerDetail, FarmerDetailEntities>(farmerDetailList).ToList();
return(farmerDetailEntityList);
}
catch (Exception ex)
{
throw ex;
}
}
// GET: api/FarmerDetail/5
public FarmerDetailEntities Get(int id)
{
try
{
FarmerDetail farmerDetail = farmerDetailOperations.GetFarmerDetailById(id);
FarmerDetailEntities farmerDetailEntity = MapEntities.Map <FarmerDetail, FarmerDetailEntities>(farmerDetail);
return(farmerDetailEntity);
}
catch (Exception ex)
{
throw ex;
}
}
// POST: api/FarmerDetail
public FarmerDetailEntities Post(FarmerDetailEntities farmerDetail)
{
try
{
FarmerDetail farmerDetailToInsert = MapEntities.Map <FarmerDetailEntities, FarmerDetail>(farmerDetail);
farmerDetailToInsert = farmerDetailOperations.InsertFarmerDetail(farmerDetailToInsert);
FarmerDetailEntities insertedFarmerDetail = MapEntities.Map <FarmerDetail, FarmerDetailEntities>(farmerDetailToInsert);
return(insertedFarmerDetail);
}
catch (Exception ex)
{
throw ex;
}
}
public PocketPageUIvalues GetPocketPageUIvalues()
{
PocketPageUIvalues pageUIvalues = new PocketPageUIvalues();
IStateInfoOperations stateInfo = new StateInfoOperations();
ICropInfoOperations cropOperations = new CropInfoOperations();
IFertilizerInfoOperations fertilizerOperation = new FertilizerInfoOperations();
IPocketInfoOperations pocketInfo = new PocketInfoOperations();
pageUIvalues.states = MapEntities.MapList <StateInfo, StateInfoEntities>(stateInfo.GetAllStates());
pageUIvalues.crops = MapEntities.MapList <CropInfo, CropInfoEntities>(cropOperations.GetAllCrops().ToList());
pageUIvalues.fertilizers = MapEntities.MapList <FertilizerInfo, FertilizerInfoEntities>(fertilizerOperation.GetFertilizerList());
pageUIvalues.pocketStatusList = MapEntities.MapList <PocketStatu, PocketStatusEntities>(pocketInfo.GetpocketStatusList());
return(pageUIvalues);
}
private PocketInfoEntities MapToBusinessEntity(PocketInfo pocketInfo)
{
PocketInfoEntities pocketInfoEntities = MapEntities.Map <PocketInfo, PocketInfoEntities>(pocketInfo);
pocketInfoEntities.StateName = pocketInfo.StateInfo.StateName;
pocketInfoEntities.DistrictName = pocketInfo.DistrictInfo.DistrictName;
pocketInfoEntities.PocketVillageMappingList = MapEntities.MapList <PocketVillageMapping, PocketVillageMappingEntities>(pocketInfo.PocketVillageMappings.ToList());
pocketInfoEntities.PocketCropMappingList = MapEntities.MapList <PocketCropMapping, PocketCropMappingEntities>(pocketInfo.PocketCropMappings.ToList());
pocketInfoEntities.PocketFertilizerMappingList = MapEntities.MapList <PocketFertilizerMapping, PocketFertilizerMappingEntities>(pocketInfo.PocketFertilizerMappings.ToList());
pocketInfoEntities.states.Add(MapEntities.Map <StateInfo, StateInfoEntities>(pocketInfo.StateInfo));
pocketInfoEntities.districts.Add(MapEntities.Map <DistrictInfo, DistrictInfoEntities>(pocketInfo.DistrictInfo));
pocketInfoEntities.pocketStatusList.Add(MapEntities.Map <PocketStatu, PocketStatusEntities>(pocketInfo.PocketStatu));
pocketInfoEntities.pocketStatus = MapEntities.Map <PocketStatu, PocketStatusEntities>(pocketInfo.PocketStatu);
PocketVillageMapping pocketMappingTemp;
pocketInfoEntities.PocketVillageMappingList.ForEach(y =>
{
pocketMappingTemp = pocketInfo.PocketVillageMappings.Select(r => r).Where(r => r.Id == y.Id).FirstOrDefault();
y.SubDistrictName = pocketMappingTemp.SubDistrictInfo.SubDistrictName;
y.VillageName = pocketMappingTemp.VillageInfo.VILLAGE;
y.subDistricts.Add(MapEntities.Map <SubDistrictInfo, SubDistrictInfoEntities>(pocketMappingTemp.SubDistrictInfo));
y.villages.Add(MapEntities.Map <VillageInfo, VillageInfoEntities>(pocketMappingTemp.VillageInfo));
});
PocketCropMapping pocketCropMappingTemp;
pocketInfoEntities.PocketCropMappingList.ForEach(y =>
{
pocketCropMappingTemp = pocketInfo.PocketCropMappings.Select(r => r).Where(r => r.id == y.id).FirstOrDefault();
y.CropInfoEntity = MapEntities.Map <CropInfo, CropInfoEntities>(pocketInfo.PocketCropMappings.Select(r => r).Where(r => r.id == y.id).FirstOrDefault().CropInfo);
y.Crops.Add(y.CropInfoEntity);
});
PocketFertilizerMapping pocketFertilizerMappingTemp;
pocketInfoEntities.PocketFertilizerMappingList.ForEach(y =>
{
pocketFertilizerMappingTemp = pocketInfo.PocketFertilizerMappings.Select(r => r).Where(r => r.Id == y.Id).FirstOrDefault();
y.FertilizerInfoEntity = MapEntities.Map <FertilizerInfo, FertilizerInfoEntities>(pocketInfo.PocketFertilizerMappings.Select(r => r).Where(r => r.Id == y.Id).FirstOrDefault().FertilizerInfo);
y.Fertilizers.Add(y.FertilizerInfoEntity);
});
return(pocketInfoEntities);
}
