public IHttpActionResult DeleteCountry(int countryId)
{
CountryRequest request = new CountryRequest
{
CountryDto = new CountryDto {
CountryId = countryId
}
};
List <string> errors = ValidateDeleteCountry(request);
CountryMessage message = new CountryMessage();
if (errors != null && errors.Any())
{
message.ErrorMessage = CountryMessageResource.ValidationErrors;
message.ErrorType = ErrorType.ValidationError;
message.Errors = new List <string>();
message.OperationSuccess = false;
message.Errors.AddRange(errors);
}
else
{
message = _serviceCountryClient.DeleteCountry(request);
}
return(Json(message));
}
public IPagedResults <CountryResponse> GetCountrys(CountryRequest request)
{
var respone = new PagedResults <CountryResponse>();
var query = _countryRepository.GetAllNoneDeleted();
respone.Total = query.Count();
//sort data
if (!string.IsNullOrEmpty(request?.SortField))
{
OrderBy(ref query, request);
}
else
{
query = query.OrderBy(x => x.CountryName);
}
//pagging data
if (request?.Skip != null && request.Take.HasValue)
{
Paging(ref query, request);
}
var result = Mapper.Map <List <Country>, List <CountryResponse> >(query.ToList());
respone.Data = result;
return(respone);
}
public ContentResult editcountry(CountryRequest request)
{
var msg = string.Empty;
var flag = _countryService.Edit(request, UserContext.SysUserContext.Id, out msg);
return(Result <string>(flag, msg));
}
public string GetCountryName(CountryRequest request)
{
var test = new CountryRepository();
var drzave = test.GetAll();
return(drzave[0].Name);
}
public override Task <CountryReply> GetCountry(CountryRequest request, ServerCallContext context)
{
_logger.LogInformation("Querying for country...");
CountryReply country = null;
try
{
country = _Db.GetCountries()
.Where(candidate => String.Equals(request.Country, candidate.CountryFull, StringComparison.OrdinalIgnoreCase))
.First();
}
catch (Exception ex)
{
_logger.LogError($"{ex.GetType()} occured; {ex.Message}; ");
country = new CountryReply {
Message = ex.Message,
CountryFull = ""
};
}
if (country.CountryFull != "")
{
country.Players.AddRange(GetPlayersFromCountry(country.CountryFull));
}
return(Task.FromResult(country));
}
/// <summary>
/// Validation delete country.
/// </summary>
/// <param name="request">the request to validate.</param>
/// <returns>errors validation</returns>
private List <string> ValidateFindCountries(CountryRequest request)
{
var errors = new List <string>();
if (request?.CountryDto == null)
{
errors.Add(CountryMessageResource.NullRequest);
}
else
{
switch (request.FindCountryDto)
{
case FindCountryDto.CountryId:
errors.AddRange(GenericValidationAttribute <CountryDto> .ValidateAttributes("CountryId",
request.CountryDto.CountryId.ToString()));
break;
case FindCountryDto.CountryCode:
errors.AddRange(GenericValidationAttribute <CountryDto> .ValidateAttributes("CountryCode",
request.CountryDto.CountryCode.ToString()));
break;
case FindCountryDto.CountryShortName:
errors.AddRange(GenericValidationAttribute <CountryDto> .ValidateAttributes("CountryShortName",
request.CountryDto.CountryShortName));
break;
}
}
return(errors);
}
public async Task <ActionResult> Create(CountryRequest countryRequest)
{
try
{
RestRequest restRequest = new RestRequest("api/Countries", Method.POST);
restRequest.AddHeader("content-type", "multipart/form-data");
restRequest.AddParameter("name", countryRequest.Name);
using (var ms = new MemoryStream())
{
countryRequest.PhotoUrl.CopyTo(ms);
var fileBytes = ms.ToArray();
restRequest.AddFile("PhotoUrl", fileBytes, countryRequest.PhotoUrl.FileName, countryRequest.PhotoUrl.ContentType);
}
var response = await RestClient.ExecuteAsync(restRequest);
if (response.StatusCode == HttpStatusCode.BadRequest)
{
throw new Exception("Not Created");
}
return(RedirectToAction(nameof(Index)));
}
catch (Exception e)
{
ViewBag.Message = e.Message;
return(View());
}
}
public async Task <CountryModel> GetCountry(CountryRequest request)
{
var entity = _reader.Get(KycCountryNoSqlEntity.GeneratePartitionKey(),
KycCountryNoSqlEntity.GenerateRowKey(request.CountryCode));
return(entity?.Country ?? await _grpcService.GetCountry(request));
}
public bool Insert(CountryRequest request, int sysUserId, out string msg)
{
bool flag = false;
msg = string.Empty;
try
{
if (request.Name.IsEmpty())
{
msg = "名称不能为空";
return(flag);
}
_dbContext.Insert(new t_sys_country
{
name = request.Name
});
flag = true;
}
catch (Exception ex)
{
flag = false;
msg = "服务异常";
LogUtils.LogError("CountryService.Insert", ex);
}
return(flag);
}
public bool Edit(CountryRequest request, int sysUserId, out string msg)
{
bool flag = false;
msg = string.Empty;
try
{
if (request.Name.IsEmpty())
{
msg = "名称不能为空";
return(flag);
}
t_sys_country country = _dbContext.Get <t_sys_country>(request.Id);
if (country != null)
{
country.name = request.Name;
_dbContext.Update(country);
flag = true;
}
else
{
msg = "数据信息不存在";
}
}
catch (Exception ex)
{
flag = false;
msg = "服务异常";
LogUtils.LogError("CountryService.Edit", ex);
}
return(flag);
}
public async Task <Country> GetAsync(string code, CountryRequest request)
{
Requires.ArgumentNotNull(request, nameof(request));
var countryLink = await _linkFactory.CreateLinkAsync($"countries/{code}").ConfigureAwait(_halClient);
return(await _halClient.GetAsync <Country>(countryLink, request).ConfigureAwait(_halClient));
}
//[Authorize]
public override async Task <CountryReply> Update(CountryRequest request, ServerCallContext context)
{
//var currentUser = context.GetHttpContext().User;
var updateCountry = _mapper.Map <Country>(request);
var country = await _countryService.UpdateAsync(updateCountry);
return(_mapper.Map <CountryReply>(country));
}
/// <summary>
/// From Country Request to Country Request pivot.
/// </summary>
/// <param name="countryRequest"></param>
/// <returns>Country Request pivot result.</returns>
public static CountryRequestPivot ToPivot(this CountryRequest countryRequest)
{
return(new CountryRequestPivot
{
CountryPivot = countryRequest.CountryDto.ToPivot(),
FindCountryPivot = Utility.EnumToEnum <FindCountryDto, FindCountryPivot>(countryRequest.FindCountryDto)
});
}
public async Task <IReadOnlyList <Country> > GetAllAsync(CountryRequest request)
{
Requires.ArgumentNotNull(request, nameof(request));
var root = await _halClient.GetRootAsync().ConfigureAwait(_halClient);
return(await _halClient.GetAllPagesAsync <Country>(root.CountriesLink, request).ConfigureAwait(_halClient));
}
public async Task <PagedResource <Country> > GetAsync(CountryRequest request)
{
Requires.ArgumentNotNull(request, nameof(request));
var root = await _halClient.GetRootAsync().ConfigureAwait(_halClient);
return(await _halClient.GetAsync <PagedResource <Country> >(
root.CountriesLink,
request).ConfigureAwait(_halClient));
}
public async Task <IActionResult> Post([FromForm] CountryRequest country)
{
bool created = await CountryService.Add(country);
if (!created)
{
return(BadRequest());
}
return(Ok());
}
public async Task <CountryModel> GetCountry(CountryRequest request)
{
try
{
return(await _repository.GetCountry(request.CountryCode));
}
catch (Exception e)
{
_logger.LogError(e, "When getting country {country}", request.CountryCode);
throw;
}
}
protected override bool isValid(out string exceptionMessage)
{
if (name.Length == 0) {
return makeExceptionMessage (out exceptionMessage, "The name of the country is invalid");
}
CountryRequest cr = new CountryRequest ();
if (cr.fetchCountryFromName (name).Count != 0) {
return makeExceptionMessage (out exceptionMessage, "The name of the country is invalid because it already exists.");
}
return makeExceptionMessage(out exceptionMessage);
}
public async Task <PagedResult <CountryResponse> > GetPageAsync(CountryRequest request)
{
PagedResult <CountryResponse> pagedResult = await _context
.Countries.AsQueryable()
.Select(i => new CountryResponse
{
Id = i.Id,
Name = i.Name
})
.ToPagedResultAsync(request);
return(pagedResult);
}
public HttpResponseMessage GetAllCountries([FromUri] CountryRequest request)
{
try
{
var users = _adminServices.GetCountrys(request);
return(users != null?Request.CreateResponse(HttpStatusCode.OK, users) :
Request.CreateResponse(HttpStatusCode.NoContent, Constants.ErrorMessageCodes.NoRecordsFoundMessage));
}
catch (Exception exception)
{
return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, exception.Message));
}
}
public string GetCountryList()
{
string stringData = null;
string tid = hadc.GetTokenId();
var response1 = string.Empty;
CountryRequest cf = new CountryRequest();
cf.ClientId = ClientId;
cf.TokenId = tid;
cf.EndUserIp = ip.Replace(" ", "");
try
{
HttpClient client = new HttpClient();
client.BaseAddress = new Uri(BaseUriUpToCityData);
MediaTypeWithQualityHeaderValue contentType = new MediaTypeWithQualityHeaderValue("application/json");
client.DefaultRequestHeaders.Accept.Add(contentType);
var contentData = new StringContent(JsonConvert.SerializeObject(cf), System.Text.Encoding.UTF8, "application/json");
HttpResponseMessage response = client.PostAsync("rest/CountryList", contentData).Result;
stringData = response.Content.ReadAsStringAsync().Result;
string str = stringData;
var obj = JsonConvert.DeserializeObject <countrys>(str);
Console.WriteLine(obj.Countrylist);
int status = obj.Status;
if (status == 1)
{
string countryListData = obj.Countrylist;
XDocument doc = XDocument.Parse(countryListData);
var CountryCodes = from service in doc.Descendants("Country")
select(string) service.Element("Code");
var CountryNames = from service in doc.Descendants("Country")
select(string) service.Element("Name");
CountryTab ct = new CountryTab();
foreach (var item in CountryCodes.Zip(CountryNames, (a, b) => new { A = a, B = b }))
{
var a = item.A;
var b = item.B;
ct.CountryCode = a;
ct.CountryName = b;
hotelCity.CountryTabs.Add(ct);
hotelCity.SaveChanges();
}
}
}
catch (WebException ex)
{
ViewBag.Ex = ex;
}
return(stringData);
}
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 <List <CountryModel> > Post([FromBody] CountryRequest country)
{
var userAgent = Request.Headers["User-Agent"];
if (country == null || country.Name == null || country.Name.Length == 0 || (country.Name.EndsWith(" ") && country.Name.StartsWith(" ")))
{
throw new ArgumentNullException("Argument is not defined");
}
;
var result = GetCountryData(country.Name).Result;
await queueConnector.SendMessagesAsync(result);
return(result);
}
/// <summary>
/// Delete Country
/// </summary>
/// <param name="request">country request.</param>
/// <returns>Country message.</returns>
public CountryMessage DeleteCountry(CountryRequest request)
{
CountryMessage message = new CountryMessage();
try
{
_serviceCountry.DeleteCountry(request.ToPivot());
message.OperationSuccess = true;
}
catch (Exception e)
{
message.ErrorType = ErrorType.TechnicalError;
message.ErrorMessage = e.Message;
}
return(message);
}
public override async Task <CountryReply> Update(CountryRequest request, ServerCallContext context)
{
var currentUser = context.GetHttpContext().User;
try
{
var updateCountry = _mapper.Map <Country>(request);
var country = await _countryService.UpdateAsync(updateCountry);
return(_mapper.Map <CountryReply>(country));
}
catch (Exception e)
{
throw new RpcException(Status.DefaultCancelled, e.Message);
}
}
/// <summary>
/// Validation delete country.
/// </summary>
/// <param name="request">the request to validate.</param>
/// <returns>errors validation</returns>
private List <string> ValidateDeleteCountry(CountryRequest request)
{
var errors = new List <string>();
if (request?.CountryDto == null)
{
errors.Add(CountryMessageResource.NullRequest);
}
else
{
errors.AddRange(GenericValidationAttribute <CountryDto> .ValidateAttributes("CountryId",
request.CountryDto.CountryId.ToString()));
}
return(errors);
}
public async Task <bool> Add(CountryRequest countryReq)
{
Guid Id = Guid.NewGuid();
string url = await ImageService.UploadImage(Id, countryReq.PhotoUrl);
Country country = new Country()
{
Id = Id,
Name = countryReq.Name,
States = countryReq.States,
Friends = countryReq.Friends,
PhotoUrl = url
};
return(await CountryRepository.Add(country));
}
public override async Task <CountryReply> Update(CountryRequest request, ServerCallContext context)
{
var currentUser = context.GetHttpContext().User;
try
{
var updateCountry = _mapper.Map <Country>(request);
var country = await _countryService.UpdateAsync(updateCountry);
return(_mapper.Map <CountryReply>(country));
}
catch (Exception e)
{
var httpContext = context.GetHttpContext();
httpContext.Response.StatusCode = 500; // Required to fire Polly retry policy, else 200 will be returned
throw new RpcException(Status.DefaultCancelled, e.Message);
}
}
public IHttpActionResult FindCountries(CountryRequest request)
{
List <string> errors = ValidateFindCountries(request);
CountryMessage message = new CountryMessage();
if (errors != null && errors.Any())
{
message.ErrorMessage = CountryMessageResource.ValidationErrors;
message.ErrorType = ErrorType.ValidationError;
message.Errors = new List <string>();
message.OperationSuccess = false;
message.Errors.AddRange(errors);
}
else
{
message = _serviceCountryClient.FindCountries(request);
}
return(Json(message));
}
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 ActionResult addnewCountry(CountryRequest countryRequest)
{
var countryname = appDbContex.Countries.Where(a => a.CountryName == countryRequest.CountryName).FirstOrDefault();
if (countryname == null)
{
string id = Guid.NewGuid().ToString();
Country country = new Country
{
Id = id,
CountryName = countryRequest.CountryName,
CountryCode = countryRequest.CountryCode
};
appDbContex.Countries.Add(country);
appDbContex.SaveChangesAsync();
return(Ok(new { Message = "Country Name add successfully!" }));
// return Ok("Country Name add successfully!");
}
return(BadRequest(new { Message = "Country Name Already Exists!" }));
}
public async Task <OperationResponse> DeleteCountry(CountryRequest request)
{
try
{
await _repository.DeleteCountry(request.CountryCode);
return(new OperationResponse()
{
IsSuccess = true
});
}
catch (Exception e)
{
_logger.LogError(e, "When deleting country {country}", request.CountryCode);
return(new OperationResponse()
{
IsSuccess = false,
Error = e.Message
});
}
}
