public async Task <IActionResult> Edit(int id, [Bind("Id,SpecData")] Specializations specializations)
{
if (id != specializations.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(specializations);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!SpecializationsExists(specializations.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(specializations));
}
public void AddPlayer(Player player, Specializations clientSpecialization)
{
if (_players.TryAdd(player.Id, player))
{
player.CurrentCharacter = Map.AddCharacter(player.Nickname, clientSpecialization);
}
}
public Hero(HeroClass heroClass, HeroRace heroRace, string heroName)
{
Materials = new List <Material>();
Recipes = new List <Recipe>();
Artifacts = new List <Artifact>();
EquippedArtifacts = new List <Artifact>();
Quests = new List <Quest>();
Specializations = new Specializations();
ArtifactSets = new List <ArtifactSet>
{
new ArtifactSet
{
Id = 0,
Name = "Default set"
}
};
HeroClass = heroClass;
HeroRace = heroRace;
Experience = 0;
Level = 0;
Name = heroName;
ClickDamagePerLevel = 1;
AuraDamage = 0.084;
CritDamage = 2.0;
AuraAttackSpeed = AuraSpeedBase;
Id = ++User.Instance.LastHeroId;
SetClassSpecificValues();
RefreshHeroExperience();
}
public GameObjectDTO Respawn(int playerId, Specializations clientSpecialization)
{
Player p;
if (!_players.TryGetValue(playerId, out p))
{
return new GameObjectDTO();
Console.WriteLine($"Player: {playerId} could not respawn.");
}
p.CurrentCharacter = Map.AddCharacter(p.Nickname, clientSpecialization);
Body b = p.CurrentCharacter.Body;
return new GameObjectDTO()
{
Id = p.CurrentCharacter.Id,
Body = new BodyDTO
{
Position = new PointDTO
{
X = b.Position.X,
Y = b.Position.Y
},
Width = b.Width,
Height = b.Height,
Type = (int)b.Type
}
};
}
public ScheduleOperation()
{
InitializeComponent();
DataContext = this;
String[] foundRecordSpec;
String[] linesSpec = File.ReadAllLines("C:/Users/Andjela Paunovic/Desktop/projekat2/project/zdravoCorporationBackend/HCI_wpf_Andjela_Paunovic/HCI_wpf_Andjela_Paunovic/CSV/specializations.csv");
for (int i = 1; i < linesSpec.Length; i++)
{
Specialization spec = new Specialization();
foundRecordSpec = linesSpec[i].Split(',');
spec.SpecName = foundRecordSpec[1];
Specializations.Add(spec);
}
String[] foundRecordDoc;
String[] linesDoc = File.ReadAllLines("C:/Users/Andjela Paunovic/Desktop/projekat2/project/zdravoCorporationBackend/HCI_wpf_Andjela_Paunovic/HCI_wpf_Andjela_Paunovic/CSV/doctors.csv");
for (int i = 1; i < linesDoc.Length; i++)
{
//Na osnovu unete specijalizacije treba da se izlistaju odredjeni doktori
Doctor doc = new Doctor();
foundRecordDoc = linesDoc[i].Split(',');
doc.FirstName = foundRecordDoc[0] + " " + foundRecordDoc[1] + " " + foundRecordDoc[2];
Doctors.Add(doc);
}
}
public void AddSpecialization(string name)
{
if (!CharacterObject.CanAffordSpecialization)
{
return;
}
int price = CharacterObject.Options.KarmaSpecialization;
//If data file contains {4} this crashes but...
string upgradetext = //TODO WRONG
$"{LanguageManager.Instance.GetString("String_ExpenseLearnSpecialization")} {DisplayName} ({name})";
SkillSpecialization nspec = new SkillSpecialization(name, false);
ExpenseLogEntry entry = new ExpenseLogEntry();
entry.Create(price * -1, upgradetext, ExpenseType.Karma, DateTime.Now);
entry.Undo = new ExpenseUndo().CreateKarma(KarmaExpenseType.AddSpecialization, nspec.InternalId);
CharacterObject.ExpenseEntries.Add(entry);
Specializations.Add(nspec);
CharacterObject.Karma -= price;
}
public ActionResult DeleteConfirmed(int id)
{
Specializations specializations = db.Specializations.Find(id);
db.Specializations.Remove(specializations);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public List<Specializations> GetUserSpecializationList(Specializations? userSpecializations)
{
var userSpecializationList = userSpecializations.HasValue && userSpecializations != Specializations.AllSpecializations
? new List<Specializations>(userSpecializations.Value.GetFlags())
: new List<Specializations>();
return userSpecializationList;
}
protected override sealed ItemDetermination MakeDetermination(Item item, Specializations spec)
{
if (!IsAllowed(item, spec))
{
return(new ItemDetermination(spec, DisallowLevel, DisallowReason));
}
return(new ItemDetermination(spec, DeterminationLevel.Allowed, string.Empty));
}
public static CourseSpecialization Create(Course course, Specializations specialization)
{
return(new CourseSpecialization
{
CourseId = course.Id,
Course = course,
Specialization = specialization
});
}
public async Task <ActionResult> DeleteConfirmed(int id)
{
Specializations specializations = await db.Specializations.FindAsync(id);
db.Specializations.Remove(specializations);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
public async Task <IEnumerable <Doctor> > GetAllBySpecialization(Specializations specialization)
{
await using var context = ContextFactory.CreateDbContext();
return(await context.Doctors
.Where(d => d.IsActive)
.Where(d => d.Specializations
.Any(s => s.SingleSpecialization == specialization))
.ToListAsync());
}
public void AddPlayer(Player player, string clientIp, int clientUdpPort, int clientTcpPort,
Specializations clientSpecialization)
{
_players.Add(player.Id, player);
player.CurrentCharacter = Map.AddCharacter(player.Nickname, clientSpecialization);
// TODO data to character creation should be dynamic
Map.Broker.AddTarget(player.Id, clientIp, clientUdpPort, clientTcpPort);
}
public static bool IsClass(this Specializations spec, Classes playerClass)
{
if (!IsSingleSpecialization(spec))
{
throw new ArgumentOutOfRangeException(nameof(spec), "Parameter must be a single defined specialization.");
}
return((spec & playerClass.ToSpecializations()) != 0);
}
public static CourseSpecialization Create(Course course, Specializations specialization)
{
return new CourseSpecialization
{
CourseId = course.Id,
Course = course,
Specialization = specialization
};
}
public void FinishQuest()
{
_timer.Stop();
TicksCountText = "";
Specializations.UpdateSpecializationAmountAndUi(SpecializationType.Questing);
AssignRewards();
(GameAssets.Pages["QuestMenu"] as QuestMenuPage).RerollQuests();
CombatTimersHelper.StartAuraTimerOnCurrentRegion();
}
public SpecializationGroup SpecializationGroup()
{
return(new SpecializationGroup
{
Id = Id,
SqlSetId = SqlSetId,
UiDefaultText = UiDefaultText,
Specializations = Specializations.Select(s => s.Specialization())
});
}
public void Add(Program type)
{
lock (type)
{
if (Count == ProgramId.Length)
{
var newLength = ProgramId.Length + 4;
var _ProgramId = new string[newLength];
ProgramId.CopyTo(_ProgramId);
ProgramId = _ProgramId;
var _Name = new string[newLength];
Name.CopyTo(_Name);
Name = _Name;
var _Duration = new string[newLength];
Duration.CopyTo(_Duration);
Duration = _Duration;
var _Limit = new int[newLength];
Limit.CopyTo(_Limit);
Limit = _Limit;
var _DepartmentId = new string[newLength];
DepartmentId.CopyTo(_DepartmentId);
DepartmentId = _DepartmentId;
var _Specializations = new SpecializationDM[newLength];
Specializations.CopyTo(_Specializations);
Specializations = _Specializations;
var _mountedCourseDM = new MountedCourseDM[newLength];
MountedCourses.CopyTo(_mountedCourseDM);
MountedCourses = _mountedCourseDM;
}
ProgramId.Span[Count] = type.ProgramId;
Name.Span[Count] = type.Name;
Duration.Span[Count] = type.Duration;
Limit.Span[Count] = type.Limit;
DepartmentId.Span[Count] = type.DepartmentId;
Specializations.Span[Count] = new SpecializationDM(length);
if (type.Specializations?.Count > 0)
{
foreach (var t in type.Specializations)
{
Specializations.Span[Count].Add(t);
}
}
MountedCourses.Span[Count] = new MountedCourseDM(length);
if (type.MountedCourses?.Count > 0)
{
foreach (var t in type.MountedCourses)
{
MountedCourses.Span[Count].Add(t);
}
}
Count++;
}
}
public async Task <ActionResult> Edit([Bind(Include = "Id,Title")] Specializations specializations)
{
if (ModelState.IsValid)
{
db.Entry(specializations).State = EntityState.Modified;
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(specializations));
}
public string GetNameAndDescription()
{
var result = $"{(IsMain ? "**Main: **" : CurrentMembershipState.State == GuildMemberState.Left ? "**Nicht in Gilde: **" : string.Empty)}{Name}: {Class}";
if (Specializations.Any())
{
result = $"{result} {string.Join(",", Specializations.Select(s => s.GetDescription()))}";
}
return(result);
}
public async Task <IActionResult> Create([Bind("Id,SpecData")] Specializations specializations)
{
if (ModelState.IsValid)
{
_context.Add(specializations);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(specializations));
}
protected override bool IsAllowed(Item item, Specializations spec)
{
if (spec == Specializations.BearDruid)
{
return(item.Type == ItemType.Leather);
}
else
{
return(item.Type == ItemType.Plate);
}
}
public void RemoveSpecialization(Specialization specialization)
{
Specializations.Remove(specialization);
foreach (var @group in Groups)
{
if (group.Specialization == specialization)
{
group.Specialization = null;
}
}
}
private void BuyButton_Click(object sender, RoutedEventArgs e)
{
var b = sender as Button;
var recipe = b.CommandParameter as Recipe;
if (User.Instance.Gold >= recipe.Value)
{
var buyRecipeInlines = new List <Inline>
{
new Run("Are you sure you want to buy "),
new Run($"{recipe.Name}")
{
FontFamily = (FontFamily)FindResource("FontRegularDemiBold")
},
new Run(" for "),
new Run($"{recipe.Value} gold")
{
Foreground = (SolidColorBrush)FindResource("BrushGold"),
FontFamily = (FontFamily)FindResource("FontRegularDemiBold")
},
new Run("?")
};
var result = AlertBox.Show(buyRecipeInlines);
if (result == MessageBoxResult.No)
{
return;
}
(Application.Current.MainWindow as GameWindow).CreateFloatingTextUtility($"-{recipe.Value}", (SolidColorBrush)FindResource("BrushGold"), FloatingTextHelper.GoldPositionPoint);
recipe.AddItem();
User.Instance.Gold -= recipe.Value;
Specializations.UpdateSpecializationAmountAndUi(SpecializationType.Trading);
UpdateShop();
}
else
{
var notEnoughGoldInlines = new List <Inline>
{
new Run("You do not have enough gold to buy this item.\nIt costs "),
new Run($"{recipe.Value} gold")
{
Foreground = (SolidColorBrush)FindResource("BrushGold"),
FontFamily = (FontFamily)FindResource("FontRegularDemiBold")
},
new Run(".\nYou can get more gold by completing quests and selling loot from monsters and bosses.")
};
AlertBox.Show(notEnoughGoldInlines, MessageBoxButton.OK);
}
}
public ActionResult Edit([Bind(Include = "SpecializationId,SpecializationName,IsDelete,IsActive,LastUpdate,IndustryId")] Specializations specializations)
{
specializations.LastUpdate = DateTime.Now;
if (ModelState.IsValid)
{
db.Entry(specializations).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.IndustryId = new SelectList(db.Industries, "IndustryId", "IndustryName", specializations.IndustryId);
return(View(specializations));
}
public static IEnumerable <Specializations> Split(this Specializations specs)
{
for (int i = 1; i <= 1 << 27; i <<= 1)
{
Specializations spec = (Specializations)i;
if ((specs & spec) == spec)
{
yield return(spec);
}
}
}
TreeNode CreateTreeNodeCore(bool displayUnsetFields)
{
var configuration = new TreeNodeObjectExplorerConfiguration {
ShowUnsetFields = displayUnsetFields
};
using var stream = item.OpenStream();
var rawEMsg = PeekUInt(stream);
var node = BuildInfoNode(rawEMsg);
node.Expand();
var header = ReadHeader(rawEMsg, stream);
node.Nodes.Add(new TreeNodeObjectExplorer("Header", header, configuration).TreeNode);
var body = ReadBody(rawEMsg, stream, header);
var bodyNode = new TreeNodeObjectExplorer("Body", body, configuration).TreeNode;
node.Nodes.Add(bodyNode);
var payload = ReadPayload(stream);
if (payload != null && payload.Length > 0)
{
node.Nodes.Add(new TreeNodeObjectExplorer("Payload", payload, configuration).TreeNode);
}
if (Specializations != null)
{
var objectsToSpecialize = new[] { body };
while (objectsToSpecialize.Any())
{
var specializations = objectsToSpecialize.SelectMany(o => Specializations.SelectMany(x => x.ReadExtraObjects(o)));
if (!specializations.Any())
{
break;
}
bodyNode.Collapse(ignoreChildren: true);
var extraNodes = specializations.Select(x => new TreeNodeObjectExplorer(x.Key, x.Value, configuration).TreeNode).ToArray();
node.Nodes.AddRange(extraNodes);
// Let the specializers examine any new message objects.
objectsToSpecialize = specializations.Select(x => x.Value).ToArray();
}
}
return(node);
}
public void AddSpecialization(string name)
{
int price = IsKnowledgeSkill ? CharacterObject.Options.KarmaKnowledgeSpecialization : CharacterObject.Options.KarmaSpecialization;
int intExtraSpecCost = 0;
int intTotalBaseRating = TotalBaseRating;
decimal decSpecCostMultiplier = 1.0m;
foreach (Improvement objLoopImprovement in CharacterObject.Improvements)
{
if (objLoopImprovement.Minimum <= intTotalBaseRating &&
(string.IsNullOrEmpty(objLoopImprovement.Condition) || (objLoopImprovement.Condition == "career") == CharacterObject.Created || (objLoopImprovement.Condition == "create") != CharacterObject.Created) && objLoopImprovement.Enabled)
{
if (objLoopImprovement.ImprovedName == SkillCategory)
{
if (objLoopImprovement.ImproveType == Improvement.ImprovementType.SkillCategorySpecializationKarmaCost)
{
intExtraSpecCost += objLoopImprovement.Value;
}
else if (objLoopImprovement.ImproveType == Improvement.ImprovementType.SkillCategorySpecializationKarmaCostMultiplier)
{
decSpecCostMultiplier *= objLoopImprovement.Value / 100.0m;
}
}
}
}
if (decSpecCostMultiplier != 1.0m)
{
price = decimal.ToInt32(decimal.Ceiling(price * decSpecCostMultiplier));
}
price += intExtraSpecCost; //Spec
if (price > CharacterObject.Karma)
{
return;
}
//If data file contains {4} this crashes but...
string upgradetext = //TODO WRONG
$"{LanguageManager.GetString("String_ExpenseLearnSpecialization", GlobalOptions.Language)} {DisplayNameMethod(GlobalOptions.Language)} ({name})";
SkillSpecialization nspec = new SkillSpecialization(name, false, this);
ExpenseLogEntry entry = new ExpenseLogEntry(CharacterObject);
entry.Create(price * -1, upgradetext, ExpenseType.Karma, DateTime.Now);
entry.Undo = new ExpenseUndo().CreateKarma(KarmaExpenseType.AddSpecialization, nspec.InternalId);
CharacterObject.ExpenseEntries.Add(entry);
Specializations.Add(nspec);
CharacterObject.Karma -= price;
}
public async Task <ActionResult> Create([Bind(Include = "Id,Title")] Specializations specializations)
{
if (ModelState.IsValid)
{
db.Specializations.Add(specializations);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(specializations));
}
// GET: Admin/Specialization_Ad/Details/5
public ActionResult Details(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Specializations specializations = db.Specializations.Find(id);
if (specializations == null)
{
return(HttpNotFound());
}
return(View(specializations));
}
public static IEnumerable <Specializations> GetFlags(this Specializations specializations)
{
var bitCount = GetEnumUnderlineTypeBitCount(specializations);
for (var i = 0; i < bitCount; i++)
{
var number = 1 << i;
var numberAsSpecializations = (Specializations)number;
if ((specializations & numberAsSpecializations) == numberAsSpecializations)
{
yield return(numberAsSpecializations);
}
}
}
public IQueryable<Course> GetCoursesQueryForSpecializations(Specializations? specializations)
{
ThrowIfDisposed();
var userSpecializationList = GetUserSpecializationList(specializations);
var coursesQuery = from course in _context.Courses
where (!userSpecializationList.Any() ||
course.CourseSpecializations.Any(x => userSpecializationList.Contains(x.Specialization)))
&& !course.IsDeleted
select course;
return coursesQuery;
}
// GET: Specializations/Delete/5
public async Task <ActionResult> Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Specializations specializations = await db.Specializations.FindAsync(id);
if (specializations == null)
{
return(HttpNotFound());
}
return(View(specializations));
}
private void HandleCrafting <T>(Recipe recipe)
{
if (!MeetsCraftingRequirement(recipe))
{
var listOfInlines = new List <Inline>
{
new Run("You dont meet Craftsman specialization requirements to craft "),
new Run($"{recipe.Rarity.ToString()}")
{
Foreground = ColorsHelper.GetRarityColor(recipe.Rarity),
FontFamily = (FontFamily)FindResource("FontRegularDemiBold")
},
new Run(" artifacts.\nCraft more common items in order to master it.")
};
AlertBox.Show(listOfInlines, MessageBoxButton.OK);
return;
}
bool enoughIngredients;
if (typeof(T) == typeof(Material))
{
enoughIngredients = CheckAndRemoveMaterials(recipe);
}
else
{
enoughIngredients = CheckAndRemoveIngots(recipe);
}
if (enoughIngredients)
{
recipe.Artifact.CreateMythicTag();
recipe.Artifact.AddItem();
recipe.RemoveItem();
Specializations.UpdateSpecializationAmountAndUi(SpecializationType.Crafting);
UpdateBlacksmithItems();
// If hero has all other artifacts, grant Transcendence.
if (User.Instance.CurrentHero.Artifacts.Select(x => x.Name).Distinct().Count() == GameAssets.Artifacts.Count - 1)
{
var transcendence = GameAssets.Artifacts.FirstOrDefault(x => x.Name == "Transcendence");
transcendence?.AddItem();
}
}
}
public static string GetClassName(this Specializations spec)
{
return(spec switch
{
Specializations.BalanceDruid or Specializations.BearDruid or Specializations.CatDruid or Specializations.RestoDruid => "Druid",
Specializations.BeastMasterHunter or Specializations.MarksmanHunter or Specializations.SurvivalHunter => "Hunter",
Specializations.ArcaneMage or Specializations.FireMage or Specializations.FrostMage => "Mage",
Specializations.HolyPaladin or Specializations.ProtPaladin or Specializations.RetPaladin => "Paladin",
Specializations.DiscPriest or Specializations.ShadowPriest or Specializations.HolyPriest => "Priest",
Specializations.AssassinationRogue or Specializations.CombatRogue or Specializations.SubtletyRogue => "Rogue",
Specializations.EleShaman or Specializations.EnhanceShaman or Specializations.RestoShaman => "Shaman",
Specializations.AfflictionWarlock or Specializations.DemoWarlock or Specializations.DestroWarlock => "Warlock",
Specializations.ProtWarrior or Specializations.ArmsWarrior or Specializations.FuryWarrior => "Warrior",
_ => throw new ArgumentOutOfRangeException(nameof(spec))
});
protected override bool IsAllowed(Item item, Specializations spec)
{
var equippableSpecs = item.Type switch
{
ItemType.Axe => SpecializationGroups.Paladin | SpecializationGroups.Shaman | SpecializationGroups.Warrior | SpecializationGroups.Hunter,
ItemType.Mace => SpecializationGroups.Druid | SpecializationGroups.Paladin | SpecializationGroups.Shaman | SpecializationGroups.Warrior,
ItemType.Sword => SpecializationGroups.Paladin | SpecializationGroups.Warrior | SpecializationGroups.Hunter,
ItemType.Polearm => SpecializationGroups.Paladin | SpecializationGroups.Warrior | SpecializationGroups.Hunter,
ItemType.Stave => SpecializationGroups.All & ~(SpecializationGroups.Paladin | SpecializationGroups.Rogue),
_ => throw new ArgumentException("Item is not a two-handed weapon.", nameof(item))
};
return((spec & equippableSpecs) == spec);
}
}
public async Task<CatalogStatistic> GetCatalogStatisticAsync(Specializations? specializations)
{
var coursesQuery = GetCoursesQueryForSpecializations(specializations);
var statistic = await (from needForBatch in coursesQuery
select new CatalogStatistic
{
TrainingProviderCount =
CatalogContext.TrainingProviders.Count(
tp => coursesQuery.Any(q => q.TrainingProviderId == tp.Id) && !tp.IsDeleted),
CategoryCount =
CatalogContext.Categories.Count(cat => coursesQuery.Any(q => q.CategoryId == cat.Id) && !cat.IsDeleted),
CourseCount = coursesQuery.Count(),
AuthorCount = CatalogContext.CourseAuthors
.Where(ca => coursesQuery.Any(q => q.Id == ca.CourseId) && !ca.IsDeleted)
.GroupBy(ca => ca.AuthorId).Count()
}).FirstAsync();
return statistic;
}
public async Task<List<CatalogEntryViewModel>> GetTrainingProviderCatalogAsync(Specializations? specializations)
{
ThrowIfDisposed();
var coursesQuery = GetCoursesQueryForSpecializations(specializations);
var catalog = await CatalogContext.TrainingProviders
.Where(x => !x.IsDeleted)
.Select(x => new CatalogEntryViewModel
{
Name = x.Name,
SiteUrl = x.SiteUrl,
LogoFileName = x.LogoFileName,
CategoryCount = x.Categories
.Count(category => coursesQuery.Any(q => q.CategoryId == category.Id) && !category.IsDeleted),
CourseCount = x.Courses
.Count(course => coursesQuery.Any(q => q.Id == course.Id)),
AuthorsCount = CatalogContext.CourseAuthors
.Where(ca => x.Id == ca.TrainingProviderId && !ca.IsDeleted && coursesQuery.Any(q => q.Id == ca.CourseId))
.GroupBy(ca => ca.AuthorId).Count()
}).ToListAsync();
return catalog;
}
public async Task<AuthorInfoViewModel> GetAuthorInfoAsync(string authorUrlName, string trainingProviderName, Specializations? specializations)
{
var authorIdentity = await CatalogContext.TrainingProviderAuthors
.Where(x => x.UrlName == authorUrlName &&
x.TrainingProvider.Name == trainingProviderName &&
!x.IsDeleted)
.Select(x => new { x.AuthorId, x.TrainingProviderId })
.SingleOrDefaultAsync();
if (authorIdentity == null)
{
return null;
}
var coursesQuery = GetCoursesQueryForSpecializations(specializations);
var authorInfoViewModel = await CatalogContext.TrainingProviderAuthors
.Where(x => x.AuthorId == authorIdentity.AuthorId &&
x.TrainingProviderId == authorIdentity.TrainingProviderId &&
!x.IsDeleted)
.Select(x => new AuthorInfoViewModel
{
TrainingProvider = new TrainingProviderViewModel
{
Name = x.TrainingProvider.Name,
SiteUrl = x.TrainingProvider.SiteUrl,
LogoFileName = x.TrainingProvider.LogoFileName
},
FirstName = x.Author.FirstName,
LastName = x.Author.LastName,
Bio = x.Author.Bio,
Social = x.Author.Social,
Badge = x.Author.Badge,
Avatar = x.Author.Avatar,
SiteUrl = x.SiteUrl,
UrlName = x.UrlName,
Participations = x.Author.AuthorTrainingProviders
.Where(tpa => tpa.TrainingProviderId != authorIdentity.TrainingProviderId &&
coursesQuery.Any(q => q.TrainingProviderId == tpa.TrainingProviderId))
.Select(tpa => new ParticipationViewModel
{
TrainingProvider = new TrainingProviderViewModel
{
Name = tpa.TrainingProvider.Name,
SiteUrl = tpa.TrainingProvider.SiteUrl,
LogoFileName = tpa.TrainingProvider.LogoFileName
},
UrlName = tpa.UrlName
})
}).SingleOrDefaultAsync();
return authorInfoViewModel;
}
public SpecializationsListViewModel(Specializations selectedSpecializations)
{
SelectedSpecializationTitles = selectedSpecializations.GetFlags().Select(x => x.ToString());
}
public async Task<CourseCatalogViewModel> GetCoursesForCategoryAsync(string trainingProviderName, string categoryUrlName,
string userId, Specializations? specializations)
{
var courseQuery = GetCoursesQueryForSpecializations(specializations);
courseQuery = courseQuery.Where(x => x.Category.UrlName == categoryUrlName &&
!x.Category.IsDeleted &&
x.TrainingProvider.Name == trainingProviderName);
var courses = await ProjectToCourseCatalogEntry(courseQuery, userId).ToListAsync();
if (courses.Any())
{
var courseList = new CourseCatalogViewModel
{
CourseListFor = CourseListFor.Category,
Courses = courses
};
return courseList;
}
return null;
}
public static Character CreateCharacter(Specializations specialization)
{
return _specializations[specialization]();
}
public async Task<InfoViewModel> GetTrainingProviderInfoAsync(string trainingProviderName, Specializations? specializations)
{
var coursesQuery = GetCoursesQueryForSpecializations(specializations);
var trainingProviderInfo = await CatalogContext.TrainingProviders
.Where(tp => tp.Name == trainingProviderName && !tp.IsDeleted)
.Select(tp => new InfoViewModel
{
Name = tp.Name,
Description = tp.Description,
SiteUrl = tp.SiteUrl,
LogoFileName = tp.LogoFileName,
CategoryCount = tp.Categories
.Count(cat => coursesQuery.Any(cq => cq.CategoryId == cat.Id) && !cat.IsDeleted),
CourseCount = tp.Courses
.Count(course => coursesQuery.Any(cq => cq.Id == course.Id)),
AuthorsCount = UpdateContext.CourseAuthors
.Where(
ca =>
tp.Id == ca.TrainingProviderId && !ca.IsDeleted &&
coursesQuery.Any(cq => cq.Id == ca.CourseId))
.GroupBy(ca => ca.AuthorId).Count(),
UpdateDates = UpdateContext.UpdateEvents
.Where(ue => ue.TrainingProviderId == tp.Id &&
(ue.UpdateResult == UpdateResult.Success ||
ue.UpdateResult == UpdateResult.Resolved) &&
ue.CoursesUpdates.Any(
c =>
c.OperationType == OperationType.Add &&
coursesQuery.Any(cq => cq.Id == c.CourseId)))
.Select(ue => DbFunctions.TruncateTime(ue.StartedOn).Value)
.Distinct()
.OrderBy(ue => ue)
.ToList()
}).SingleOrDefaultAsync();
return trainingProviderInfo;
}
public async Task<IEnumerable<CourseLinkViewModel>> GetTop5MonthPopularCoursesAsync(Specializations? specializations)
{
var courseQuery = GetCoursesQueryForSpecializations(specializations);
var utcDateNow = DateTime.UtcNow.Date;
var top5MonthPopularCourses = await courseQuery
.Where(x => DbFunctions.DiffDays(x.ReleaseDate, utcDateNow) <= 30)
.OrderByDescending(x => x.Rating.Raters)
.Take(5)
.Select(x => new CourseLinkViewModel
{
CourseTitle = x.Title,
CourseUrlName = x.UrlName,
TrainingProviderName = x.TrainingProvider.Name,
CategoryUrlName = x.Category.UrlName
}).ToListAsync();
return top5MonthPopularCourses;
}
public async Task<IEnumerable<CourseLinkViewModel>> GetTop5NewCoursesAsync(Specializations? specializations)
{
var courseQuery = GetCoursesQueryForSpecializations(specializations);
var top5NewCourses = await courseQuery
.OrderByDescending(x => x.ReleaseDate)
.Take(5)
.Select(x => new CourseLinkViewModel
{
CourseTitle = x.Title,
CourseUrlName = x.UrlName,
TrainingProviderName = x.TrainingProvider.Name,
CategoryUrlName = x.Category.UrlName
}).ToListAsync();
return top5NewCourses;
}
public async Task<AuthorCatalogViewModel> GetAuthorsCatalogAsync( string trainingProviderName, Specializations? specializations)
{
var coursesQuery = GetCoursesQueryForSpecializations(specializations);
var authorsQuery = trainingProviderName != null
? CatalogContext.TrainingProviderAuthors
.Where(x => x.TrainingProvider.Name == trainingProviderName &&
x.AuthorCourses.Any(ca => coursesQuery.Any(q => q.Id == ca.CourseId)) && !x.IsDeleted)
: CatalogContext.TrainingProviderAuthors
.Where(x => x.AuthorCourses.Any(ca => coursesQuery.Any(q => q.Id == ca.CourseId)) && !x.IsDeleted);
var catalogModel = await authorsQuery
.Select(x => new CatalogEntryViewModel
{
TrainingProvider = new TrainingProviderViewModel
{
Name = x.TrainingProvider.Name,
LogoFileName = x.TrainingProvider.LogoFileName,
SiteUrl = x.TrainingProvider.SiteUrl
},
Author = new TrainingProviderAuthorViewModel
{
FullName = x.FullName,
UrlName = x.UrlName
}
}).ToListAsync();
if (!catalogModel.Any())
{
return null;
}
var catalog = catalogModel
.GroupBy(x => char.ToUpperInvariant(x.Author.LastName[0]), x => x)
.OrderBy(group => group.Key)
.AsEnumerable();
var tokenCatalog = GetTokenCatalog();
var authorCatalogViewModel = new AuthorCatalogViewModel
{
Navigation = new NavigationViewModel
{
SelectedToken = trainingProviderName != null
? trainingProviderName.ToTitleCaseInvariant()
: NavigationViewModel.ALLToken,
TokenCatalog = tokenCatalog
},
Catalog = catalog
};
return authorCatalogViewModel;
}
public Character AddCharacter(string nickname, Specializations specialization)
{
Character c = CharacterFactory.CreateCharacter(specialization);
if (GameObjects.TryAdd(c.Id, c))
{
c.Register(Observation.KILLING, this, ExterminationNotification);
c.Register(Observation.EXTERMINATION, this, ExterminationNotification);
Body b = c.Body;
GameObjectDAO data = new GameObjectDAO
{
X = b.Position.X,
Y = b.Position.Y,
Width = b.Width,
Height = b.Height,
Id = c.Id,
Specialization = (int)c.Specialization
};
Broker.WriteCreateCharacter(nickname, data);
}
return c;
}
public async Task<CourseCatalogSearchResult> GetCourseCatalogSearchResultAsync(CourseCatalogSearchRequest request, string userId, Specializations? specializations)
{
var courseQuery = GetCoursesQueryForSpecializations(specializations);
if (!string.IsNullOrWhiteSpace(request.trainingProviderName) &&
request.trainingProviderName != NavigationViewModel.ALLToken)
{
courseQuery = courseQuery
.Where(x => x.TrainingProvider.Name == request.trainingProviderName);
}
var recordsTotal = await courseQuery.CountAsync();
var recordsFiltered = recordsTotal;
if (!string.IsNullOrWhiteSpace(request.searchTerm))
{
courseQuery = courseQuery
.Where(x => x.Title.Contains(request.searchTerm));
recordsFiltered = await courseQuery.CountAsync();
}
var catalog = await courseQuery
.SortCourses(request.order)
.Skip(request.start)
.Take(request.length)
.Select(x => new CourseCatalogEntryViewModel
{
TrainingProvider = new TrainingProviderViewModel
{
Name = x.TrainingProvider.Name,
LogoFileName = x.TrainingProvider.LogoFileName,
SiteUrl = x.TrainingProvider.SiteUrl
},
Category = new CategoryViewModel
{
Title = x.Category.Title,
UrlName = x.Category.UrlName,
LogoFileName = x.Category.LogoFileName
},
Course = new CourseViewModel
{
Id = x.Id,
Title = x.Title,
SiteUrl = x.SiteUrl,
UrlName = x.UrlName,
HasClosedCaptions = x.HasClosedCaptions,
Level = x.Level,
Rating = x.Rating,
Duration = x.Duration,
ReleaseDate = x.ReleaseDate,
LearningState = x.Subscriptions
.Where(s => s.UserId == userId)
.Select(s => s.State)
.FirstOrDefault(),
Authors = x.CourseAuthors
.Where(a => (!a.IsDeleted))
.Select(a => new CourseAuthorViewModel
{
FullName = a.TrainingProviderAuthor.FullName,
UrlName = a.TrainingProviderAuthor.UrlName,
IsCoAuthor = a.IsAuthorCoAuthor
}).ToList()
}
}).ToListAsync();
foreach (var entry in catalog)
{
entry.Category.TrainingProvider = entry.TrainingProvider;
}
var searchResult = new CourseCatalogSearchResult
{
draw = request.draw,
recordsTotal = recordsTotal,
recordsFiltered = recordsFiltered,
catalog = catalog
};
return searchResult;
}
public async Task<CatalogViewModel> GetCategoriesCatalogAsync(Specializations? specializations, string trainingProviderName)
{
var coursesQuery = GetCoursesQueryForSpecializations(specializations);
var categoriesQuery = string.IsNullOrWhiteSpace(trainingProviderName)
? CatalogContext.Categories
.Where(x => coursesQuery.Any(q => q.CategoryId == x.Id) && !x.IsDeleted)
: CatalogContext.Categories
.Where(x => x.TrainingProvider.Name == trainingProviderName &&
coursesQuery.Any(q => q.CategoryId == x.Id) && !x.IsDeleted);
var catalog = await categoriesQuery
.Select(x => new CatalogEntryViewModel
{
TrainingProvider = new TrainingProviderViewModel
{
Name = x.TrainingProvider.Name,
LogoFileName = x.TrainingProvider.LogoFileName,
SiteUrl = x.TrainingProvider.SiteUrl
},
Title = x.Title,
UrlName = x.UrlName,
LogoFileName = x.LogoFileName,
CourseCount = coursesQuery.Count(q => q.CategoryId == x.Id),
LastCourseDate = coursesQuery
.Where(q => q.CategoryId == x.Id)
.OrderByDescending(d => d.ReleaseDate)
.FirstOrDefault().ReleaseDate
})
.OrderBy(x => x.Title)
.ToListAsync();
if (!catalog.Any()) return null;
var tokenCatalog = GetTokenCatalog();
var categoryCatalogViewModel = new CatalogViewModel
{
Navigation = new NavigationViewModel
{
SelectedToken = string.IsNullOrWhiteSpace(trainingProviderName)
? NavigationViewModel.ALLToken
: trainingProviderName.ToTitleCaseInvariant(),
TokenCatalog = tokenCatalog
},
Categories = catalog
};
return categoryCatalogViewModel;
}
public async Task<CourseCatalogViewModel> GetCoursesForAuthorAsync(string authorUrlName, string trainingProviderName, string userId,
Specializations? specializations)
{
var authorIdentity = await CatalogContext.TrainingProviderAuthors
.Where(x => x.UrlName == authorUrlName &&
x.TrainingProvider.Name == trainingProviderName &&
!x.IsDeleted)
.Select(x => new { x.AuthorId, x.TrainingProviderId })
.SingleOrDefaultAsync();
if (authorIdentity == null)
{
return null;
}
var courseQuery = GetCoursesQueryForSpecializations(specializations);
courseQuery = courseQuery.Where(x => x.CourseAuthors.Any(ca => ca.AuthorId == authorIdentity.AuthorId) &&
x.TrainingProviderId == authorIdentity.TrainingProviderId);
var courses = await ProjectToCourseCatalogEntry(courseQuery, userId).ToListAsync();
if (courses.Any())
{
var courseList = new CourseCatalogViewModel
{
CourseListFor = CourseListFor.Author,
Courses = courses
};
return courseList;
}
return null;
}
public async Task<CourseCatalogViewModel> GetAddedCoursesForDateAsync(DateTime addDate, string trainingProviderName, string userId,
Specializations? specializations)
{
var userSpecializationList = GetUserSpecializationList(specializations);
var courseQuery = UpdateContext.UpdateEvents
.Where(x => DbFunctions.TruncateTime(x.StartedOn) == DbFunctions.TruncateTime(addDate) &&
x.TrainingProvider.Name == trainingProviderName &&
x.CoursesUpdates.Any(cu => cu.OperationType == OperationType.Add))
.SelectMany(x => x.CoursesUpdates)
.Where(x => x.OperationType == OperationType.Add)
.Select(x => x.Course)
.Where(x => !x.IsDeleted &&
(!userSpecializationList.Any() ||
x.CourseSpecializations.Any(cs => userSpecializationList.Contains(cs.Specialization))));
var courses = await ProjectToCourseCatalogEntry(courseQuery, userId).ToListAsync();
if (courses.Any())
{
var courseList = new CourseCatalogViewModel
{
CourseListFor = CourseListFor.Author,
Courses = courses
};
return courseList;
}
return null;
}
