public void CanPersistASkill()
{
//Arrange
var context = GetSqlLiteContext();
var cvRepository = new CvRepository(context);
var skillRepository = new SkillRepository(context);
var cv = new Cv()
{
Name = Constants.CvName, TagLine = Constants.CvTagLine, Blurb = Constants.CvBlurb
};
cvRepository.Add(cv);
var cvId = cvRepository.Get()[0].Id;
//Act
var skill = new Skill()
{
Name = "Continuous Delivery", Blurb = "Awesome at CI and CD"
};
skillRepository.AddToCv(skill, cvId);
//Assert
var result = skillRepository.GetForCv(cvId)[0];
Assert.AreEqual(skill.Name, result.Name);
Assert.AreEqual(skill.Blurb, result.Blurb);
Assert.AreEqual(cvId, result.Cv.Id);
}
/// <summary>
/// The constructor of the Resume business logic layer.
/// </summary>
public ResumeBLL(
IConfiguration configuration,
ILogger <DocumentBLL> logger,
IHttpContextAccessor httpContextAccessor,
UserManager <User> userManager,
ResumeRepository resumeRepository,
ResumeStateRepository resumeStateRepository,
ResumeSkillRepository resumeSkillRepository,
DocumentResumeRepository documentResumeRepository,
DocumentRepository documentRepository,
SkillRepository skillRepository
)
{
this.configuration = configuration;
this.logger = logger;
this.httpContextAccessor = httpContextAccessor;
this.userManager = userManager;
this.resumeRepository = resumeRepository;
this.resumeStateRepository = resumeStateRepository;
this.resumeSkillRepository = resumeSkillRepository;
this.documentResumeRepository = documentResumeRepository;
this.documentRepository = documentRepository;
this.skillRepository = skillRepository;
}
public GeekHunterUnitOfWork(DbContext context)
{
this._Context = context;
this._SkillRepository = new SkillRepository(context);
this._CandidateRepository = new CandidateRepository(context);
this._SkillCandidateRepository = new CandidateSkillRepository(context);
}
public void CanDeleteSkill()
{
//Arrange
var context = GetSqlLiteContext();
var cvRepository = new CvRepository(context);
var skillRepository = new SkillRepository(context);
var cv = new Cv()
{
Name = Constants.CvName, TagLine = Constants.CvTagLine, Blurb = Constants.CvBlurb
};
cvRepository.Add(cv);
var cvId = cvRepository.Get()[0].Id;
var skill = new Skill()
{
Name = "Continuous Delivery", Blurb = "Awesome at CI and CD"
};
skillRepository.AddToCv(skill, cvId);
var skillId = skillRepository.GetForCv(cvId)[0].Id;
//Act
skillRepository.Delete(skillId);
//Assert
Assert.AreEqual(0, skillRepository.GetForCv(cvId).Count);
}
public void ProcessContent(IContentPersister persister)
{
using (var db = new GameDatabaseContext())
{
var repo = new SkillRepository(db);
var skills = repo.GetAll();
foreach (var skill in skills)
{
// Save out properties we want to a new object and then persist
dynamic persistable = new ExpandoObject();
Console.WriteLine("Processing skill with ID {0}", skill.Id);
persistable.id = skill.Id;
persistable.name = skill.Name;
persistable.castTime = skill.CastTime;
persistable.cooldownTime = skill.CooldownTime;
persistable.description = skill.Description;
persistable.damage = skill.Damage;
persistable.type = skill.SkillType;
persistable.iconId = skill.IconId;
persister.Persist(persistable, "\\skills\\{0}.json".FormatWith(skill.Id));
}
}
}
public RepositoryTest()
{
_context = new EmployeeSkillsDBContext();
_skillRepository = new SkillRepository(_context);
_EmployeeSkillsRepository = new EmployeeSkillsRepository(_context);
SetupLogging();
}
public async void CreateAsync_GivenTwoValidSkills_ReturnsTwoNewSkillIDs()
{
var skill1 = new SkillCreateDTO
{
Name = "Cooking"
};
var skill2 = new SkillCreateDTO
{
Name = "Dancing"
};
using (var repository = new SkillRepository(context))
{
var id1 = await repository.CreateAsync(skill1);
var id2 = await repository.CreateAsync(skill2);
var foundSkill1 = await context.Skills.FirstAsync();
var foundSkill2 = (await context.Skills.ToArrayAsync())[1];
Assert.Equal(foundSkill1.Id, id1);
Assert.Equal(foundSkill2.Id, id2);
}
}
public Creature(Dictionary <string, object> NamedRange)
{
Id = (NamedRange.ContainsKey("Id")? NamedRange["Id"].ToString().AsInt(): -1);
SpeciesId = NamedRange["SpeciesId"].ToString().AsInt();
EvolutionId = NamedRange["EvolutionId"].ToString().AsInt();
EvolutionStage = NamedRange["EvolutionStage"].ToString().AsInt();
NameEn = NamedRange["NameEn"].ToString();
NameFr = NamedRange["NameFr"].ToString();
BaseRank = NamedRange["BaseRank"].ToString().AsInt();
HP = NamedRange["HP"].ToString().AsInt();
ATK = NamedRange["ATK"].ToString().AsInt();
DEF = NamedRange["DEF"].ToString().AsInt();
SPD = NamedRange["SPD"].ToString().AsInt();
CRIT = NamedRange["CRIT"].ToString().AsInt();
CRITD = NamedRange["CRITD"].ToString().AsInt();
ACC = NamedRange["ACC"].ToString().AsInt();
RES = NamedRange["RES"].ToString().AsInt();
Element = new Element(NamedRange["ElementId"].ToString().AsInt());
Role = new Role(NamedRange["RoleId"].ToString().AsInt());
Skills = new List <Skill>()
{
SkillRepository.GetSkillById((NamedRange.ContainsKey("Spell1Id")? NamedRange["Spell1Id"].ToString().AsInt(): -1)),
SkillRepository.GetSkillById((NamedRange.ContainsKey("Spell1AId")? NamedRange["Spell1AId"].ToString().AsInt(): -1)),
SkillRepository.GetSkillById((NamedRange.ContainsKey("Spell1BId")? NamedRange["Spell1BId"].ToString().AsInt(): -1)),
SkillRepository.GetSkillById((NamedRange.ContainsKey("Spell2Id")? NamedRange["Spell2Id"].ToString().AsInt(): -1)),
SkillRepository.GetSkillById((NamedRange.ContainsKey("Spell3Id")? NamedRange["Spell3Id"].ToString().AsInt(): -1))
};
}
public DeveloperSkillsPostController()
{
db = new ApplicationDbContext();
_developerSkillsRepository = new DeveloperSkillsRepository(db);
_unitOfWork = new UnitOfWork(db);
_skillRepository = new SkillRepository(db);
}
public JobService(DatabaseContext context, BoTuDienRepository boTuDienRepository, SkillRepository skillRepository, DanhSachJobSkillRepository danhSachJobSkillRepository) : base(context)
{
this.dbContext = context;
this.boTuDienRepository = boTuDienRepository;
this.skillRepository = skillRepository;
this.danhSachJobSkillRepository = danhSachJobSkillRepository;
}
public async void AddSkillAsyncWithId_GivenSkillAndUserExist_ReturnsSUCCESS()
{
var existingUser = new User()
{
Id = 1, Firstname = "IAlready", Surname = "Exist", Mail = "*****@*****.**", AzureUId = "existingAuzreUId"
};
var existingSkill = new Skill()
{
Id = 1, Name = "Dancing"
};
userRepository = new UserRepository(setupContextForIntegrationTests());
skillRepository = new SkillRepository(context);
projectRepository = new ProjectRepository(context);
var skillLogic = new SkillLogic(skillRepository, userRepository, projectRepository);
context.Users.Add(existingUser);
context.Skills.Add(existingSkill);
context.SaveChanges();
context.Entry(existingSkill).State = EntityState.Detached;
//SanityCheck
Assert.Equal(1, await context.Users.CountAsync());
Assert.Equal(existingUser, await context.Users.FirstAsync());
Assert.Equal(1, await context.Skills.AsNoTracking().CountAsync());
using (var logic = new UserLogic(userRepository, skillLogic, sparkLogicMock.Object, locationLogicMock.Object))
{
var result = await logic.AddSkillAsync(1, 1);
Assert.Equal(ResponseLogic.SUCCESS, result);
}
}
public async void CreateAsync(UserCreateDTO user, String azureUId, ResponseLogic expected)
{
var existingUser = new User()
{
Id = 1, Firstname = "IAlready", Surname = "Exist", Mail = "*****@*****.**", AzureUId = "existingAuzreUId"
};
var existingLocation = new Location()
{
Id = 1, City = "Sydney", Country = "Australia"
};
userRepository = new UserRepository(setupContextForIntegrationTests());
skillRepository = new SkillRepository(context);
projectRepository = new ProjectRepository(context);
locationRepository = new LocationRepository(context);
var locationLogic = new LocationLogic(locationRepository, userRepository, projectRepository);
context.Users.Add(existingUser);
context.Locations.Add(existingLocation);
context.SaveChanges();
//SanityCheck
Assert.Equal(1, await context.Users.CountAsync());
Assert.Equal(existingUser, await context.Users.FirstAsync());
Assert.Equal(1, await context.Locations.CountAsync());
Assert.Equal(existingLocation, await context.Locations.FirstAsync());
using (var logic = new UserLogic(userRepository, skillLogicMock.Object, sparkLogicMock.Object, locationLogic))
{
var result = await logic.CreateAsync(user, azureUId);
Assert.Equal(expected, result);
}
}
public async void DeleteAsync_GivenSkillExistsAndInProjectsAndUser_ReturnsSuccess()
{
var skillToDelete = new Skill
{
Id = 1,
Name = "Category"
};
var creatorUser = new User()
{
Id = 1, Firstname = "First", Surname = "Sur", AzureUId = "Azure", Mail = "*****@*****.**", Skills = new List <UserSkill> {
{ new UserSkill()
{
UserId = 1, Skill = skillToDelete
} }
},
};
var projects = new List <Project>
{
new Project {
Id = 1, Title = "Project1", Skills = new List <ProjectSkill> {
new ProjectSkill()
{
ProjectId = 1, Skill = skillToDelete
}
}, CreatedDate = DateTime.Now, Description = "abcd", CreatorId = creatorUser.Id
},
new Project {
Id = 2, Title = "Project2", Skills = new List <ProjectSkill> {
new ProjectSkill()
{
ProjectId = 2, Skill = skillToDelete
}
}, CreatedDate = DateTime.Now, Description = "abcd", CreatorId = creatorUser.Id
}
};
skillRepository = new SkillRepository(setupContextForIntegrationTests());
context.Skills.Add(skillToDelete);
context.Users.Add(creatorUser);
context.Projects.AddRange(projects);
context.SaveChanges();
//Sanity Check
Assert.NotNull(context.Skills.Find(skillToDelete.Id));
Assert.Equal(2, (await context.Projects.ToArrayAsync()).Length);
using (var logic = new SkillLogic(skillRepository, userRepositoryMock.Object, projectRepositoryMock.Object))
{
var response = await logic.DeleteAsync(skillToDelete.Id);
Assert.Equal(ResponseLogic.SUCCESS, response);
foreach (var project in await context.Projects.ToArrayAsync())
{
Assert.Empty(project.Skills);
}
}
}
public UnitOfWork(MyResumeContext context)
{
_context = context;
Experiences = new ExperienceRepository(_context);
Skills = new SkillRepository(_context);
MyProfile = new MyProfileRepository(_context);
}
public JobType(
JobStateRepository jobStateRepository,
JobRepository jobRepository,
SkillRepository skillRepository,
JobSkillRepository jobSkillRepository
)
{
Field(x => x.Id, type: typeof(IdGraphType));
Field(x => x.Title, nullable: true);
Field(x => x.Description, nullable: true);
Field <JobStateType>(
"jobState",
resolve: context =>
{
if (context.Source.JobStateId != null)
{
return(jobStateRepository.GetById((Guid)context.Source.JobStateId));
}
return(null);
}
);
//// Async test
//FieldAsync<JobStateType>(
// "jobState",
// resolve: async context =>
// {
// if (context.Source.JobStateId != null) {
// return await context.TryAsyncResolve(
// async c => await jobStateRepository.GetByIdAsync((Guid)context.Source.JobStateId)
// );
// }
//
// return null;
// }
//);
Field <ListGraphType <SkillType> >(
"skills",
resolve: context => skillRepository.GetByJobId(context.Source.Id)
);
//// Async test
//FieldAsync<ListGraphType<SkillType>>(
// "skills",
// resolve: async context =>
// {
// return await context.TryAsyncResolve(
// async c => await skillRepository.GetByJobIdAsync(context.Source.Id)
// );
// }
//);
Field(x => x.CreatedByUserId, type: typeof(IdGraphType));
// TODO: Field(x => x.CreatedByUser, type: typeof(UserType));
Field(x => x.ModifiedByUserId, type: typeof(IdGraphType));
// TODO: Field(x => x.ModifiedByUser, type: typeof(UserType));
}
public ContactsController(ContactRepository repository, SkillRepository skillRepository, IMapper mapper,
IHttpContextAccessor httpContextAccessor)
{
_repository = repository;
_skillRepository = skillRepository;
_mapper = mapper;
_httpContextAccessor = httpContextAccessor;
}
public UnitOfWork(EMSDbContext context, IPropertyMappingService propertyMappingService)
{
_context = context ?? throw new ArgumentNullException(nameof(context));
Jobs = new JobRepository(context);
JobSkills = new JobSkillRepository(context);
Skills = new SkillRepository(context, propertyMappingService);
Employees = new EmployeeRepository(context);
}
public IEnumerable<SkillTemplate> GetSkills()
{
using (var context = new GameDatabaseContext())
{
var repo = new SkillRepository(context);
return repo.GetAll();
}
}
public SkillTemplate GetSkillById(int id)
{
using (var context = new GameDatabaseContext())
{
var repo = new SkillRepository(context);
return repo.Get(id);
}
}
public GetPersonalProfileDependencies(PersonalProfileRepository personalProfileRepo, SkillRepository skillRepo,
InterestsRepository interestsRepository, UserIdRepository userIdRepository)
{
_personalProfileRepo = personalProfileRepo;
_skillRepo = skillRepo;
_interestsRepository = interestsRepository;
_userIdRepository = userIdRepository;
}
private static void CreateSkills(ApplicationContext AppContext)
{
SkillRepository repo = new SkillRepository(AppContext);
{
List <Skill> list = GetSkillList();
repo.InsertAll(list);
}
}
public void TestMethod1()
{
ISkillRepository SkillRepo = new SkillRepository(new EmployeeCapacityDBContext());
var items = SkillRepo.GetListofSkills();
TestContext.WriteLine("test");
}
public RecruiterServiceIntegrationTest()
{
_recruiterRepository = new RecruiterRepository(_database);
_companyRepository = new CompanyRepository(_database);
_jobOfferRepository = new JobOfferRepository(_database);
_skillRepository = new SkillRepository(_database);
_service = new RecruiterService(_companyRepository, _recruiterRepository, _jobOfferRepository);
}
public PostPersonalProfileDependencies(PersonalProfileRepository personalProfileRepo, SkillRepository skillRepo,
InterestsRepository interestsRepository, UserIdRepository userIdRepository, IEmailSender emailSender)
{
_personalProfileRepo = personalProfileRepo;
_skillRepo = skillRepo;
_interestsRepository = interestsRepository;
_userIdRepository = userIdRepository;
_emailSender = emailSender;
}
async void SaveClicked(object sender, EventArgs e)
{
try
{
skill.ClassID = getSkillClassID();
if (skill.ClassID > 0)
{
SkillRepository s = new SkillRepository();
if (skill.ID == 0)
{
await s.AddSkill(skill);
}
else
{
await s.UpdateSkill(skill);
}
thisApp.needClassRefresh = true;
await Navigation.PopAsync();
}
else
{
await DisplayAlert("Class Not Selected:", "You must set the class.", "Ok");
}
}
catch (AggregateException ex)
{
string errMsg = "";
foreach (var exception in ex.InnerExceptions)
{
errMsg += Environment.NewLine + exception.Message;
}
await DisplayAlert("One or more exceptions has occurred:", errMsg, "Ok");
}
catch (ApiException apiEx)
{
var sb = new StringBuilder();
sb.AppendLine("Errors:");
foreach (var error in apiEx.Errors)
{
sb.AppendLine("-" + error);
}
thisApp.needSkillRefresh = true;
await DisplayAlert("Problem Saving the Skill:", sb.ToString(), "Ok");
}
catch (Exception ex)
{
if (ex.GetBaseException().Message.Contains("connection with the server"))
{
await DisplayAlert("Error", "No connection with the server.", "Ok");
}
else
{
await DisplayAlert("Error", "Could not complete operation.", "Ok");
}
}
}
public SkillRepositoryTest()
{
ContextOptions = new DbContextOptionsBuilder <ApplicationDbContext>().UseSqlite(CreateInMemoryDatabase()).Options;
_connection = RelationalOptionsExtension.Extract(ContextOptions).Connection;
_context = new ApplicationDbContext(ContextOptions);
Seed();
_skillRepository = new SkillRepository(_context);
}
protected override void Save()
{
using (var db = new GameDatabaseContext())
{
var ContentTemplate = this.ContentTemplate as SkillTemplate;
var repository = new SkillRepository(db);
repository.Update(ContentTemplate, ContentTemplate.Id);
}
base.Save();
}
/// <summary>
/// The constructor of the Job business logic layer.
/// </summary>
public JobBLL(
JobRepository jobRepository,
SkillRepository skillRepository,
JobSkillRepository jobSkillRepository
)
{
this.jobRepository = jobRepository;
this.skillRepository = skillRepository;
this.jobSkillRepository = jobSkillRepository;
}
public IHttpActionResult SaveSkill(SkillTemplate skillTemplate, int id)
{
using (var context = new GameDatabaseContext())
{
var repo = new SkillRepository(context);
repo.Update(skillTemplate, id);
return Ok();
}
}
[System.Web.Mvc.HttpPost] public SkillRemoveResult Remove(Skill skill)
{
var ret = new SkillRemoveResult
{
SkillId = skill.SkillId,
SkillGroupId = skill.SkillGroupId,
FailedToRemove = !SkillRepository.Remove(skill)
};
return(ret);
}
public void Get_ReturnAOkObjectResult_GetOneTechnologyByID()
{
//Arrange
var _skillRepository = new SkillRepository(DbContextMocker.GetTechnologyContext());
var _tecnologyController = new TechnologyController(_skillRepository);
// Act
var response = _tecnologyController.Get(1);
// Assert
Assert.IsType <OkObjectResult>(response);
}
public RecruiterServiceIntegrationTest()
{
_recruiterRepository = new RecruiterRepository(_database);
_companyRepository = new CompanyRepository(_database);
_jobOfferRepository = new JobOfferRepository(_database);
_skillRepository = new SkillRepository(_database);
_personRepository = new PersonRepository(_database);
_accountRepository = new AccountRepository(_database);
_recruiterService = new RecruiterService(_companyRepository, _recruiterRepository, _jobOfferRepository, _personRepository, _accountRepository);
_personService = new PersonService(_personRepository, _jobOfferRepository, _accountRepository);
}
public void DrawDetails(NTree dataTree)
{
if (Type == NodeType.Skill)
{
var skill = RPG.PlayerData.Skills.First(s => s.Name == Ref);
new UIText(Ref, new Point(UI.WIDTH / 2, UI.HEIGHT - 95), 0.3f, Color.White, 0, true).Draw();
new UIText(skill.Description, new Point(UI.WIDTH / 2, UI.HEIGHT - 75), 0.22f, Color.White, 0, true).Draw();
var topPoint = new Point(UI.WIDTH / 2, UI.HEIGHT - 62);
var i = 0;
var sparams = SkillRepository.GetVisibleParams(Ref);
foreach (var kvp in sparams)
{
new UIText(kvp.Key + ": " + kvp.Value.Invoke(skill), topPoint + new Size(0, 10 * i), 0.20f, Color.DodgerBlue, 0, true).Draw();
i++;
}
new UIText(skill.Unlocked ? "unlocked" : "unlock for " + skill.PointsToUnlock + " SP", new Point(UI.WIDTH / 2, UI.HEIGHT - 22), 0.20f, Color.Gray, 0, true).Draw();
Sprite.Draw(new Point(UI.WIDTH / 2 - 140, UI.HEIGHT - 50), 40, 40, Color.FromArgb(120, 255, 255, 255));
}
else if (Type == NodeType.Weapon)
{
var wep = RPG.PlayerData.Weapons.FirstOrDefault(s => s.WeaponHash == WepHash);
new UIText(Ref, new Point(UI.WIDTH / 2, UI.HEIGHT - 95), 0.3f, Color.White, 0, true).Draw();
new UIText(wep.Description, new Point(UI.WIDTH / 2, UI.HEIGHT - 75), 0.22f, Color.White, 0, true).Draw();
var topPoint = new Point(UI.WIDTH / 2, UI.HEIGHT - 62);
//var i = 0;
//var sparams = SkillRepository.GetVisibleParams(Ref);
//foreach (var kvp in sparams)
//{
// new UIText(kvp.Key +": " + kvp.Value.Invoke(skill) ,topPoint + new Size(0,10 * i) , 0.20f, Color.DodgerBlue, 0, true).Draw();
// i++;
//}
new UIText(wep.Unlocked ? "unlocked" : "unlock for " + wep.PointsToUnlock + " SP [Requires Lv." + wep.LevelToUnlock + "]", new Point(UI.WIDTH / 2, UI.HEIGHT - 22), 0.20f, Color.Gray, 0, true).Draw();
Sprite.Draw(new Point(UI.WIDTH / 2 - 140, UI.HEIGHT - 50), 40, 40, Color.FromArgb(120, 255, 255, 255));
}
else if (Type == NodeType.SkillMod)
{
new UIText(Ref, new Point(UI.WIDTH / 2, UI.HEIGHT - 95), 0.3f, Color.White, 0, true).Draw();
new UIText(Description, new Point(UI.WIDTH / 2, UI.HEIGHT - 75), 0.22f, Color.White, 0, true).Draw();
var skillForMod = RPG.PlayerData.Skills.FirstOrDefault(s => s.Name == dataTree.TreeRef);
var mod = skillForMod.UsedMods.FirstOrDefault(s => s == Ref);
var unlockedText = mod != null ? "unlocked" : "unlock for " + skillForMod.Mods[Ref] + " SP";
new UIText(unlockedText, new Point(UI.WIDTH / 2, UI.HEIGHT - 22), 0.20f, Color.Gray, 0, true).Draw();
Sprite.Draw(new Point(UI.WIDTH / 2 - 140, UI.HEIGHT - 50), 40, 40, Color.FromArgb(120, 255, 255, 255));
}
}
public void MultipleSkillsAreReturnedInOrder()
{
//Arrange
var context = GetSqlLiteContext();
var cvRepository = new CvRepository(context);
var skillRepository = new SkillRepository(context);
var cv = new Cv()
{
Name = Constants.CvName, TagLine = Constants.CvTagLine, Blurb = Constants.CvBlurb
};
cvRepository.Add(cv);
var cvId = cvRepository.Get()[0].Id;
//Act
var skill1 = new Skill()
{
Name = "Continuous Delivery", Blurb = "Awesome at CI and CD", Order = 5
};
skillRepository.AddToCv(skill1, cvId);
var skill2 = new Skill()
{
Name = "DevOps", Blurb = "DevOps Master", Order = 3
};
skillRepository.AddToCv(skill2, cvId);
var skill3 = new Skill()
{
Name = "Agile", Blurb = "Agile Expert", Order = 1
};
skillRepository.AddToCv(skill3, cvId);
var skill4 = new Skill()
{
Name = "Software Engineering", Blurb = "Since 2001", Order = 2
};
skillRepository.AddToCv(skill4, cvId);
//Assert
var results = skillRepository.GetForCv(cvId);
var order = 0;
foreach (var result in results)
{
Assert.IsTrue(result.Order > order);
order = result.Order;
}
}
public void Use(Skill obj)
{
if (CoolDownTimer.Usable)
{
SkillRepository.GetAction(Name).Invoke(obj);
CoolDownTimer.Reset();
}
else
{
var secs = CoolDownTimer.SecondsRemaining.ToString("0.0");
RPG.Notify("cannot use " + Name + " for " + secs + "s");
}
}
public IHttpActionResult NewSkill()
{
using (var context = new GameDatabaseContext())
{
var repo = new SkillRepository(context);
var skill =
repo.Add(new SkillTemplate(SkillType.Elemental, SkillTargetType.Enemy, SkillActivationType.Immediate, 0,
0, "", 0, "New Skill"));
return Ok(skill);
}
}
public override void UseItemOn(Character character, Character user)
{
var player = character as Player;
if (player != null)
{
using (var context = new GameDatabaseContext())
{
var skillRepo = new SkillRepository(context);
var skillTemplate = skillRepo.Get(ItemTemplate.LearntSkillId);
player.AddSkill(new Skill(skillTemplate));
}
}
else
{
Logger.Instance.Warn("You cannot use a skillbook on a non-player target.");
}
}
public RpgController()
{
EventRepository = new EventRepository(_context);
EventLinkItemRepository = new EventLinkItemRepository(_context);
QuestRepository = new QuestRepository(_context);
HeroRepository = new HeroRepository(_context);
SkillRepository = new SkillRepository(_context);
GuildRepository = new GuildRepository(_context);
SkillSchoolRepository = new SkillSchoolRepository(_context);
TrainingRoomRepository = new TrainingRoomRepository(_context);
CharacteristicRepository = new CharacteristicRepository(_context);
CharacteristicTypeRepository = new CharacteristicTypeRepository(_context);
StateRepository = new StateRepository(_context);
StateTypeRepository = new StateTypeRepository(_context);
//using (var scope = StaticContainer.Container.BeginLifetimeScope())
//{
// EventRepository = scope.Resolve<IEventRepository>();
// QuestRepository = scope.Resolve<IQuestRepository>();
// HeroRepository = scope.Resolve<IHeroRepository>();
// SkillRepository = scope.Resolve<ISkillRepository>();
//}
}
private void PopulateToolsetViewModel()
{
ClearViewModelPopulation();
using (GameModuleRepository repo = new GameModuleRepository())
{
ViewModel.ActiveModule = repo.GetModule();
}
using (ContentPackageResourceRepository repo = new ContentPackageResourceRepository())
{
ViewModel.TilesetSpriteSheetsList = repo.GetAllUIObjects(ContentPackageResourceTypeEnum.Tileset, false);
}
using (ItemRepository repo = new ItemRepository())
{
ViewModel.ItemList = repo.GetAllUIObjects();
}
using (ScriptRepository repo = new ScriptRepository())
{
ViewModel.ScriptList = repo.GetAllUIObjects();
}
using (GenderRepository repo = new GenderRepository())
{
ViewModel.GenderList = repo.GetAllUIObjects();
}
using (ConversationRepository repo = new ConversationRepository())
{
ViewModel.ConversationList = repo.GetAllUIObjects();
}
using (RaceRepository repo = new RaceRepository())
{
ViewModel.RaceList = repo.GetAllUIObjects();
}
using (FactionRepository repo = new FactionRepository())
{
ViewModel.FactionList = repo.GetAllUIObjects();
}
using (TilesetRepository repo = new TilesetRepository())
{
ViewModel.TilesetList = repo.GetAllUIObjects();
}
using (AbilityRepository repo = new AbilityRepository())
{
ViewModel.AbilityList = repo.GetAll();
}
using (SkillRepository repo = new SkillRepository())
{
ViewModel.SkillList = repo.GetAll();
}
using (LevelRequirementRepository repo = new LevelRequirementRepository())
{
ViewModel.LevelRequirementList = repo.GetAll();
}
}
