public ActionResult CreateAddress(string addyType, int churchId)
{
AddressInfoVm info = null;
var partialView = string.Empty;
switch (addyType.ToLower())
{
case "address":
info = new AddressVm();
partialView = "_Address.cshtml";
break;
case "email":
info = new EmailVm();
partialView = "_Email.cshtml";
break;
case "phone":
info = new PhoneVm();
partialView = "_Phone.cshtml";
break;
}
info.Id = new Random().Next(-100, -1);
info.IdentityId = churchId;
return(PartialView("/Views/Shared/AddressInfo/" + partialView, info));
}
public ActionResult AddAddress(AddressVm vm)
{
if (ModelState.IsValid)
{
var model = new Address();
model.AddressFirst = vm.AddressFirst;
model.AddressSecond = vm.AddressSecond;
model.PostalCode = vm.PostalCode;
model.City = vm.City;
model.Country = vm.Country;
addressService.Add(model);
var uAddress = new UserAddress();
uAddress.UserId = vm.UserId;
uAddress.AddressId = model.AddressId;
userAddressService.Add(uAddress);
return(RedirectToAction("Loggedin", "Address"));
}
else
{
ModelState.AddModelError("", "You have to fill all required fields.");
return(View());
}
}
internal void SaveCompany(CompanyVm companyVM, AddressVm addressVm)
{
Company company = new Company();
company.CompanyId = companyVM.company.CompanyId;
company.CompanyCode = companyVM.company.CompanyCode;
company.CompanyName = companyVM.company.CompanyName;
company.CreatedBy = sessionObj.USERID;
company.CreatedOn = UTILITY.SINGAPORETIME;
company.InCorporationDate = companyVM.company.InCorporationDate;
company.IsActive = true;
company.SSFNumber = companyVM.company.SSFNo;
company.TaxIdNumber = companyVM.company.TaxIdNo;
company.BranchCode = companyVM.company.BranchCode;
if (companyVM.company.Logo != null && companyVM.company.Logo.ContentLength > 0)
{
company.CompanyLogo = companyVM.company.Logo.FileName;
string path = HttpContext.Current.Server.MapPath("~/Uploads/");
if (!Directory.Exists(path))
{
Directory.CreateDirectory(path);
}
companyVM.company.Logo.SaveAs(path + company.CompanyLogo);
}
company.RegNo = companyVM.company.RegNo;
company.ModifiedBy = sessionObj.USERID;
company.ModifiedOn = UTILITY.SINGAPORETIME;
Add(company);
Address companyAddress = new Address()
{
Address1 = addressVm.Address1,
Address2 = addressVm.Address2,
AddressType = UTILITY.COMPANY,
CityName = addressVm.CityName,
Contact = addressVm.Contact,
CountryCode = addressVm.CountryCode,
LinkID = company.CompanyId,
CreatedBy = sessionObj.USERID,
CreatedOn = UTILITY.SINGAPORETIME,
Email = addressVm.Email,
FaxNo = addressVm.FaxNo,
MobileNo = addressVm.MobileNo,
IsActive = true,
ModifiedBy = sessionObj.USERID,
ModifiedOn = UTILITY.SINGAPORETIME,
SeqNo = addressVm.SeqNo,
StateName = addressVm.StateName,
TelNo = addressVm.TelNo,
WebSite = addressVm.WebSite,
ZipCode = addressVm.ZipCode,
};
addressBO.Add(companyAddress);
}
public static void UpdateByViewModel(AddressRecord record, AddressVm addressVm)
{
record.Address = addressVm.Address.TrimIt().StripTags();
record.Latitude = addressVm.Latitude;
record.Longitude = addressVm.Longitude;
record.Tip = addressVm.Tip.TrimIt().StripTags();
record.IsDeleted = addressVm.Destroy;
}
private AddressVm PopulateAddressVm(Customer customer, AddressVm addressVm)
{
addressVm.Number = customer.Address.Number;
addressVm.Street = customer.Address.Street;
addressVm.Village = customer.Address.Village;
addressVm.City = customer.Address.City;
addressVm.Postcode = customer.Address.Postcode;
return(addressVm);
}
public ActionResult AddAddress(int id)
{
UserModel user = new UserModel();
var model = new AddressVm();
user = userService.GetUser(id);
model.UserId = user.UserId;
return(View(model));
}
internal static SearchCriteriaVm MapToSearchCriteriaVm(this AddressVm addressVm, SearchType searchType)
{
SearchCriteriaVm searchCriteriaVm = new SearchCriteriaVm();
searchCriteriaVm.SearchType(searchType);
searchCriteriaVm.CountryCode(addressVm.CountryCode);
searchCriteriaVm.StateCode(addressVm.StateCode);
searchCriteriaVm.City(addressVm.City);
return(searchCriteriaVm);
}
public ActionResult editaddress(AddressVm vm)
{
if (ModelState.IsValid)
{
TaskService.editAddess(new Address {
Id = vm.Id, address = vm.address
});
}
return(Redirect("~/Home/getaddress/" + vm.Contact));
}
public ActionResult AddBranch(BranchVm branchVm, AddressVm addressVm)
{
try
{
branchBO.SaveBranch(branchVm, addressVm);
var list = contributionBO.GetListByProperty(x => x.BranchId == branchVm.branch.BranchID).ToList();
var count = list.Count();
if (count == 0)
{
Contribution contribution = new Contribution
{
Name = UTILITY.BASICSALARYCOMPONENT,
Description = UTILITY.BASICSALARYCOMPONENT,
IsActive = true,
CreatedBy = SESSIONOBJ.USERID,
CreatedOn = UTILITY.SINGAPORETIME,
RegisterCode = "BASIC SALARY",
BranchId = branchVm.branch.BranchID,
SortBy = 0
};
contributionBO.Add(contribution);
Contribution contribution1 = new Contribution
{
Name = UTILITY.INCENTIVEEMPLOYERCONTRIBUTION,
Description = UTILITY.INCENTIVEEMPLOYERCONTRIBUTION,
IsActive = true,
CreatedBy = SESSIONOBJ.USERID,
CreatedOn = UTILITY.SINGAPORETIME,
RegisterCode = "EMPLOYER CONTRIBUTION",
BranchId = branchVm.branch.BranchID,
SortBy = 0
};
contributionBO.Add(contribution1);
Contribution contribution2 = new Contribution
{
Name = UTILITY.INCENTIVEEMPLOYEECONTRIBUTION,
Description = UTILITY.INCENTIVEEMPLOYEECONTRIBUTION,
IsActive = true,
CreatedBy = SESSIONOBJ.USERID,
CreatedOn = UTILITY.SINGAPORETIME,
RegisterCode = "EMPLOYEE CONTRIBUTION",
BranchId = branchVm.branch.BranchID,
SortBy = 0
};
contributionBO.Add(contribution2);
}
}
catch (Exception ex)
{
throw ex;
}
return(RedirectToAction("Company"));
}
private IEnumerable <ValidationError> ValidateAddress(AddressVm model, string prefix = "")
{
var result = new List <ValidationError>();
if (!string.IsNullOrEmpty(model.Address) && model.Address.Length > 255)
{
var addressProperty = model.GetPropertyName(p => p.Address);
result.Add(new ValidationError(
prefix + addressProperty,
T("Address can not be longer than 255 characters.").Text));
}
var latitudeProperty = model.GetPropertyName(p => p.Latitude);
if (Math.Abs(model.Latitude - 0) < 0.00001)
{
result.Add(new ValidationError(
prefix + latitudeProperty,
T("Latitude can not be empty.").Text));
}
else if (model.Latitude < -90 || model.Latitude > 90)
{
result.Add(new ValidationError(
prefix + latitudeProperty,
T("Latitude is out of range.").Text));
}
var longitudeProperty = model.GetPropertyName(p => p.Longitude);
if (Math.Abs(model.Longitude - 0) < 0.00001)
{
result.Add(new ValidationError(
prefix + longitudeProperty,
T("Longitude can not be empty").Text));
}
else if (model.Longitude < -180 || model.Longitude > 180)
{
result.Add(new ValidationError(
prefix + latitudeProperty,
T("Longitude is out of range.").Text));
}
if (!string.IsNullOrEmpty(model.Tip) && model.Tip.Length > 255)
{
var tipProperty = model.GetPropertyName(p => p.Tip);
result.Add(new ValidationError(
prefix + tipProperty,
T("Address tip can not be longer than 255 characters.").Text));
}
return(result);
}
public ActionResult Company(CompanyVm companyVM, AddressVm addressVm)
{
try
{
companyBO.SaveCompany(companyVM, addressVm);
}
catch (Exception ex)
{
throw ex;
}
return(RedirectToAction("Company"));
}
protected void BindSearchModel(
AddressVm model,
ControllerContext controllerContext,
PropertyDescriptor propertyDescriptor)
{
if (string.Equals(propertyDescriptor.Name, "State"))
{
string countryCodeStr = (string)controllerContext.RouteData.Values["countryCode"]
?? controllerContext.HttpContext.Request["CountryCode"];
model.CountryCode = countryCodeStr;
}
}
public async Task <int> CreateAddress(AddressVm address, int employeeId)
{
var entityAddress = mapper.Map <Address>(address);
entityAddress.EmployeeId = employeeId;
addressRepository.Add(entityAddress);
if (await addressRepository.SaveAll())
{
return(entityAddress.Id);
}
return(-1);
}
public async Task <IActionResult> GetAccountBalance([FromBody] AddressVm addressVm)
{
try
{
var result = await _unBlockchainService.GetAccountBalance(addressVm.Address);
return(Ok(result));
}
catch (Exception ex)
{
_logger.LogError(ex.HResult, ex.InnerException == null ? ex.Message : ex.InnerException.Message);
return(BadRequest("Ha ocurrido un error inesperado."));
}
}
public static AddressVm Repopulate(this AddressVm address)
{
if (!address.Country.Id.HasValue)
{
address.Country.Id = LocationBc.Instance.DefaultCountry.Id;
}
List <Country> countries = LocationBc.Instance.GetAllCountries();
address.Country.AvailableCountries = countries.ConvertAll <SelectListItem>((Country m) => {
SelectListItem selectListItem = new SelectListItem();
long?id = m.Id;
selectListItem.set_Value(id.ToString());
selectListItem.set_Text(m.Name);
id = m.Id;
long?nullable = address.Country.Id;
selectListItem.set_Selected(id.GetValueOrDefault() == nullable.GetValueOrDefault() & id.HasValue == nullable.HasValue);
return(selectListItem);
});
List <State> states = LocationBc.Instance.GetStates(address.Country.Id);
address.State.AvailableStates = states.ConvertAll <SelectListItem>((State m) => {
SelectListItem selectListItem = new SelectListItem();
long?id = m.Id;
selectListItem.set_Value(id.ToString());
selectListItem.set_Text(m.Name);
id = m.Id;
long?nullable = address.State.Id;
selectListItem.set_Selected(id.GetValueOrDefault() == nullable.GetValueOrDefault() & id.HasValue == nullable.HasValue);
return(selectListItem);
});
if (address.State.Id.HasValue)
{
List <City> cities = LocationBc.Instance.GetCities(address.State.Id);
address.City.AvailableCities = cities.ConvertAll <SelectListItem>((City m) => {
SelectListItem selectListItem = new SelectListItem();
long?id = m.Id;
selectListItem.set_Value(id.ToString());
selectListItem.set_Text(m.Name);
id = m.Id;
long?nullable = address.City.Id;
selectListItem.set_Selected(id.GetValueOrDefault() == nullable.GetValueOrDefault() & id.HasValue == nullable.HasValue);
return(selectListItem);
});
}
else
{
address.City.AvailableCities = new List <SelectListItem>();
}
return(address);
}
public ActionResult editaddress(int id)
{
List <Address> con = TaskService.address();
AddressVm vm = new AddressVm();
foreach (var i in con)
{
if (i.Id == id)
{
vm.Id = i.Id; vm.address = i.address; vm.Contact = i.Contact.Id;
}
}
return(View(vm));
}
public AddressVm Build(AddressDt addressDt)
{
var addressVm = new AddressVm();
addressVm.City = addressDt.City;
addressVm.Country = addressDt.Country;
addressVm.Name = addressDt.Name;
addressVm.PostCode = addressDt.PostCode;
addressVm.Region = addressDt.Region;
addressVm.StreetAddress = addressDt.StreetAddress;
addressVm.Suburb = addressDt.Suburb;
return(addressVm);
}
internal void SaveBranch(BranchVm branchVm, AddressVm addressVm)
{
Branch branch = new Branch()
{
BranchCode = branchVm.branch.BranchCode,
BranchName = branchVm.branch.BranchName,
RegNo = branchVm.branch.RegNo,
CreatedBy = sessionObj.USERID,
CreatedOn = UTILITY.SINGAPORETIME,
ModifiedBy = sessionObj.USERID,
ModifiedOn = UTILITY.SINGAPORETIME,
CompanyCode = "EZY",
CompanyId = 1000,
IsActive = true,
BranchID = branchVm.branch.BranchID,
SSFNumber = branchVm.branch.SSFNumber,
TaxIdNumber = branchVm.branch.TaxIdNumber,
BranchTaxCode = branchVm.branch.BranchTaxCode
};
Add(branch);
Address branchAddress = new Address()
{
Address1 = addressVm.Address1,
Address2 = addressVm.Address2,
AddressType = UTILITY.BRANCH,
CityName = addressVm.CityName,
Contact = addressVm.Contact,
CountryCode = addressVm.CountryCode,
LinkID = branch.BranchID,
CreatedBy = sessionObj.USERID,
CreatedOn = UTILITY.SINGAPORETIME,
Email = addressVm.Email,
FaxNo = addressVm.FaxNo,
MobileNo = addressVm.MobileNo,
IsActive = true,
ModifiedBy = sessionObj.USERID,
ModifiedOn = UTILITY.SINGAPORETIME,
SeqNo = addressVm.SeqNo,
StateName = addressVm.StateName,
TelNo = addressVm.TelNo,
WebSite = addressVm.WebSite,
ZipCode = addressVm.ZipCode,
};
addressBO.Add(branchAddress);
}
private CustomerVm Populate(Customer customer, AddressVm addressVm)
{
var customerVm = new CustomerVm
{
WillId = customer.Will.Id,
FirstName = customer.FirstName,
LastName = customer.LastName,
Address = PopulateAddressVm(customer, addressVm),
DateOfBirth = new DateVm
{
DateOfBirth = customer.DateOfBirth.Date,
Day = customer.DateOfBirth.Day,
Month = customer.DateOfBirth.Month,
Year = customer.DateOfBirth.Year,
}
};
return(customerVm);
}
public ActionResult addadress(AddressVm vm)
{
List <Contact> contact = TaskService.contacts();
Contact c = new Contact();
if (ModelState.IsValid)
{
foreach (var i in contact)
{
if (i.Id == vm.Id)
{
c = i;
}
}
TaskService.insertAddress(new Address {
address = vm.address, Contact = c
});
}
return(RedirectToAction("Index"));
}
public void Build_Test11_ReturnBuildSalesOrderVm()
{
var salesOrderVm = new SalesOrderVm();
var addressVm = new AddressVm();
var currencyVm = new CurrencyVm();
var companyFeatures = new CompanyFeaturesVm();
var salesTax = new SalesTaxVm();
_mockedSalesOrderVmModelBuilder.Setup(x => x.Build(_mockedSalesOrder.Object)).Returns(salesOrderVm);
_mockedAddressVmModelBuilder.Setup(x => x.Build(_mockedSalesOrder.Object.DeliveryAddress)).Returns(addressVm);
_mockedCurrencyVmModelBuilder.Setup(x => x.Build(_mockedSalesOrder.Object.Currency)).Returns(currencyVm);
_mockedCompanyFeatureVmModelBuilder.Setup(x => x.Build(_mockedSalesOrder.Object.Customer.Company)).Returns(companyFeatures);
_mockedSalesTaxVmModelBuilder.Setup(x => x.Build(_mockedSalesOrder.Object.SalesTax)).Returns(salesTax);
var vm = _salesOrderVmBuilder.Build(_mockedSalesOrder.Object);
Assert.That(vm, Is.EqualTo(salesOrderVm));
Assert.That(vm.DeliveryAddress, Is.EqualTo(addressVm));
Assert.That(vm.Currency, Is.EqualTo(currencyVm));
Assert.That(vm.CompanyFeatures, Is.EqualTo(companyFeatures));
Assert.That(vm.SalesTax, Is.EqualTo(salesTax));
}
public OrderVm FromOrder(Order order)
{
AddressVm pickupAddress = OrderVm.PopulateAddress(order.PickupAddress);
AddressVm deliveryAdress = OrderVm.PopulateAddress(order.DeliveryAddress);
//pickupAddress.Notes = order.PickUpNotes;
//deliveryAdress.Notes = order.DeliveryNotes;
var orderVM = new OrderVm()
{
Id = order.Id.ToString(),
OrderDate = order.CreatedAt.ToString(),
OrderNumber = order.OrderNumber,
OrderType = ((OrderTypeEnum)order.OrderType).ToString(),
CallerFirstName = order.CallerFirstName,
CallerLastName = order.CallerLastName,
CallerPhoneNumber = order.CallerPhoneNumber,
CallerEmail = order.CallerEmail,
PickupAddressString = pickupAddress.ToString,
DeliveryAddressString = deliveryAdress.ToString,
PickupDate = order.PickupDate?.ToString(),
DeliveryDate = order.DeliveryDate?.ToString(),
PickupInstructions = order.PickUpNotes,
DeliveryInstructions = order.DeliveryNotes,
Customer = order.Client != null ? order.Client.AccountCode + " " + order.Client.Name : "",
IsBilledThirdParty = order.BillToDifferent,
CollectableAmount = order.CodAmount,
OnlinePaymentDetails = order.OnlinePayment,
OfficeStaffDetails = order.OfficeStaff,
Dealer = order.InvoiceClientId.ToString(),
ThirdParty = order.InvoiceBillingPartyId.ToString(),
};
orderVM.Pianos = order.Pianos.OrderByDescending(x => x.CreatedAt).Select(
x => new PianoVm()
{
Id = x.Id,
OrderId = order.Id,
PianoCategoryType = System.Enum.GetName(typeof(PianoCategoryTypeEnum), x.PianoCategoryType),
PianoType = x.PianoTypeId.ToString(),
PianoSize = x.PianoSizeId.ToString(),
PianoMake = x.PianoMakeId.ToString(),
PianoModel = x.Model,
PianoFinish = PianoFinishList.FirstOrDefault(y => y.Value == x.PianoFinishId.ToString()).Text,
SerialNumber = x.SerialNumber,
IsBench = x.IsBench,
IsBoxed = x.IsBoxed,
IsPlayer = x.IsPlayer,
Notes = x.Notes
}).ToList();
orderVM.Pianos.ForEach(x =>
{
if (!string.IsNullOrEmpty(x.PianoType))
{
x.PianoType = Db.PianoTypes.Where(y => y.Id.ToString() == x.PianoType).FirstOrDefault().Type;
}
if (!string.IsNullOrEmpty(x.PianoMake))
{
x.PianoMake = Db.PianoMake.Where(y => y.Id.ToString() == x.PianoMake).FirstOrDefault().Name;
}
if (!string.IsNullOrEmpty(x.PianoSize))
{
x.PianoSize = Db.PianoSize.Where(y => y.Id.ToString() == x.PianoSize).FirstOrDefault().Width.ToString();
}
});
orderVM.Charges = order.OrderCharges.OrderBy(x => x.Id).Select(
x => new PianoChargesVm()
{
Id = x.Id.ToString(),
ChargesTypeId = x.PianoChargesId.ToString(),
Amount = x.Amount.ToString()
}).ToList();
orderVM.Charges.ForEach(x =>
{
var obj = Db.PianoCharges.Where(y => y.Id.ToString() == x.ChargesTypeId).FirstOrDefault();
x.ChargesCode = obj.Code.ToString();
x.ChargesDetails = obj.Details.ToString();
//x.ChargesType = ((ChargesTypeEnum)obj.ChargesType).ToString();
});
return(orderVM);
}
public ActionResult AddAddress()
{
var model = new AddressVm(AppCache.Instance);
return(PartialView("_Address", model));
}
public static AddressValidationVm GetAddressValidationVm(AddressVm addressVm)
{
return(LocationBc.Instance.GeocodeAddress(addressVm.ToEntity()).MapToAddressValidationVm());
}
public ActionResult deleteaddress(AddressVm vm)
{
TaskService.deleteAddress(vm.Id);
return(Redirect("~/Home/getaddress/" + vm.Contact));
}
