public int Insert(AddressAddRequest model)
{
int AddressId = 0;
DataProvider.ExecuteNonQuery(GetConnection, "dbo.Address_Insert",
inputParamMapper : delegate(SqlParameterCollection paramCollection)
{
paramCollection.AddWithValue("@UserId", model.UserId);
paramCollection.AddWithValue("@Name", model.Name);
paramCollection.AddWithValue("@ExternalPlaceId", model.ExternalPlaceId);
paramCollection.AddWithValue("@Line1", model.Line1);
paramCollection.AddWithValue("@Line2", model.Line2);
paramCollection.AddWithValue("@City", model.City);
paramCollection.AddWithValue("@State", model.State);
paramCollection.AddWithValue("@StateId", model.StateId);
paramCollection.AddWithValue("@ZipCode", model.ZipCode);
paramCollection.AddWithValue("@Country", model.Country);
paramCollection.AddWithValue("@Latitude", model.Latitude);
paramCollection.AddWithValue("@Longitude", model.Longitude);
SqlParameter p = new SqlParameter("@AddressId", SqlDbType.Int);
p.Direction = System.Data.ParameterDirection.Output;
paramCollection.Add(p);
},
returnParameters : delegate(SqlParameterCollection param)
{
int.TryParse(param["@AddressId"].Value.ToString(), out AddressId);
});
return(AddressId);
}
public int Insert(AddressAddRequest model)
{
int id = 0;
_dataProvider.ExecuteNonQuery(
"dbo.Addresses2_Insert",
inputParamMapper : delegate(SqlParameterCollection paramCol)
{
paramCol.AddWithValue("@Address", model.Address);
paramCol.AddWithValue("@Latitude", model.Latitude);
paramCol.AddWithValue("@Longitude", model.Longitude);
//Output param
SqlParameter parm = new SqlParameter();
parm.ParameterName = "@Id";
parm.SqlDbType = SqlDbType.Int;
parm.Direction = ParameterDirection.Output;
paramCol.Add(parm);
},
returnParameters : delegate(SqlParameterCollection paramCol)
{
Int32.TryParse(paramCol["@Id"].Value.ToString(), out id);
}
);
return(id);
}
public int SaveWebsiteAddress(WebsiteAddRequest model)
{
var addressId = model.AddressId;
AddressAddRequest newAddress = new AddressAddRequest();
AddressUpdateRequest Address = new AddressUpdateRequest();
if (addressId > 0)
{
Address.Name = model.Name;
Address.AddressId = model.AddressId;
Address.ExternalPlaceId = model.ExternalAddressId;
Address.Line1 = model.Street;
Address.City = model.City;
Address.State = model.State;
Address.ZipCode = model.ZipCode;
Address.Country = model.Country;
Update(Address);
}
else
{
newAddress.Name = model.Name;
newAddress.ExternalPlaceId = model.ExternalAddressId;
newAddress.Line1 = model.Street;
newAddress.City = model.City;
newAddress.State = model.State;
newAddress.ZipCode = model.ZipCode;
newAddress.Country = model.Country;
addressId = Insert(newAddress);
}
return(addressId);
}
public async Task <ActionResult <dynamic> > GetForecast(AddressAddRequest model)
{
string api = "xxxxxxxxxxx";
string mode = "json";
string units = "imperial";
string requestUri = string.Format($"https://api.openweathermap.org/data/2.5/forecast?mode={mode}&appid={api}&units={units}&lat={model.Latitude}&lon={model.Longitude}");
try
{
using (var client = new HttpClient())
{
Task <HttpResponseMessage> request = client.GetAsync(requestUri);
if (request.Result.IsSuccessStatusCode)
{
string content = await request.Result.Content.ReadAsStringAsync();
dynamic result = JObject.Parse(content);
return(result);
}
else
{
string error = await request.Result.Content.ReadAsStringAsync();
return(StatusCode(400));
}
}
}
catch (Exception ex)
{
return(StatusCode(500, ex.Message));
}
}
public int Insert(AddressAddRequest model, int userId)
{
int id = 0;
_dataProvider.ExecuteNonQuery("dbo.Addresses_Insert", inputParamMapper : delegate(SqlParameterCollection parms)
{
SqlParameter parm = new SqlParameter();
parm.ParameterName = "@Id";
parm.SqlDbType = SqlDbType.Int;
parm.Direction = ParameterDirection.Output;
parms.Add(parm);
parms.AddWithValue("@UserId", userId);
parms.AddWithValue("@AddressTypeId", model.AddressTypeId);
parms.AddWithValue("@LineOne", model.LineOne);
parms.AddWithValue("@LineTwo", model.LineTwo);
parms.AddWithValue("@City", model.City);
parms.AddWithValue("@Zip", model.Zip);
parms.AddWithValue("@StateId", model.StateId);
parms.AddWithValue("@Latitude", model.Latitude);
parms.AddWithValue("@Longitude", model.Longitude);
}, returnParameters : delegate(SqlParameterCollection parms)
{
Int32.TryParse(parms["@Id"].Value.ToString(), out id);
});
return(id);
}
public int InsertAddress(AddressAddRequest model, string userId)
{
// Guid uid = Guid.Empty; 000-0000-0000-0000 >> unique identifier - huge number; hexa-decimal>> combinations of numbers and letters
var id = 0;
DataProvider.ExecuteNonQuery(GetConnection, "dbo.Addresses_Insert"
, inputParamMapper : delegate(SqlParameterCollection AddressesInsert)
{
AddressesInsert.AddWithValue("@Line1", model.Line1);
AddressesInsert.AddWithValue("@Line2", model.Line2);
AddressesInsert.AddWithValue("@City", model.City);
AddressesInsert.AddWithValue("@StateProvinceId", model.StateProvinceId);
AddressesInsert.AddWithValue("@ZipCode", model.ZipCode);
SqlParameter p = new SqlParameter("@Id", System.Data.SqlDbType.Int);
p.Direction = System.Data.ParameterDirection.Output;
AddressesInsert.Add(p);
}, returnParameters : delegate(SqlParameterCollection param)
{
int.TryParse(param["@Id"].Value.ToString(), out id);
}
);
return(id); //returns just the numeric id which is the Scope Identity from SQL
}
public int Insert(AddressAddRequest model)
{
int returnValue = 0;
DataProvider.ExecuteNonQuery("dbo.Address_Insert",
inputParamMapper: (SqlParameterCollection inputs) =>
{
inputs.AddWithValue("@AddressTypeId", model.AddressTypeId);
inputs.AddWithValue("@StreetAddress", model.StreetAddress);
inputs.AddWithValue("@City", model.City);
inputs.AddWithValue("@StateProvinceId", model.StateProvinceId);
inputs.AddWithValue("@PostalCode", model.PostalCode);
inputs.AddWithValue("@Latitude", model.Latitude);
inputs.AddWithValue("@Longitude", model.Longitude);
SqlParameter idOut = new SqlParameter("@Id", 0);
idOut.Direction = ParameterDirection.Output;
inputs.Add(idOut);
},
returnParameters: (SqlParameterCollection inputs) =>
{
int.TryParse(inputs["@Id"].Value.ToString(), out returnValue);
});
return(returnValue);
}
public int Add(AddressAddRequest data, int userId)
{
if (data == null)
{
throw new ArgumentNullException("Parameter data is required");
}
int addressId = 0;
string storedProc = "[dbo].[Addresses_Insert]";
_dataProvider.ExecuteNonQuery(storedProc,
delegate(SqlParameterCollection sqlParams)
{
sqlParams.AddWithValue("@LineOne", data.LineOne);
sqlParams.AddWithValue("@LineTwo", data.LineTwo);
sqlParams.AddWithValue("@City", data.City);
sqlParams.AddWithValue("@StateId", data.StateId);
sqlParams.AddWithValue("@PostalCode", data.PostalCode);
sqlParams.AddWithValue("@UserId", userId);
SqlParameter idParameter = new SqlParameter("@Id", System.Data.SqlDbType.Int);
idParameter.Direction = System.Data.ParameterDirection.Output;
sqlParams.Add(idParameter);
}, returnParameters : delegate(SqlParameterCollection param)
{
Int32.TryParse(param["@Id"].Value.ToString(), out addressId);
}
);
return(addressId);
}
public static int AddressInsert(AddressAddRequest payload)
{
int id = 0;
string connString = System.Configuration.ConfigurationManager.ConnectionStrings["DefaultConnection"].ConnectionString;
using (SqlConnection sqlConn = new SqlConnection(connString))
{
using (SqlCommand cmd = new SqlCommand("Address_Insert", sqlConn))
{
cmd.CommandType = System.Data.CommandType.StoredProcedure;
cmd.Parameters.AddWithValue("@AddressLine1", payload.AddressLine1);
cmd.Parameters.AddWithValue("@AddressLine2", payload.AddressLine2);
cmd.Parameters.AddWithValue("@City", payload.City);
cmd.Parameters.AddWithValue("@State", payload.State);
cmd.Parameters.AddWithValue("@Zip", payload.Zip);
SqlParameter param = new SqlParameter();
param.ParameterName = "@ID";
param.SqlDbType = System.Data.SqlDbType.Int;
param.Direction = System.Data.ParameterDirection.Output;
cmd.Parameters.Add(param);
sqlConn.Open();
cmd.ExecuteNonQuery();
id = (int)cmd.Parameters["@ID"].Value;
}
}
return(id);
}
public void InsertAddress(string UserId, AddressAddRequest model)
{
var Result = _AddressService.Insert(model);
DataProvider.ExecuteNonQuery(GetConnection, "dbo.UserAddress_Insert"
, inputParamMapper : delegate(SqlParameterCollection paramCollection)
{
paramCollection.AddWithValue("@UserId", UserId);
paramCollection.AddWithValue("@AddressId", Result);
}, returnParameters: null);
}
/// <summary>
/// Method allowing to add address
/// </summary>
/// <param name="request">Add address request model</param>
/// <returns>Added address</returns>
public async Task <Address> CreateAddress(AddressAddRequest request)
{
var addressToAdd = Mapper.Map <AddressAddRequest, Address>(request);
addressToAdd.IsActive = true;
await AddressRepo.CreateAsync(addressToAdd);
await AddressRepo.SaveChangesAsync();
return(addressToAdd);
}
public ActionResult <int> Insert(AddressAddRequest model)
{
try
{
int id = _addressService.Insert(model);
return(id);
}
catch (Exception ex)
{
return(StatusCode(500, ex.Message));
}
}
public HttpResponseMessage Insert(AddressAddRequest model)
{
if (!ModelState.IsValid)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState));
}
ItemResponse <int> response = new ItemResponse <int>();
response.Item = _AddressService.Insert(model);
return(Request.CreateResponse(response));
}
public async Task <IActionResult> AddAddress(AddressAddRequest request)
{
var user = await UsersService.GetUserBaseInfo(request.UserId);
if (user == null)
{
return(BadRequest(ApiResponse.Failure("user", "user does not exist")));
}
await AddressService.CreateAddress(request);
return(Ok(ApiResponse.Success()));
}
public HttpResponseMessage Add(AddressAddRequest model)
{
if (!ModelState.IsValid)
{
return(CreateErrorResponse());
}
int userId = _auth.GetCurrentUserId();
ItemResponse <int> response = new ItemResponse <int>
{
Item = _service.Add(model, userId)
};
return(Request.CreateResponse(HttpStatusCode.Created, response));
}
public HttpResponseMessage AddAddress(AddressAddRequest model)
{
// if the Model does not pass validation, there will be an Error response returned with errors
if (!ModelState.IsValid)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState));
}
ItemResponse <int> response = new ItemResponse <int>(); //give a domain object //item = Post it in id from proc
string userId = UserService.GetCurrentUserId();
response.Item = _addressService.InsertAddress(model, userId); //inserting from model into database
return(Request.CreateResponse(response));
}
public HttpResponseMessage InsertUserCredits(AddressAddRequest model)
{
if (!ModelState.IsValid)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState));
}
SuccessResponse response = new SuccessResponse();
string UserId = UserService.GetCurrentUserId();
_UserAddressService.InsertAddress(UserId, model);
return(Request.CreateResponse(HttpStatusCode.OK, response));
}
public ActionResult <ItemResponse <int> > Insert(AddressAddRequest model)
{
try
{
int id = _addressService.Insert(model, _authService.GetCurrentUserId());
ItemResponse <int> resp = new ItemResponse <int>();
resp.Item = id;
return(Created201(resp));
}
catch (Exception ex)
{
Logger.LogError(ex.ToString());
return(StatusCode(500, new ErrorResponse(ex.Message)));
}
}
public async Task <ActionResult <dynamic> > GetWeather(AddressAddRequest model)
{
//var weatherResult = new List<Weather>();
//if(!_cache.TryGetValue("id", out weatherResult))
{
string api = "xxxxxxxxxxxx";
string mode = "json";
string units = "imperial";
string requestUri = string.Format($"https://api.openweathermap.org/data/2.5/weather?mode={mode}&appid={api}&units={units}&lat={model.Latitude}&lon={model.Longitude}");
try
{
using (var client = new HttpClient())
{
Task <HttpResponseMessage> request = client.GetAsync(requestUri);
if (request.Result.IsSuccessStatusCode)
{
string content = await request.Result.Content.ReadAsStringAsync();
dynamic result = JObject.Parse(content);
//var weatherData = new Weather();
//weatherData.id = result.id;
//weatherData.temp = result.main.temp;
//weatherData.temp_min = result.main.temp_min;
//weatherData.temp_max = result.main.temp_max;
//weatherData.weather = result.weather;
//_cache.Set("id", weatherData);
return(result);
}
else
{
string error = await request.Result.Content.ReadAsStringAsync();
return(StatusCode(400));
}
}
}
catch (Exception ex)
{
return(StatusCode(500, ex.Message));
}
}
}
public void Add_Test()
{
//Arrange
int userId = 1;
AddressAddRequest address = new AddressAddRequest
{
LineOne = "123 Fake St",
LineTwo = "4",
City = "New York",
StateId = 45,
PostalCode = "10101",
};
//Act
int result = _addressService.Add(address, userId);
//Assert
Assert.IsInstanceOfType(result, typeof(int), "Id must be an int");
Assert.IsTrue(result > 0);
}
public int SaveWaypointAddress(WaypointRequest model)
{
var addressId = 0;
AddressAddRequest newAddress = new AddressAddRequest();
Address CurrentAddress = GetByExternalAddressId(model.Address.ExternalPlaceId);
if (CurrentAddress == null)
{
model.Address.Name = model.ContactName;
addressId = Insert(model.Address);
}
else
{
AddressUpdateRequest Address = new AddressUpdateRequest();
Address.AddressId = CurrentAddress.AddressId;
Address.Name = model.ContactName;
Address.ExternalPlaceId = model.Address.ExternalPlaceId;
Address.Line1 = model.Address.Line1;
Address.City = model.Address.City;
Address.State = model.Address.State;
Address.ZipCode = model.Address.ZipCode;
if (model.Address.Latitude != null && model.Address.Latitude > 0)
{
Address.Latitude = model.Address.Latitude;
}
if (model.Address.Longitude != null && model.Address.Longitude > 0)
{
Address.Longitude = model.Address.Longitude;
}
Update(Address);
addressId = CurrentAddress.AddressId;
}
return(addressId);
}
public AddressServiceTest()
{
List <Address> addressList = new List <Address>();
Address a1 = new Address();
a1.StateProvince = new StateProvince();
Address a2 = new Address();
a2.StateProvince = new StateProvince();
Address a3 = new Address();
a3.StateProvince = new StateProvince();
a1.Id = 1;
a1.LineOne = "777 S. Alameda Ave";
a1.LineTwo = "200";
a1.City = "Los Angeles";
a1.StateProvince.Id = 9;
a1.PostalCode = "90021";
a2.Id = 2;
a2.LineOne = "1229 N. New Hampshire Ave";
a2.LineTwo = "2";
a2.City = "Los Angeles";
a2.StateProvince.Id = 9;
a2.PostalCode = "90029";
a3.Id = 3;
a3.LineOne = "1111 S. Figueroa St.";
a3.LineTwo = "";
a3.City = "Los Angeles";
a3.StateProvince.Id = 9;
a3.PostalCode = "90015";
addressList.Add(a1);
addressList.Add(a2);
addressList.Add(a3);
List <AddressAddRequest> addressAddAddressList = new List <AddressAddRequest>();
AddressAddRequest aar1 = new AddressAddRequest();
//int userId = 41;
aar1.LineOne = "777 S. Alameda Ave";
aar1.LineTwo = "200";
aar1.City = "Los Angeles";
aar1.StateId = 9;
aar1.PostalCode = "90021";
addressAddAddressList.Add(aar1);
List <AddressUpdateRequest> addressUpdateAddressList = new List <AddressUpdateRequest>();
AddressUpdateRequest aur1 = new AddressUpdateRequest();
aur1.Id = 1;
aur1.LineOne = "123 Fake St.";
aur1.LineTwo = "4";
aur1.City = "New York";
aur1.StateId = 4;
aur1.PostalCode = "10101";
addressUpdateAddressList.Add(aur1);
var mock = new Mock <IAddressService>();
mock.Setup(m => m.Add(It.IsAny <AddressAddRequest>(), It.IsAny <int>())).Returns(
(AddressAddRequest insertRequestModel, int userId) =>
{
List <ValidationResult> valididationResults = ValidateModel(insertRequestModel);
if (valididationResults.Count > 0)
{
throw new ValidationException(valididationResults[0], null, insertRequestModel);
}
return(addressAddAddressList.Count + 1);
}
);
mock.Setup(m => m.Get(It.IsAny <int>())).Returns((int id) =>
{
Address model = addressList.Where(m => m.Id == id).FirstOrDefault();
Address newModel = null;
if (model != null)
{
newModel = new Address();
newModel.StateProvince = new StateProvince();
newModel.Id = model.Id;
newModel.LineOne = model.LineOne;
newModel.LineTwo = model.LineTwo;
newModel.City = model.City;
newModel.StateProvince.Id = model.StateProvince.Id;
newModel.PostalCode = model.PostalCode;
}
return(newModel);
});
mock.Setup(m => m.Update(It.IsAny <AddressUpdateRequest>(), It.IsAny <int>())).Callback(
(AddressUpdateRequest updateRequestModel, int userId) =>
{
List <ValidationResult> validationResults = ValidateModel(updateRequestModel);
if (validationResults.Count > 0)
{
throw new ValidationException(validationResults[0], null, updateRequestModel);
}
Address model = addressList.Where(m => m.Id == updateRequestModel.Id).Single();
model.LineOne = updateRequestModel.LineOne;
model.LineTwo = updateRequestModel.LineTwo;
model.City = updateRequestModel.City;
model.StateProvince.Id = updateRequestModel.StateId;
model.PostalCode = updateRequestModel.PostalCode;
}
);
mock.Setup(m => m.Delete(It.IsAny <int>())).Callback(
(int id) =>
{
Address address = addressList.Where(m => m.Id == id).Single();
addressList.Remove(address);
});
mock.Setup(m => m.Get(It.IsAny <int>(), It.IsAny <int>())).Returns(
(int pageIndex, int pageSize) =>
{
List <Address> addressesList = new List <Address>();
int count = (pageIndex) * pageSize;
for (int i = count; i < addressList.Count; i++)
{
if (i < count + pageSize)
{
addressesList.Add(addressList[i]);
}
else
{
break;
}
}
Paged <Address> paged = new Paged <Address>(addressesList, pageIndex, pageSize, addressList.Count);
return(paged);
});
mock.Setup(m => m.GetByUserId(It.IsAny <int>())).Returns((int userId) =>
{
Address model = addressList.Where(m => m.UserId == userId).FirstOrDefault();
Address newModel = null;
if (model != null)
{
newModel = new Address();
newModel.StateProvince = new StateProvince();
newModel.Id = model.Id;
newModel.LineOne = model.LineOne;
newModel.LineTwo = model.LineTwo;
newModel.City = model.City;
newModel.StateProvince.Id = model.StateProvince.Id;
newModel.PostalCode = model.PostalCode;
newModel.UserId = model.UserId;
}
return(newModel);
});
_addressService = mock.Object;
}
