public bool Insert(CityRequest request, int sysUserId, out string msg)
{
bool flag = false;
msg = string.Empty;
try
{
if (request.ProvinceId <= 0)
{
msg = "省份不能为空";
return(flag);
}
if (request.Name.IsEmpty())
{
msg = "名称不能为空";
return(flag);
}
_dbContext.Insert(new t_sys_city
{
provinceId = request.ProvinceId,
name = request.Name
});
flag = true;
}
catch (Exception ex)
{
flag = false;
msg = "服务异常";
LogUtils.LogError("CityService.Insert", ex);
}
return(flag);
}
public ActionResult CreateCity(CityViewModel city)
{
var ncity = new CityRequest()
{
Description = city.Description,
ProvinceId = city.ProvinceId
};
try
{
var result = false;
if (city.Id == 0)
{
result = this.CityService.CreateCity(ncity);
}
if (result)
{
return(Redirect("/System/Index"));
}
else
{
return(View("../Shared/Error"));
}
}
catch (Exception ex)
{
return(View("../Shared/Error"));
}
}
public ContentResult editcity(CityRequest request)
{
var msg = string.Empty;
var flag = _cityService.Edit(request, UserContext.SysUserContext.Id, out msg);
return(Result <string>(flag, msg));
}
public async Task <int> Update(int id, CityRequest data)
{
var city = await _context.Cities.FindAsync(id);
city.Name = data.name;
_context.Cities.Update(city);
try
{
await _context.SaveChangesAsync();
return(1);
}
catch (DbUpdateConcurrencyException)
{
if (!CityExists(id))
{
return(0);
}
else
{
throw;
}
}
}
public ActionResult GetCity(int id, string name)
{
var request = new CityRequest(id, name);
var res = _cityService.GetCityById(request);
return(View(res));
}
public ResponseBase GetCityById(CityRequest request)
{
var response = new ResponseBase();
var result = Factory.Perform.GetSingle <CityResult>("usp_City_GetById", request);
this.SuccessfulResponse(response, result);
return(response);
}
public IHttpActionResult Post(CityRequest city)
{
var result = CityService
.CreateCity(city);
return(Created <Entidad>("", new Entidad {
Id = result.Id
}));
}
public IEnumerable <City> GetCities(CityRequest request)
{
if (request == null)
{
return(null);
}
return(_geoRepository.GetCityStateByName(request.Name, request.CountryCode));
}
public async Task <int> Create(CityRequest data)
{
City city = _mapper.Map <City>(data);
_context.Cities.Add(city);
int resp = await _context.SaveChangesAsync();
return(resp);
}
public async Task <Check> CheckApi(CheckSettings settings, CityRequest requestModel)
{
var result = new Check {
Settings = settings
};
result.State.LastCheckTime = DateTime.Now;
return(await PerformCheck(settings.EnvironmentId, result, requestModel));
}
private async Task <Check> PerformCheck(int environmentId, Check check, CityRequest requestModel)
{
check.State.Status = StatusesEnum.CRITICAL;
var address = new EnvironmentHelper().GetApiUrl(environmentId);
var query = $"{address}/api/delivery/settlements";
//var requestModel = new CityRequest
//{
// AreaId = 57,
// DeliveryMethodKey = 3,
// DistrictId = 0,
// LanguageId = 2,
// SearchString = "хар"
//};
var response = _httpService.PerformPostRequest(query, timeOut, requestModel);
var result = response.Result;
if (!result.IsSuccessStatusCode)
{
check.State.Description = "Полученный статус-код для населенных пунктов: " + result.StatusCode;
return(check);
}
try
{
var responseContent = await result.Content.ReadAsStringAsync();
var settlementsResponseModel = JsonConvert.DeserializeObject <ApiResponse <List <SettlementModel> > >(responseContent);
if (!settlementsResponseModel.Success)
{
var errorsStr = string.Join(".", settlementsResponseModel.Errors);
check.State.Description = "Ошибка получения населенных пунктов: " + errorsStr;
return(check);
}
if (settlementsResponseModel?.Data?.Count == 0)
{
check.State.Description = "Получен пустой список населенных пунктов";
return(check);
}
}
catch (Exception e)
{
check.State.Description = "Исключение во время получения населенных пунктов: " + e.Message;
}
check.State.Status = StatusesEnum.OK;
check.State.Description = "Проблем не обнаружено";
return(check);
}
public override async Task GetCities(CityRequest request,
IServerStreamWriter <CityResponse> responseStream,
ServerCallContext context)
{
var list = await GetHttpCitiesAsync();
foreach (var c in list)
{
await responseStream.WriteAsync(c);
}
}
public City CreateCity(CityRequest City)
{
var entity = new DomainModel.City()
{
Description = City.Description,
Province = this.ProvinceRepository.GetById(City.ProvinceId)
};
this.CityRepository.Insert(entity);
return(entity);
}
public static City ToCity(this CityRequest src)
{
return(new City()
{
Id = Guid.NewGuid(),
Name = src.CityName,
Place = src.Place,
StartDate = src.StartDate,
EndDate = src.EndDate
});
}
public CityResponse GetCityInfos(CityRequest cityRequest)
{
if (cityRequest.provinceId <= 0)
{
cityRequest.provinceId = 0;
}
CityResponse response = new CityResponse();
response.CityInfos = BaseBLL <CityBLL> .Instance.GetCityInfos(cityRequest.provinceId);
return(response);
}
public async Task <BaseResponse> AddCity(CityRequest request)
{
BaseResponse baseResponse = new BaseResponse();
City city = null;
city = Mapper.Map <CityRequest, City>(request, city);
await DbContext.City.AddAsync(city);
var update = await DbContext.SaveChangesAsync();
return(baseResponse);
}
public async Task <PagedResult <CityResponse> > GetPageAsync(CityRequest request)
{
PagedResult <CityResponse> pagedResult = await _context
.Cities.AsQueryable()
.Select(i => new CityResponse
{
Id = i.Id,
Name = i.Name,
Zip = i.Zip
})
.ToPagedResultAsync(request);
return(pagedResult);
}
public void testGetData()
{
var cookie = new Cookie("incap_ses_264_1276841", "zqTLGFJTOmAn/CN5P+2pA8RTRF4AAAAA55D7hroVG4lj6zw6nY4UMQ==");
var dataReceiver = new DataReceiver(cookie);
var airportsRequest = new AirportRequest("", "", "LLBG");
var airlinesRrequest = new AirlineRequest("", "LLBG");
var countriesRequest = new CountryRequest("", "LLBG");
var citiesRequest = new CityRequest("", "", "LLBG");
var airlines = dataReceiver.GetData <Airline>(airlinesRrequest);
var airports = dataReceiver.GetData <Airport>(airportsRequest);
var countries = dataReceiver.GetData <Country>(countriesRequest);
var cities = dataReceiver.GetData <City>(citiesRequest);
}
public async Task <ActionResult> NeedOTP([FromBody] CityRequest request)
{
try
{
await _CityAdapter.AddCity(request);
return(Ok());
}
catch (Exception ex)
{
_logger.LogError(ex, "asdf");
return(Ok());
}
}
public async Task <ActionResult> Create([FromBody] CityRequest request)
{
try
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
return(Ok(await _cityService.Create(request)));
}
catch (Exception ex)
{
return(BadRequest());
}
}
public async override Task GetAllCities(CityRequest request, IServerStreamWriter <CityResponse> responseStream, ServerCallContext context)
{
int i = 0;
while (!context.CancellationToken.IsCancellationRequested && i < _theList.Count())
{
foreach (var item in _theList)
{
await Task.Delay(1000); //waiting one second for each response
_logger.LogInformation("Sending City Data");
i++;
await responseStream.WriteAsync(item);
}
}
}
public async Task <IActionResult> GetCityById([FromRoute] CityRequest request)
{
var model = await _cityService.GetCityByIdAsync(request.CityId);
if (model == null)
{
return(BadRequest());
}
var response = new CityGetByIdResponse
{
Code = "success",
Message = "city.get.success",
Data = model
};
return(Ok(model));
}
public IActionResult UpdateCity(CityRequest cityRequest)
{
var city = _cityRepository.GetCity(cityRequest.Id);
var oblast = _oblastRepository.GetOblast(cityRequest.OblastId);
if (city == null)
{
return(NotFound("City Not Found"));
}
if (oblast == null)
{
return(NotFound("Oblast Not Found"));
}
city.Name = city.Name;
city.OblastId = oblast.Id;
city.Oblast = oblast;
_cityRepository.Update(city);
return(Ok("Updated successfully"));
}
protected override bool isValid(out string exceptionMessage)
{
if (name.Length == 0) {
return makeExceptionMessage (out exceptionMessage, "The name of the city is invalid");
}
if (!validCountry (country, out exceptionMessage)) {
return false;
}
CountryRequest cor = new CountryRequest ();
string countryName = cor.fetchFromID (country) [0].name;
CityRequest cr = new CityRequest ();
if (cr.fetchFromNameAndCountry (name, countryName).Count () != 0) {
return makeExceptionMessage (out exceptionMessage, "The name of the city already exists for a city in the country " + countryName);
}
return makeExceptionMessage(out exceptionMessage);
}
public async Task <CommandResult> Handle(DeliveryAutoSettlementsCheckCommand request, CancellationToken cancellationToken)
{
var result = new CommandResult {
Success = true
};
var check = new SettlementsCheck(_httpService);
var requestModel = new CityRequest
{
AreaId = 57,
DeliveryMethodKey = 3,
DistrictId = 598,
LanguageId = 2,
SearchString = ""
};
result.CheckModel = await check.CheckApi(request.CheckSettings, requestModel);
return(result);
}
public async Task <ActionResult> Update([FromRoute] int id, [FromBody] CityRequest city)
{
try
{
if (id == 0)
{
return(BadRequest());
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
return(Ok(await _cityService.Update(id, city)));
}
catch (Exception ex)
{
return(BadRequest());
}
}
public async Task <Response> Create(CityRequest model)
{
int result = await _cityRepository.Create(model);
if (result == 1)
{
return(new Response
{
IsSuccess = true,
Message = "Se creo exitosamente"
});
}
else
{
return(new Response
{
IsSuccess = false,
Message = "No fue creada"
});
}
}
public bool Edit(CityRequest request, int sysUserId, out string msg)
{
bool flag = false;
msg = string.Empty;
try
{
if (request.ProvinceId <= 0)
{
msg = "省份不能为空";
return(flag);
}
if (request.Name.IsEmpty())
{
msg = "名称不能为空";
return(flag);
}
t_sys_city city = _dbContext.Get <t_sys_city>(request.Id);
if (city != null)
{
city.name = request.Name;
city.provinceId = request.ProvinceId;
_dbContext.Update(city);
flag = true;
}
else
{
msg = "数据信息不存在";
}
}
catch (Exception ex)
{
flag = false;
msg = "服务异常";
LogUtils.LogError("CityService.Edit", ex);
}
return(flag);
}
public IActionResult AddCity(CityRequest cityRequest)
{
var oblastId = cityRequest.OblastId;
var cityName = cityRequest.Name;
var oblast = _oblastRepository.GetOblast(oblastId);
if (oblast == null)
{
return(NotFound("Oblast Not Found"));
}
var city = new City
{
Name = cityName,
OblastId = oblastId,
Oblast = oblast
};
oblast.Cities.Add(city);
_cityRepository.Add(city);
_oblastRepository.Update(oblast);
return(Ok("Successful"));
}
public async Task <Response> Update(int id, CityRequest request)
{
int result = await _cityRepository.Update(id, request);
if (result > 0)
{
return(new Response
{
IsSuccess = true,
Message = "Se actualizó exitosamente",
Result = result
});
}
else
{
return(new Response
{
IsSuccess = false,
Message = "No fue actualizada correctamente"
});
}
}
public async Task <IActionResult> AddCityRequest([FromBody] CityRequest cityRequest)
{
return(Ok());
}
