public CountryContext country()
{
CountryContext _localctx = new CountryContext(Context, State);
EnterRule(_localctx, 2, RULE_country);
int _la;
try {
EnterOuterAlt(_localctx, 1);
{
{
State = 9; Match(COUNTRY);
State = 11;
ErrorHandler.Sync(this);
_la = TokenStream.LA(1);
if (_la == COMMA)
{
{
State = 10; Match(COMMA);
}
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
ErrorHandler.ReportError(this, re);
ErrorHandler.Recover(this, re);
}
finally {
ExitRule();
}
return(_localctx);
}
public async Task <Activity> GetActivitiesByUniqCode(string uniqCode)
{
using (var db = new CountryContext())
{
return(await db.Activity.FirstOrDefaultAsync(_ => _.UniqId == uniqCode));
}
}
public async Task <List <Activity> > GetActivities()
{
using (var db = new CountryContext())
{
return(await db.Activity.ToListAsync());
}
}
static void Main(string[] args)
{
using (var context = new CountryContext("name=CountriesConnectionString"))
{
using (var store = new UserStore <User>(context))
{
using (var manager = new UserManager(store))
{
User u = new User()
{
UserName = "******",
PhoneNumber = "8123456",
Email = "*****@*****.**"
};
var res = manager.CreateAsync(u, "password").Result;
}
}
}
//using (IUnitOfWork uow = new UnitOfWork(new CountryContext()))
//{
// var countries = uow.CountryRepository.Find(
// //new string[] { "RU", "LV" },
// null
// //new string[] { "USA", "Latvia", "XXX"});
// );
// uow.Complete();
//}
Console.WriteLine("Ready");
Console.ReadKey();
}
public async Task <Country> GetCountriesById(int countryId)
{
using (var db = new CountryContext())
{
return(await db.Country.FirstOrDefaultAsync(_ => _.CountryId == countryId));
}
}
public async Task <Activity> GetActivitiesById(int ActivityId)
{
using (var db = new CountryContext())
{
return(await db.Activity.FirstOrDefaultAsync(_ => _.ActivityId == ActivityId));
}
}
public async Task <List <Country> > GetCountries()
{
using (var db = new CountryContext())
{
return(await db.Country.ToListAsync());
}
}
public async Task <List <Activity> > GetActivitiesByISO(string ISO)
{
using (var db = new CountryContext())
{
var countryId = db.Country.FirstOrDefaultAsync(_ => _.CountryISOCode == ISO).Result.CountryId;
return(await db.Activity.Where(_ => _.CountryId == countryId).ToListAsync());
}
}
public async Task UpdateCountry(Country country)
{
using (var db = new CountryContext())
{
db.Country.Update(country);
await db.SaveChangesAsync();
}
}
public async Task <Activity> GetActivitiesByUniqCodeAndISO(string uniqCode, string ISO)
{
using (var db = new CountryContext())
{
var countryId = db.Country.FirstOrDefaultAsync(_ => _.CountryISOCode == ISO).Result.CountryId;
return(await db.Activity.FirstOrDefaultAsync(_ => _.CountryId == countryId && _.UniqId == uniqCode));
}
}
public async Task UpdateActivity(Activity Activity)
{
using (var db = new CountryContext())
{
db.Activity.Update(Activity);
await db.SaveChangesAsync();
}
}
public async Task AddCountry(Country country)
{
using (var db = new CountryContext())
{
await db.Country.AddAsync(country);
await db.SaveChangesAsync();
}
}
public List <T> ParsingResult <T, T2>(List <T2> data) where T : Entity where T2 : class
{
var parsedData = data as List <CountryDto>;
if (parsedData == null)
{
throw new System.Exception("Can't parse data");
}
var countries = new List <CountryEntity>();
using (var context = new CountryContext())
{
var regions = parsedData.Select(x => x.Region.Value);
var incomeLevels = parsedData.Select(x => x.IncomeLevel.Value);
var adminregions = parsedData.Select(x => x.Adminregion.Value);
var lendingTypes = parsedData.Select(x => x.LendingType.Value);
var values = regions.Concat(incomeLevels.Concat(adminregions.Concat(lendingTypes))).Distinct().ToList();
var allRegions = context.Regions
.Where(x => values.Contains(x.Value))
.ToList();
foreach (var country in countries)
{
var adminregion = allRegions
.FirstOrDefault(x => x.Value == country.Adminregion.Value);
var incomeLevel = allRegions
.FirstOrDefault(x => x.Value == country.IncomeLevel.Value);
var region = allRegions
.FirstOrDefault(x => x.Value == country.Region.Value);
var lendingType = allRegions
.FirstOrDefault(x => x.Value == country.LendingType.Value);
var newCountry = new CountryEntity
{
Adminregion = adminregion,
IncomeLevel = incomeLevel,
Region = region,
LendingType = lendingType,
CapitalCity = country.CapitalCity,
Iso2Code = country.Iso2Code,
Latitude = country.Latitude,
Longitude = country.Longitude,
Name = country.Name
};
countries.Add(newCountry);
}
}
return(countries as List <T>);
}
public async Task AddActivity(Activity Activity, string countryISOCode)
{
using (var db = new CountryContext())
{
Activity.UniqId = GenereteUniqId(countryISOCode, Activity.ActivityName);
await db.Activity.AddAsync(Activity);
await db.SaveChangesAsync();
}
}
// GET: Cities
public IActionResult Index(bool isReadable, SortState sortOrder = SortState.NameAsc, string searchString = "")
{
List <City> cities = _context.city.ToList();
HoaraSort(cities, sortOrder, 0, cities.Count - 1);
ViewData["NameSort"] = sortOrder == SortState.NameAsc ? SortState.NameDesc : SortState.NameAsc;
ViewData["CurrentFilter"] = searchString;
ViewData["isReadable"] = false;
if (!string.IsNullOrEmpty(searchString))
{
cities = cities.Where(s => s.name.StartsWith(searchString)).ToList();
}
if (isReadable)
{
ViewData["isReadable"] = true;
CountryContext countryContext = new CountryContext();
RegionContext regionContext = new RegionContext();
var query = cities.AsQueryable().Join(regionContext.region,
cities => cities.region_id,
region => region.region_id,
(cities, region) => new
{
cities.city_id,
cities.country_id,
City = cities.name,
Region = region.name,
})
.Join
(
countryContext.country,
cities => cities.country_id,
country => country.country_id,
(cities, country) => new FullCity
{
city_id = cities.city_id,
City = cities.City,
Region = cities.Region,
Country = country.name
}
);
ViewData["Res"] = query.ToList();
return(View());
}
return(View(cities));
}
public void Save <T>(T entity) where T : Entity
{
var saveEntity = entity as CountryEntity;
if (saveEntity == null)
{
throw new System.Exception("Can't save empty entity");
}
using (var context = new CountryContext())
{
context.Countries.Add(saveEntity);
context.SaveChanges();
}
}
public EditMemberViewModel()
{
_memberContext = ContextFactory.GetTeamContext();
_userContext = ContextFactory.GetUserRegistrationContext();
_countryContext = ContextFactory.GetCountryContext();
_membershipContext = ContextFactory.GetMembershipContext();
_saveChangesCommand = new RelayCommand( OnSaveChanges );
_changePasswordCommand = new RelayCommand( OnChangePassword );
statusTimer = new DispatcherTimer();
statusTimer.Interval = new TimeSpan( 0, 0, 0, 3 );
statusTimer.Tick += new EventHandler( OnTimerTick );
IsStatusVisible = Visibility.Collapsed;
IsLoggedIn = true;
//LoadData(id);
UpdateForUsersRole();
}
public async Task <bool> DeleteCountry(int countryId)
{
using (var db = new CountryContext())
{
var countryForDelete = await db.Country.FirstOrDefaultAsync(_ => _.CountryId == countryId);
if (countryForDelete == null)
{
return(false);
}
db.Country.Remove(countryForDelete);
await db.SaveChangesAsync();
return(true);
}
}
public async Task <bool> DeleteActivity(int ActivityId)
{
using (var db = new CountryContext())
{
var ActivityForDelete = await db.Activity.FirstOrDefaultAsync(_ => _.ActivityId == ActivityId);
if (ActivityForDelete == null)
{
return(false);
}
db.Activity.Remove(ActivityForDelete);
await db.SaveChangesAsync();
return(true);
}
}
public CountriesController(CountryContext context, StateContext stateContext)
{
_context = context;
_stateContext = stateContext;
if (_context.Countries.Count() == 0)
{
Country country = new Country {
Name = "United States", Code = "US"
};
State state = new State {
Name = "Virginias", Code = "VA", Country = country, CountryId = country.CountryId
};
_stateContext.States.Add(state);
_context.Countries.Add(country);
_context.SaveChanges();
_stateContext.SaveChanges();
}
}
public void Save <T>(List <T> entities) where T : Entity
{
var saveEntityList = entities as List <CountryEntity>;
if (saveEntityList == null)
{
throw new System.Exception("Can't save empty entity");
}
using (var context = new CountryContext())
{
foreach (var saveEntity in saveEntityList)
{
context.Countries.Add(saveEntity);
}
context.SaveChanges();
}
}
public CountryContext country()
{
CountryContext _localctx = new CountryContext(Context, State);
EnterRule(_localctx, 20, RULE_country);
try {
EnterOuterAlt(_localctx, 1);
{
State = 79; Match(COUNTRY);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
ErrorHandler.ReportError(this, re);
ErrorHandler.Recover(this, re);
}
finally {
ExitRule();
}
return(_localctx);
}
// GET: Regions
public IActionResult Index(bool isReadable, SortState sortOrder = SortState.NameAsc, string searchString = "")
{
IQueryable <Region> regions = _context.region.ToList().AsQueryable();
ViewData["NameSort"] = sortOrder == SortState.NameAsc ? SortState.NameDesc : SortState.NameAsc;
ViewData["CurrentFilter"] = searchString;
ViewData["isReadable"] = false;
if (!string.IsNullOrEmpty(searchString))
{
regions = regions.Where(s => s.name.StartsWith(searchString));
}
regions = sortOrder switch
{
SortState.NameDesc => regions.OrderByDescending(s => s.name),
_ => regions.OrderBy(s => s.name),
};
if (isReadable == true)
{
ViewData["isReadable"] = true;
CountryContext countryContext = new CountryContext();
var query = regions.Join(
countryContext.country,
regions => regions.country_id,
country => country.country_id,
(regions, country) => new FullRegion
{
region_id = regions.region_id,
Country = country.name,
Region = regions.name
});
ViewData["Res"] = query.AsNoTracking().ToList();
return(View());
}
return(View(regions.AsNoTracking().ToList()));
}
public CountriesController(CountryContext context)
{
_context = context;
}
static void Main(string[] args)
{
using (var dbContext = new ApplicationDbContext()) {
var _ctx = new CountryContext(new ApplicationDbContext());
var countries = _ctx.Countries.Include(cntr => cntr.Cities).ToList();
foreach (var country in countries)
{
Console.WriteLine($"COUNTRY : ID : {country.CountryId} - NAME : {country.CountryName}");
foreach (var city in country.Cities)
{
Console.WriteLine($" ---- CITY : ID : {city.CityId} - NAME : {city.CityName}");
}
}
var _accCtx = new AccountContext(dbContext);
var _clientCtx = new ClientContext(dbContext);
var accounts = _accCtx.Accounts.Include(acc => acc.Client).ToList();
var clients = _clientCtx.Clients.Include(cl => cl.Accounts).ToList();
Console.WriteLine(">>>>>>>>>>>>>>>>ACCOUNTS<<<<<<<<<<<<<<<<<<<<<");
accounts.ForEach(acc =>
{
Console.WriteLine($" ACCOUNT : ID {acc.AccountID}, LOGIN {acc.AccountLogin}, PASSWORD {acc.AccountPassword}, ROLE {acc.Role} " +
$" CREATED : {acc.Created.ToShortDateString()}, UPDATED {acc.Updated.ToShortDateString()}");
Console.WriteLine($" ---- CLIENT : ID {acc.ClientID}, NAME {acc.Client.ClientFirstname}, SURNAME {acc.Client.ClientLastname}, ADDRESS {acc.Client.ClientAddress}" +
$" CREATED : {acc.Client.Created.ToShortDateString()}, UPDATED {acc.Client.Updated.ToShortDateString()}");
});
Console.WriteLine(">>>>>>>>>>>>>>>>CLIENTS<<<<<<<<<<<<<<<<<<<<<<<");
clients.ForEach(cl =>
{
Console.WriteLine($" CLIENT : ID {cl.ClientId}, NAME {cl.ClientFirstname}, SURNAME {cl.ClientLastname}, ADDRESS {cl.ClientAddress}" +
$" CREATED : {cl.Created.ToShortDateString()}, UPDATED {cl.Updated.ToShortDateString()}");
cl.Accounts.ToList().ForEach(acc =>
{
Console.WriteLine($" ---- ACCOUNT : ID {acc.AccountID}, LOGIN {acc.AccountLogin}, PASSWORD {acc.AccountPassword}, ROLE {acc.Role} " +
$" CREATED : {acc.Created.ToShortDateString()}, UPDATED {acc.Updated.ToShortDateString()}");
});
});
var _airportCtx = new AirportContext(dbContext);
var airports = _airportCtx.Airports.Include(ap => ap.City).ToList();
airports.ForEach(ap =>
{
Console.WriteLine($"AIRPORT : ID {ap.AirportId}, CODE {ap.AirportCode}, NAME {ap.AirportName}" +
$" CREATED : {ap.Created.ToShortDateString()}, UPDATED {ap.Updated.ToShortDateString()}");
Console.WriteLine($" ---- CITY : ID : {ap.City.CityId} - NAME : {ap.City.CityName}");
});
var _airplaneCtx = new AirplaneContext(dbContext);
var airplanes = _airplaneCtx.Airplanes.Include(apl => apl.Type).ToList();
airplanes.ForEach(apl =>
{
Console.WriteLine($"AIRPLANE : ID {apl.AirplaneId}, NUMBER {apl.AirplaneNumber} , EXISTS : {apl.IsDeleted}" +
$" CREATED : {apl.Created.ToShortDateString()}, UPDATED {apl.Updated.ToShortDateString()}");
Console.WriteLine($" ---- TYPE : ID : {apl.Type.AirplaneTypeId} - NAME : {apl.Type.AirplaneTypeName}" +
$"SITS COUNT : {apl.Type.AirplaneTypeSitsCount}, PRICE : {apl.Type.SitPriceInDollars}, BUSINESS : {apl.Type.HasBusinessClass}");
});
var _airplaneTypeCtx = new AirplaneTypeContext(dbContext);
Console.WriteLine(">>>>>>>>>>>>>>>>>>>>>>>>>TYPES <<<<<<<<<<<<<<<<<<<<<<<<<<<<< ");
var _airplaneTypes = _airplaneTypeCtx.AirplaneTypes.Include(aplt => aplt.AirplanesOfCurrentType).ToList();
_airplaneTypes.ForEach(aplt =>
{
Console.WriteLine($" TYPE : ID : {aplt.AirplaneTypeId} - NAME : {aplt.AirplaneTypeName}" +
$"SITS COUNT : {aplt.AirplaneTypeSitsCount}, PRICE : {aplt.SitPriceInDollars}, BUSINESS : {aplt.HasBusinessClass}");
aplt.AirplanesOfCurrentType.ToList().ForEach(apl =>
{
Console.WriteLine($" ---- AIRPLANE : ID {apl.AirplaneId}, NUMBER {apl.AirplaneNumber} , EXISTS : {apl.IsDeleted}" +
$" CREATED : {apl.Created.ToShortDateString()}, UPDATED {apl.Updated.ToShortDateString()}");
});
});
var _flightCtx = new FlightContext(dbContext);
var flights = _flightCtx.Flights.Include(fl => fl.Airplane).Include(fl => fl.Airports).ToList();
Console.WriteLine(" >>>>>>>>>>>>>>>>>>>>>>>>FLIGHTS<<<<<<<<<<<<<<<<<<<<");
Console.WriteLine("");
Console.WriteLine("");
foreach (var flight in flights)
{
Console.WriteLine($"FLIGHT : ID {flight.FlightId} - ARRIVE TIME {flight.ArriveTime.ToShortTimeString()} - DEPARTURE TIME {flight.DepartureTime.ToShortTimeString()} ");
Console.WriteLine("");
Console.WriteLine($" ---- AIRPLANE : ID {flight.Airplane.AirplaneId}, NUMBER {flight.Airplane.AirplaneNumber} , EXISTS : {flight.Airplane.IsDeleted}");
var arrive = flight.Airports.Where(ap => ap.IsArrive).ToArray()[0];
var departure = flight.Airports.Where(ap => !ap.IsArrive).ToArray()[0];
Console.WriteLine($"----- AIRPORTS----------");
Console.WriteLine("");
Console.WriteLine($"ARRIVE AIRPORT : ID {arrive.AirportID}, CODE {arrive.Airport.AirportCode}, NAME {arrive.Airport.AirportName}");
Console.WriteLine($" ---- CITY : ID : {arrive.Airport.City.CityID} - NAME : {arrive.Airport.City.CityName}");
Console.WriteLine("");
Console.WriteLine($"DEPARTURE AIRPORT : ID {departure.AirportID}, CODE {departure.Airport.AirportCode}, NAME {departure.Airport.AirportName}");
Console.WriteLine($" ---- CITY : ID : {departure.Airport.City.CityID} - NAME : {departure.Airport.City.CityName}");
}
var _ticketCtx = new TicketContext(dbContext);
var tickets = _ticketCtx.Tickets.Include(t => t.Client).Include(t => t.Flight).ToList();
tickets.ForEach(t =>
{
Console.WriteLine($" ID : {t.TicketID} - CLIENT NAME : {t.Client.ClientFirstname + t.Client.ClientLastname} " +
$"- DEPARTURE CITY : {t.Flight.Airports.Where(ap => !ap.IsArrive).ToArray()[0].Airport.City.CityName}" +
$"- ARRIVE CITY {t.Flight.Airports.Where(ap => ap.IsArrive).ToArray()[0].Airport.City.CityName}");
});
}
}
public static CountryContext GetCountryContext()
{
return _countryContext ?? (_countryContext = new CountryContext());
}
public CountryRepository(CountryContext context, ILogger <CountryRepository> logger)
{
_context = context ?? throw new ArgumentNullException(nameof(context));
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
}
public RegionRepository(CountryContext context)
{
_context = context;
}
public CountryRepository(CountryContext context)
{
_context = context;
}
public DbFactory()
{
CountryContext = new CountryContext("name=CountriesConnectionString");
}
public StatesController(CountryContext context)
{
_context = context;
}
public HomeController(CountryContext ctx)
{
context = ctx;
}
