public ActionResult Edit([Bind(Include = "GroupId,GroupName,CityIds")] CityGroup cityGroup, FormCollection fc)
{
if (ModelState.IsValid)
{
var selectedStateId = 0;
Int32.TryParse(fc["StateId"].ToString(), out selectedStateId);
var allCitysForGivenState = db.Citys.Where(c => c.StateId == selectedStateId);
var selectedCityIds = new StringBuilder();
if (!string.IsNullOrEmpty(cityGroup.CityIds))
{
var oldCityIds = cityGroup.CityIds.Split(',');
foreach (var cityId in oldCityIds)
{
Int32.TryParse(cityId, out int id);
if (!allCitysForGivenState.Any(c => c.Id == id))
{
selectedCityIds.Append(cityId + ",");
}
}
}
cityGroup.CityIds = (selectedCityIds.ToString() + fc["SelectedCityIds"]).Trim(',');
if (cityGroup.GroupId > 0)
{
db.Entry(cityGroup).State = EntityState.Modified;
}
else
{
db.CityGroups.Add(cityGroup);
}
var x = db.SaveChanges();
return(RedirectToAction("Edit", "CityGroups", new { id = cityGroup.GroupId }));
}
return(View(cityGroup));
}
public int CalculateMaxConnections(int maxCities, int[][] args)
{
CityGroup[] cityAssigment = new CityGroup[maxCities + 1];
var allGroups = new List <CityGroup>();
int groupId = 1;
for (int ci = 0; ci < args.Length; ++ci)
{
var cityA = args[ci][0];
var cityB = args[ci][1];
//no groups assigned
if (cityAssigment[cityA] == null && cityAssigment[cityB] == null)
{
var cityGroup = new CityGroup(groupId++);
cityGroup.AddCity(cityA);
if (cityA != cityB)
{
cityGroup.AddCity(cityB);
}
cityAssigment[cityA] = cityAssigment[cityB] = cityGroup;
allGroups.Add(cityGroup);
continue;
}
//A not assigned, B assigned
if (cityAssigment[cityA] == null && cityAssigment[cityB] != null)
{
cityAssigment[cityB].AddCity(cityA);
cityAssigment[cityA] = cityAssigment[cityB];
continue;
}
//A assigned, B not assigned
if (cityAssigment[cityA] != null && cityAssigment[cityB] == null)
{
cityAssigment[cityA].AddCity(cityB);
cityAssigment[cityB] = cityAssigment[cityA];
continue;
}
//same assigment
if (cityAssigment[cityA] == cityAssigment[cityB])
{
continue;
}
//re-assign all to parent group A
cityAssigment[cityA].ConvertToSubGroup(cityAssigment[cityB]);
}
return(allGroups.Max(g => g.Count));
}
public ActionResult DeleteConfirmed(int id)
{
CityGroup cityGroup = db.CityGroups.Find(id);
db.CityGroups.Remove(cityGroup);
db.SaveChanges();
return(RedirectToAction("Index"));
}
// Constructor
public City(string name, CityGroup group)
{
_name = name;
_group = group;
_canBeOutbroken = true;
_infectionLevel = 0;
_connectedCities = new List <City>();
_hasBase = false;
_observers = new List <IObserver <City> >();
}
// return the disease given the type
public Disease GetDisease(CityGroup type)
{
foreach (Disease disease in _diseases)
{
if (disease.type == type)
{
return(disease);
}
}
return(null);
}
public ActionResult Create([Bind(Include = "GroupId,GroupName,CityIds")] CityGroup cityGroup)
{
if (ModelState.IsValid)
{
db.CityGroups.Add(cityGroup);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(cityGroup));
}
// GET: Admin/CityGroups/Delete/5
public ActionResult Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
CityGroup cityGroup = db.CityGroups.Find(id);
if (cityGroup == null)
{
return(HttpNotFound());
}
return(View(cityGroup));
}
public void LinqQuery08()
{
var customers = new LinqSamples().GetCustomerList();
var result =
from c in customers
from order in c.Orders
group new { c.CustomerID, order } by c.City into CityGroup
select new
{
City = CityGroup.Key,
AverageOrderPrice = CityGroup.Average(cg => cg.order.Total),
AverageOrdersCountCustomers = (double)CityGroup.Count() / CityGroup.Select(cg => cg.CustomerID).Distinct().Count()
};
ObjectDumper.Write(result, 5);
}
public void ConvertToSubGroup(CityGroup subGroup)
{
if (TopLevel == subGroup || TopLevel == subGroup.TopLevel)
{
return;
}
//set subgroup parent
TopLevel.Count += subGroup.TopLevel.Count;
subGroup.TopLevel.Count = 0;
subGroup.TopLevel.TopLevel = TopLevel;
//set subgroup
TopLevel.Count += subGroup.Count;
subGroup.Count = 0;
subGroup.TopLevel = TopLevel;
}
// remove 4 of a colour of card from the hand
public List <PlayerCard> removeFourCardsToCureDisease(CityGroup cardColour)
{
int removedCount = 0;
List <PlayerCard> returnList = new List <PlayerCard>();
foreach (PlayerCard card in cardsInHand)
{
if (card.group == cardColour)
{
cardsInHand.Remove(card);
returnList.Add(card);
removedCount++;
if (removedCount >= 4)
{
return(returnList);
}
}
}
return(returnList);
}
/// <summary>
/// Get Addresses, grouped by city
/// </summary>
public List <CityGroup> GetCityGroups()
{
var cityGroups = new List <CityGroup>();
var addresses = GetAddresses();
// Group by city. Take into account the region and country as well for the internal key, delimited by a caret.
// The comparer will ignore the case, and extra characters.
var cities = addresses.GroupBy(x => $"{x.City}^{x.Region}^{x.Country}", new AddressComparer());
foreach (var city in cities)
{
var cityGroup = new CityGroup
{
City = city.FirstOrDefault().City,
Region = city.FirstOrDefault().Region,
Country = city.FirstOrDefault().Country,
Addresses = new List <Address>()
};
foreach (var address in city)
{
cityGroup.Addresses.Add(new Address
{
Id = address.Id,
FirstName = address.FirstName,
LastName = address.LastName,
StreetAddress = address.StreetAddress
});
}
cityGroup.Addresses = cityGroup.Addresses.OrderBy(x => x.LastName)
.ThenBy(x => x.FirstName)
.ThenBy(x => x.StreetAddress)
.ToList();
cityGroups.Add(cityGroup);
}
return(cityGroups.OrderBy(x => x.City)
.ThenBy(x => x.Region)
.ThenBy(x => x.Country)
.ToList());
}
public Disease(CityGroup type)
{
_type = type;
}
// Constructor
public Card(string city, CityGroup group)
{
_city = city;
_isFaceUp = false;
_group = group;
}
// Constructor
public PlayerCard(string city, CityGroup group) : base(city, group)
{
loadCardImages();
}
// Constructor
public InfectionCard(string city, CityGroup group) : base(city, group)
{
loadCardImages();
}
public CityGroup(int groupId)
{
GroupId = groupId;
TopLevel = this;
Count = 0;
}
