public void AddGroup(YearOfStudy year, Specialization spec)
{
var group = Project.Schedule.AddNewGroup(year, spec);
var table = Tables.First(t => t.YearOfStudy == year);
var index = Tables.IndexOf(table);
Tables[index].AddGroup(group);
}
public HunterBase (Character charac, StatsHunter stats, HunterTalents talents, Specialization spec, int targetLvL)
{
character = charac;
Stats = stats;
Talents = talents;
Tree = spec;
TargetLevel = targetLvL;
}
public void setReadouts(Specialization s)
{
spec = s;
description.Display(spec.name);
description.Display(spec.description);
coolDownLength.Display(spec.cooldown);
Icon.SpriteName = spec.icon;
}
public EducationalPlan(Specialization parSpecialization, Specialty parSpecialty, int parYear, string parLevelEducation, string parFgos)
{
specialization = parSpecialization;
specialty = parSpecialty;
year = parYear;
levelEducation = parLevelEducation;
fgos = parFgos;
}
public EducationalPlan(Specialization parSpecialization, Specialty parSpecialty, int parYear, string parLevelEducation)
{
if (parSpecialization != null)
specialization = parSpecialization;
else specialization = new Specialization("", "");
specialty = parSpecialty;
year = parYear;
levelEducation = parLevelEducation;
}
/// <summary>
/// Конструктор характеристики - информации по дисциплине, для получение инфы из выписки ТП
/// </summary>
/// <param name="parIndex">Номер в комбобоксе</param>
/// <param name="parFileAdres">Адрес файла</param>
/// <param name="parNumberList">Название(номер) листа в выписке ТП</param>
/// <param name="parDiscipline">Название дисциплины</param>
/// <param name="parSpecialty">Специальность</param>
/// <param name="parSpecialization">Специализация</param>
public Characteristic(int parIndex,string parFileAdres, string parNumberList, string parDiscipline, Specialty parSpecialty, Specialization parSpecialization)
{
this.discipline = parDiscipline;
this.fileAdres = parFileAdres;
this.numberList = parNumberList;
this.specialization = parSpecialization;
this.specialty = parSpecialty;
this.indexInBox = parIndex;
}
public Group(int count, Specialization specialization)
{
Count = count;
Rank = Rank.Ordinary;
Specialization = specialization;
Qualification = Qualification.low;
Experience = Qualification.low;
Vitality = Vitality.healthy;
}
public Group(int count, Rank rank, Specialization specialization, Qualification qualification, Qualification experience, Vitality vitality)
{
OriginalCount = count;
Count = count;
Rank = rank;
Specialization = specialization;
Qualification = qualification;
Experience = experience;
Vitality = vitality;
}
public async Task <IActionResult> Create(Specialization specialization)
{
if (ModelState.IsValid)
{
_repository.Add <Specialization>(specialization);
await _repository.SavaAll();
return(RedirectToAction(nameof(Index)));
}
return(View(specialization));
}
public ActionResult Delete(int id)
{
Specialization specialization = unitOfWork.Specializations.FindById(id);
if (specialization != null)
{
unitOfWork.Specializations.Remove(specialization);
}
return(RedirectToAction("Index"));
}
public void Init(Specialization spec, SimulationManager simulation, ParallelTimelineDisplay timelines)
{
Name.text = spec.Name;
foreach (Upgrade upgrade in spec.Upgrades)
{
UpgradeDisplay upgradeDisplay = Instantiate(UpgradeDisplayPrefab, UpgradeDisplayParent, false);
upgradeDisplay.Upgrade = upgrade;
upgradeDisplay.Simulation = simulation;
upgradeDisplay.Timelines = timelines;
}
}
public ActionResult Delete(int id)
{
using (HISDBEntities db = new HISDBEntities())
{
Specialization spl = db.Specializations.Where(x => x.SpecializationID == id)
.FirstOrDefault <Specialization>();
db.Specializations.Remove(spl);
db.SaveChanges();
return(Json(new { success = true, message = "Deleted Successfully" }, JsonRequestBehavior.AllowGet));
}
}
public ActionResult Create([Bind(Include = "Id,Name")] Specialization specialization)
{
if (ModelState.IsValid)
{
db.Specializations.Add(specialization);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(specialization));
}
protected Specialization GetSpecializationByLocalizedName(string localizedName)
{
Specialization returnSpecialization = null;
if (this.SpecializationDictionaryByLocalizedName.ContainsKey(localizedName) == true)
{
returnSpecialization = this.SpecializationDictionaryByLocalizedName[localizedName];
}
return(returnSpecialization);
}
//
// GET: /Specialization/Edit/5
public ActionResult Edit(int id = 0)
{
Specialization specialization = db.Specializations.Find(id);
if (specialization == null)
{
return(HttpNotFound());
}
ViewBag.PersonalInfoId = new SelectList(db.PersonalInformations, "Id", "FathersName", specialization.PersonalInfoId);
ViewBag.LanguageProficiencyId = new SelectList(db.LanguageProficiency, "Id", "Reading", specialization.LanguageProficiencyId);
return(View(specialization));
}
public bool CancelSub(Specialization specialization)
{
try
{
UsersSpecializationsRepository.DeleteFilter(string.Format("User_id = {0} AND Specialization_Id = {1}", session.User.Id, specialization.Id));
return(true);
}
catch (Exception)
{
return(false);
}
}
public SpecializationViewModel FromSpecialization(Specialization specialization)
{
var viewModel = new SpecializationViewModel();
if (specialization.Id != null)
{
viewModel.Id = specialization.Id;
}
viewModel.Name = specialization.Name;
viewModel.Doctors = GetDoctorsMultiSelect(specialization.Doctors.Select(d => d.Id));
return(viewModel);
}
public ActionResult Edit(Specialization specialization)
{
if (ModelState.IsValid)
{
db.Entry(specialization).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.PersonalInfoId = new SelectList(db.PersonalInformations, "Id", "FathersName", specialization.PersonalInfoId);
ViewBag.LanguageProficiencyId = new SelectList(db.LanguageProficiency, "Id", "Reading", specialization.LanguageProficiencyId);
return(View(specialization));
}
public void UpdateSpecialization(Specialization s)
{
if (s.TariffMin < 26.88 || s.TariffMax < 26.88)
{
throw new Exception("Min / Max rate cannot be less than minimum wage");
}
if (s.TariffMin > s.TariffMax)
{
throw new Exception("Minimum rate cannot be less maximum rate");
}
dal.UpdateSpecialization(s);
}
public void addSpecialization(Specialization s)
{
validSpecialization(s);
try
{
dal.addSpecialization(s);
}
catch (InvalidCastException e)
{
throw e;
}
}
public async Task <ActionResult <Specialization> > CreateSpecialization(Specialization specialization)
{
specialization.Created = DateTime.Now;
if (specialization == null)
{
return(BadRequest());
}
db.Add(specialization);
await db.SaveChangesAsync();
return(Ok(specialization));
}
public void updateSpecialization(Specialization newJob)
{
validSpecialization(newJob);
try
{
dal.updateSpecialization(newJob);
}
catch (InvalidCastException e)
{
throw e;
}
}
public PatientAppointmentDoctor(int doctorId, IUnitOfWork _unitOfWork)
{
Doctor = _unitOfWork.Doctors.FindById(doctorId);
if (Doctor != null)
{
Specialization = _unitOfWork.Specializations.FindById((int)Doctor.SpecializationId);
}
else
{
throw new Exception("Доктор не найден!");
}
}
public ActionResult DeleteConfirmed(Guid id)
{
if (!HomeController.Authorized(this))
{
return(RedirectToAction("Login", "Accounts"));
}
Specialization specialization = db.Specializations.Find(id);
db.Specializations.Remove(specialization);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public async Task <Specialization> AddSpecialization(Specialization specialization)
{
var spec = _dbContext.Specializations.FirstOrDefault(s => s.Name == specialization.Name);
if (spec == null)
{
_dbContext.Specializations.Add(specialization);
await _dbContext.SaveChangesAsync();
}
return(spec);
}
public void CRUD_Insertion_And_ReadingTest_Exception()
{
Specialization specialization = new Specialization()
{
ID = 1, Name = "Phisic1"
};
CRUD <Specialization> crud = new CRUD <Specialization>();
crud.Add(specialization, "ID");
Specialization t_specialization = crud.Get(t => t.ID == specialization.ID);
}
public static SpecializationDTO CastToDTO(Specialization specialization)
{
List <int> userId = new List <int>();
db.UserToSpecs.Where(i => i.specId == specialization.specId).ToList().ForEach(f => userId.Add(f.userId));
return(new SpecializationDTO()
{
specId = specialization.specId,
specName = specialization.specName,
specKindId = specialization.specKindId
});
}
private void WriteSpecialization(Specialization specialization,
ReferenceLinkDisplayOptions options, XmlWriter writer)
{
// write the type itself (without outer types, because those
// will be written be other calls to this routine)
WriteSimpleType(specialization.TemplateType,
(options & ~ReferenceLinkDisplayOptions.ShowTemplates),
false, writer);
// then write the template arguments
WriteTemplateArguments(specialization.arguments, writer);
}
public ActionResult Create(int id, Specialization specialization)
{
specialization.CourseId = id;
if (ModelState.IsValid)
{
db.Specializations.Add(specialization);
db.SaveChanges();
return(RedirectToAction("Details", "Courses", new { id = id }));
}
return(View(specialization));
}
public async Task <IActionResult> PostSpecialization([FromBody] Specialization specialization)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
_context.Specialization.Add(specialization);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetSpecialization", new { id = specialization.SpecID }, specialization));
}
/// <summary>
/// Add new Specialization and Group to given YearOfStudy
/// </summary>
/// <param name="year"></param>
public void AddNewSG(YearOfStudy year)
{
var spec = new Specialization {
Name = "Новая специальность"
};
var group = new Group {
Name = "Новая группа", YearOfStudy = year, Specialization = spec
};
AddSpecialization(spec);
AddGroup(group);
}
/// <summary>
/// Converts a value.
/// </summary>
/// <param name="value">The boolean value produced by the binding source.</param>
/// <param name="targetType">The type of the binding target property.</param>
/// <param name="parameter">The converter parameter to use.</param>
/// <param name="culture">The culture to use in the converter.</param>
/// <returns>An Uri to the icon for the input <see cref="Specialization"/>.</returns>
public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
{
Specialization specialization = (Specialization)value;
// Show no icon for a blank profession
if (specialization == Specialization.None)
{
return(null);
}
return($"pack://application:,,,/Icons/{specialization}_Specialization.png");
}
public async Task <Specialization> Create(Specialization input)
{
Specialization newSpecialization = new Specialization
{
Name = input.Name
};
_context.Specializations.Add(newSpecialization);
await _context.SaveChangesAsync();
return(newSpecialization);
}
public Vacancy ToModel()
{
return(new Vacancy
(
User.ToModel(),
Specialization.ToModel(),
Skills.Select(s => s.Skill.ToModel()).ToList(),
Information
)
{
Id = Id
});
}
// Insert new Specialization
public bool Insert(Specialization aSpecialization)
{
try {
db.Specializations.InsertOnSubmit(aSpecialization);
db.SubmitChanges();
return(true);
}
catch (Exception ex) {
return(false);
throw new Exception("SpecializationBO.Select_ByFacultyCode" + ex.ToString());
}
}
public static string add(Specialization specialization)
{
if (unitOfWork.Specializations.GetAll().Find(spec => spec.name == specialization.name) == null)
{
unitOfWork.Specializations.Add(specialization);
unitOfWork.Save();
return("Новая специализация создана.");
}
else
{
return("Такая специализация уже существует!");
}
}
public async Task AddSpecialization(Sphere sphere, Specialization spec)
{
spec = _context.Specializations.Add(spec).Entity;
var sphereSpec = new SphereSpecializations()
{
SpecializationId = spec.Id,
SphereId = sphere.Id
};
_context.SphereSpecializations.Add(sphereSpec);
await _context.SaveChangesAsync();
}
public async Task <Specialization> Read(int id)
{
Specialization specialization = await _context.Specializations.FindAsync(id);
if (specialization != null)
{
return(specialization);
}
else
{
return(null);
}
}
public void OnDragDrop(dfControl source, dfDragEventArgs args)
{
if (isEquipSlot && args.Data is DraggableSpecialization)
{
var item = (DraggableSpecialization)args.Data;
spec = item.spec;
this.name = item.spec.name;
this.Icon = item.spec.icon;
args.State = dfDragDropState.Dropped;
args.Use();
espec.setEquiped(spec);
}
}
/// <summary>
/// Проверка на наличие выписки ТП для дисциплин
/// </summary>
/// <param name="parCheckedListBoxCathedra">ЛистЧекБокс с дисциплинами</param>
/// <param name="parCodeSpecialty">Код специальности</param>
/// <param name="parSpecialty">Название специальности</param>
/// <param name="parCodeSpecialization">Код специализации</param>
/// <param name="parSpecialization">Название специализации</param>
public void Verify(/*ListBox parListBox,*/ CheckedListBox parCheckedListBoxCathedra, string parCodeSpecialty, string parSpecialty, string parCodeSpecialization, string parSpecialization)
{
this.specialization = new Specialization(parCodeSpecialization, parSpecialization);
this.specialty = new Specialty(parCodeSpecialty, parSpecialty);
string discipline;
//foreach (object item in parCheckedListBoxCathedra.Items)
//Пробегаем по всему списку листачекбокса
for (int i = 0; i<parCheckedListBoxCathedra.Items.Count;i++)
{
//discipline = item.ToString().Replace(" - ","");
//берем название дисциплины
discipline = parCheckedListBoxCathedra.Items[i].ToString().Replace(" - ", "").Trim();
//проверяем есть ли такая в выписке и вытаскием инфу по ней, при наличии
if (ProcessingDiscipline(discipline))
{
/*parCheckedListBoxCathedra.SetItemChecked(parListBox.Items.IndexOf(item), true);
parCheckedListBoxCathedra.Items[parListBox.Items.IndexOf(item)] = this.cathedra;*/
// parCheckedListBoxCathedra.Items[parCheckedListBoxCathedra.Items.IndexOf(item)] = this.cathedra + " - " + discipline;
//parCheckedListBoxCathedra.SetItemChecked(parCheckedListBoxCathedra.Items.IndexOf(item), true);
parCheckedListBoxCathedra.Items[i] = discipline+" - "+this.cathedra;
parCheckedListBoxCathedra.SetItemChecked(i, true);
//добавляем характеристику к дисциплине
listCharacteristics.Add(new Characteristic(i,fileadres,numberlist,discipline,specialty,specialization));
}
}
}
private void setStatus(Specialization s)
{
if (!s.unlocked)
{
control.Opacity = 1;
Name.l.Opacity = .3f;
}
else
{
control.Opacity = 0;
Name.l.Opacity = 1;
}
spec = s;
setReadouts();
if (spec.unlocked)
{
slot.enabled = true;
slot.spec = this.spec;
}
}
public void UpdateVerifiedDate_AnySpecializationId_ExpriredToday()
{
var settingsMock = new Mock<ISettings>();
var repositoryMock = new Mock<IRepository>();
var uowMock = new Mock<IUnitOfWork>();
var serviceLocatorMock = new Mock<IServiceLocator>();
serviceLocatorMock.Setup(x => x.GetInstance<IRepository>())
.Returns(repositoryMock.Object);
serviceLocatorMock.Setup(x => x.GetInstance<IUnitOfWork>())
.Returns(uowMock.Object);
ServiceLocator.SetLocatorProvider(() => serviceLocatorMock.Object);
repositoryMock.Setup(r => r.CreateUnitOfWork()).Returns(uowMock.Object);
// Arrange
Guid id = Guid.NewGuid();
DateTime expiredDate = DateTime.Now;
Specialization specialization = new Specialization
{
Id = id
};
Specialization[] specializations = new Specialization[] { specialization };
repositoryMock.Setup(r => r.Query<Specialization>()).Returns(specializations.AsQueryable());
// Act
ManagementService managementService = new ManagementService(uowMock.Object, repositoryMock.Object, settingsMock.Object);
var currentResult = managementService
.UpdateVerifiedDate(id.ToString(), expiredDate);
// Assert
repositoryMock.Verify(repo => repo
.Update<Specialization>(It.Is<Specialization>(
s => s.Id == id && s.ExpiredDate == expiredDate)));
uowMock.Verify(uow => uow.Save());
}
private void Setup()
{
string DocPath = System.Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);
string Destination = String.Concat(DocPath, @"\", this.DestinationFolder);
if(!Directory.Exists(Destination))
{
Directory.CreateDirectory(Destination);
}
this.DestinationFolder = Destination;
/*Application Exit event*/
Application.ApplicationExit += new EventHandler(this.OnApplicationExit);
/*SpotifyRecorder instance*/
SpotifyRecorder = new SpotifyRecorder(this.DestinationFolder, this.TXT_Display, null, this.PBOX_Cover);
/*Get recording device*/
WaveInCapabilities recDevice = SpotifyRecorder.GetRecordingDevice();
label_recdevice.Text = recDevice.ProductName;
/*WebHook*/
WebHook = new CaptainHook();
/*Specialization*/
this.Specialization = Specialization.NOTHING;
}
/// <summary>
/// Executes the stealth ability
/// </summary>
/// <param name="spec"></param>
/// <param name="player"></param>
public void Execute(Specialization spec, GamePlayer player)
{
// Can't stealth while in combat
if(player.InCombat && !player.IsStealthed && player.Client.Account.PrivLevel == (int)ePrivLevel.Player)
{
player.Out.SendMessage(LanguageMgr.GetTranslation(player.Client.Account.Language, "Skill.Ability.Stealth.CannotUseInCombat"), eChatType.CT_System, eChatLoc.CL_SystemWindow);
return;
}
long stealthChangeTick = player.TempProperties.getProperty<long>(GamePlayer.STEALTH_CHANGE_TICK);
long changeTime = player.CurrentRegion.Time - stealthChangeTick;
if(changeTime < 2000)
{
player.Out.SendMessage(LanguageMgr.GetTranslation(player.Client.Account.Language, "Skill.Ability.Stealth.CannotUseStealthChangeTick", ((2000 - changeTime) / 1000).ToString()), eChatType.CT_System, eChatLoc.CL_SystemWindow);
return;
}
player.TempProperties.setProperty(GamePlayer.STEALTH_CHANGE_TICK, player.CurrentRegion.Time);
if (!player.IsStealthed)
{
// Dead can't stealth
if(!player.IsAlive)
{
player.Out.SendMessage(LanguageMgr.GetTranslation(player.Client.Account.Language, "Skill.Ability.Stealth.CannotUseDead"), eChatType.CT_System, eChatLoc.CL_SystemWindow);
return;
}
// Can't stealth if in attack mode
if(player.AttackState || (player.CurrentSpellHandler != null && player.CurrentSpellHandler.IsCasting))
{
player.Out.SendMessage(LanguageMgr.GetTranslation(player.Client.Account.Language, "Skill.Ability.Stealth.CannotUseCombatState"), eChatType.CT_System, eChatLoc.CL_SystemWindow);
return;
}
//TODO: more checks in this order
//"You can't hide with a relic!"
if (player.ConcentrationEffects.GetOfType(typeof (PulsingSpellEffect)) != null)
{
player.Out.SendMessage(LanguageMgr.GetTranslation(player.Client.Account.Language, "Skill.Ability.Stealth.CannotUseActivePulsingSpell"), eChatType.CT_System, eChatLoc.CL_SystemWindow);
return;
}
//HasVanishRealmAbilityActivated -> Allow stealthing, Stop further checks ...
if (player.IsMezzed)
{
player.Out.SendMessage(LanguageMgr.GetTranslation(player.Client.Account.Language, "Skill.Ability.Stealth.CannotUseMezzed"), eChatType.CT_System, eChatLoc.CL_SystemWindow);
return;
}
if (player.IsStunned)
{
player.Out.SendMessage(LanguageMgr.GetTranslation(player.Client.Account.Language, "Skill.Ability.Stealth.CannotUseStunned"), eChatType.CT_System, eChatLoc.CL_SystemWindow);
return;
}
// Check if enemy player is close
foreach (GamePlayer ply in player.GetPlayersInRadius(WorldMgr.VISIBILITY_DISTANCE))
{
if (ply.ObjectState != GameObject.eObjectState.Active) continue;
//Dead players don't prevent stealth!
if (!ply.IsAlive) continue;
//TODO: "True Seeing" realm ability check
//True Seeing denies restealthing for VISIBILITY_DISTANCE!
//There was/is a huge discussion about this on live servers since
//all Assessins found this quite unfair!
//But the discussion has died down since True Seeing etc.
//Friendly players/mobs don't prevent stealth!
if (!GameServer.ServerRules.IsAllowedToAttack(ply, player, true)) continue;
//GM's don't prevent stealth
if (ply.Client.Account.PrivLevel > 1) continue;
//Range check
if (!IsObjectTooClose(ply, player)) continue;
player.Out.SendMessage(LanguageMgr.GetTranslation(player.Client.Account.Language, "Skill.Ability.Stealth.CannotUseToCloseAnEnemy"), eChatType.CT_System, eChatLoc.CL_SystemWindow);
return;
}
// Check if enemy NPC is close
foreach (GameNPC npc in player.GetNPCsInRadius(WorldMgr.VISIBILITY_DISTANCE))
{
if (npc.ObjectState != GameObject.eObjectState.Active) continue;
//Dead npc don't prevent stealth!
if (!npc.IsAlive) continue;
//Friendly players/mobs don't prevent stealth!
if (!GameServer.ServerRules.IsAllowedToAttack(npc, player, true)) continue;
//Range check
if (!IsObjectTooClose(npc, player)) continue;
player.Out.SendMessage(LanguageMgr.GetTranslation(player.Client.Account.Language, "Skill.Ability.Stealth.CannotUseToCloseAnEnemy"), eChatType.CT_System, eChatLoc.CL_SystemWindow);
return;
}
}
//since 1.88 (?), players which stealth, doesn't be followed by mobs [by Suncheck]
//TODO: Some further checks need?
var attackers = new List<GameObject>();
attackers.AddRange(player.Attackers);
foreach (GameLiving attacker in attackers)
{
if (attacker.TargetObject == (GameLiving)player)
{
attacker.TargetObject = null;
if (attacker is GamePlayer)
{
((GamePlayer)attacker).Out.SendChangeTarget(attacker.TargetObject);
}
if (attacker is GameNPC)
{
GameNPC npc = (GameNPC)attacker;
if (npc.Brain is IOldAggressiveBrain)
{
((IOldAggressiveBrain)npc.Brain).RemoveFromAggroList(player);
}
attacker.StopAttack();
}
}
}
player.Stealth(!player.IsStealthed);
}
public void GetSpecializationById_AnyResult_CallsQueryMethodOfRepository()
{
var settingsMock = new Mock<ISettings>();
var componentsMock = new Mock<IComponents>();
var repositoryMock = new Mock<IRepository>();
var uowMock = new Mock<IUnitOfWork>();
var serviceLocatorMock = new Mock<IServiceLocator>();
serviceLocatorMock.Setup(x => x.GetInstance<IRepository>())
.Returns(repositoryMock.Object);
serviceLocatorMock.Setup(x => x.GetInstance<IUnitOfWork>())
.Returns(uowMock.Object);
ServiceLocator.SetLocatorProvider(() => serviceLocatorMock.Object);
// Arrange
Guid id = Guid.NewGuid();
Specialization specialization = new Specialization()
{
Id = id
};
Specialization[] specializations = new Specialization[] {specialization };
repositoryMock.Setup(r => r.Query<Specialization>()).Returns(specializations.AsQueryable());
repositoryMock.Setup(r => r.CreateUnitOfWork()).Returns(uowMock.Object);
// Act
var userService = new UserService(uowMock.Object,repositoryMock.Object, settingsMock.Object, componentsMock.Object);
SpecializationDto actuaSpecializationDto = userService.GetSpecializationById(id);
// Assert
repositoryMock.Verify(repo => repo.Query<Specialization>());
Assert.AreEqual(actuaSpecializationDto.Id, specialization.Id);
}
public void RemoveSpecialization(Specialization specialization)
{
Specializations.Remove(specialization);
foreach (var @group in Groups)
{
if (group.Specialization == specialization)
{
group.Specialization = null;
}
}
}
/// <summary>
/// Проверка на наличие и запись Специализации в базу
/// </summary>
/// <param name="parSpecialization">Специализация</param>
/// <param name="parSpecialty">Специальность</param>
public void CheckExistSpecialization(Specialization parSpecialization, Specialty parSpecialty)
{
// OleDbParameter param;
OleDbCommand commandSelect, commandInsert;
//запрос на выборку, для проверки наличи специализации в базе
if (parSpecialization.CodeSpecialization==string.Empty)
commandSelect = new OleDbCommand(" SELECT * " +
" FROM Специализация WHERE КодСпециализации is NULL AND НазвСпециализации = '"
+ parSpecialization.NameSpecialization + "' AND Спецть = (SELECT IDСпециальности " +
" FROM Специальность WHERE КодСпециальности = '" + parSpecialty.CodeSpecialty + "' AND НазвСпециальности = '" + parSpecialty.NameSpecialty + "')", dbCon);
else
commandSelect = new OleDbCommand(" SELECT * " +
" FROM Специализация WHERE КодСпециализации = '" + parSpecialization.CodeSpecialization + "' AND НазвСпециализации = '"
+ parSpecialization.NameSpecialization + "' AND Спецть = (SELECT IDСпециальности " +
" FROM Специальность WHERE КодСпециальности = '" + parSpecialty.CodeSpecialty + "' AND НазвСпециальности = '" + parSpecialty.NameSpecialty + "')", dbCon);
//запрос на добавление, при отсутствии специализации в базе
/*commandInsert = new OleDbCommand("Insert into Специализация" +
"(КодСпециализации,НазвСпециализации,Спецть)" +
"SELECT @CODESPECIALIZATION,@NAMESPECIALIZATION,IDСпециальности" +
" FROM Специальность WHERE КодСпециальности = '" + parSpecialty.CodeSpecialty + "' AND НазвСпециальности = '" + parSpecialty.NameSpecialty + "'", dbCon);*/
string codespec;
if (parSpecialization.CodeSpecialization == string.Empty) codespec = "NULL";
else codespec = parSpecialization.CodeSpecialization;
commandInsert = new OleDbCommand("Insert into Специализация" +
"(КодСпециализации,НазвСпециализации,Спецть)" +
"SELECT " + codespec + ", '" + parSpecialization.NameSpecialization + "' ,IDСпециальности" +
" FROM Специальность WHERE КодСпециальности = '" + parSpecialty.CodeSpecialty + "' AND НазвСпециальности = '" + parSpecialty.NameSpecialty + "'", dbCon);
/* param = new OleDbParameter();
//код специализации - параметр для запросов
param.ParameterName = "@CODESPECIALIZATION";
if (parSpecialization.CodeSpecialization == "") { param.IsNullable = true; }*/
/* else
//задаем значение параметра
param.Value = parSpecialization.CodeSpecialization;
//задаем тип параметра
param.OleDbType = OleDbType.Char;
//commandInsert.Parameters.Add(param);
commandInsert.Parameters.AddWithValue("@CODESPECIALIZATION", parSpecialization.CodeSpecialization);
param = new OleDbParameter();
//название специализации - параметр для запросов
param.ParameterName = "@NAMESPECIALIZATION";
//задаем значение параметра
param.Value = parSpecialization.NameSpecialization;
//задаем тип параметра
param.OleDbType = OleDbType.Char;
//commandInsert.Parameters.Add(param);
commandInsert.Parameters.AddWithValue("@NAMESPECIALIZATION", parSpecialization.NameSpecialization);*/
//проверка есть ли такая запись в Базе, если нет - то запись её
CheckExistRecord(commandInsert, commandSelect);
}
private void setReadouts(Specialization s)
{
type.Display(s.name);
description.Display(s.description);
cost.Display(s.cost);
CostValue = s.cost;
status.Display(s.unlocked);
sprite.SpriteName = s.icon;
spec = s;
if (spec.unlocked)
{
psb.button.IsEnabled = false;
}
}
public void GetSpecialization()
{
string parString = GetSpecializationName();
string code = Regex.Match(parString, @"\d+").Value;
string name = Regex.Match(parString.Remove(0, code.Length), @"\D+").Value.Trim('\\', '\"', ' ', '\r');
this.specialization = new Specialization(code,name);
}
static int Specialization()
{
Specialization e = new Specialization()
{
DepartmentID = (int)LookUpsValues["DepartmentID"],
SpecializationName = "SpecializationName",
SystemID = (int)LookUpsValues["SystemID"]
};
commonUow.Specializations.Add<Specialization, int>(e);
commonUow.Specializations.Commit();
return e.ID;
}
public void RemoveSpecialization(Specialization specialization)
{
UpdateStatus("Удаление специальности...");
Mouse.OverrideCursor = Cursors.Wait;
_tableController.RemoveSpecialization(specialization);
Mouse.OverrideCursor = Cursors.Arrow;
UpdateStatus("Специальность удалена");
}
/// <summary>
/// Add all spell-lines and other things that are new when this skill is trained
/// FIXME : this should be in database
/// </summary>
/// <param name="player"></param>
/// <param name="skill"></param>
public override void OnSkillTrained(GamePlayer player, Specialization skill)
{
base.OnSkillTrained(player, skill);
switch (skill.KeyName)
{
case Specs.CompositeBow:
if (ServerProperties.Properties.ALLOW_OLD_ARCHERY == true)
{
if (skill.Level < 3)
{
// do nothing
}
else if (skill.Level < 6)
{
player.AddAbility(SkillBase.GetAbility(Abilities.Critical_Shot, 1));
}
else if (skill.Level < 9)
{
player.AddAbility(SkillBase.GetAbility(Abilities.Critical_Shot, 2));
}
else if (skill.Level < 12)
{
player.AddAbility(SkillBase.GetAbility(Abilities.Critical_Shot, 3));
}
else if (skill.Level < 15)
{
player.AddAbility(SkillBase.GetAbility(Abilities.Critical_Shot, 4));
}
else if (skill.Level < 18)
{
player.AddAbility(SkillBase.GetAbility(Abilities.Critical_Shot, 5));
}
else if (skill.Level < 21)
{
player.AddAbility(SkillBase.GetAbility(Abilities.Critical_Shot, 6));
}
else if (skill.Level < 24)
{
player.AddAbility(SkillBase.GetAbility(Abilities.Critical_Shot, 7));
}
else if (skill.Level < 27)
{
player.AddAbility(SkillBase.GetAbility(Abilities.Critical_Shot, 8));
}
else if (skill.Level >= 27)
{
player.AddAbility(SkillBase.GetAbility(Abilities.Critical_Shot, 9));
}
if (skill.Level >= 45)
{
player.AddAbility(SkillBase.GetAbility(Abilities.RapidFire, 2));
}
else if (skill.Level >= 35)
{
player.AddAbility(SkillBase.GetAbility(Abilities.RapidFire, 1));
}
if (skill.Level >= 45)
{
player.AddAbility(SkillBase.GetAbility(Abilities.SureShot));
}
if (skill.Level >= 50)
{
player.AddAbility(SkillBase.GetAbility(Abilities.PenetratingArrow, 3));
}
else if (skill.Level >= 40)
{
player.AddAbility(SkillBase.GetAbility(Abilities.PenetratingArrow, 2));
}
else if (skill.Level >= 30)
{
player.AddAbility(SkillBase.GetAbility(Abilities.PenetratingArrow, 1));
}
}
break;
}
}
public void RemoveSpecialization(Specialization specialization)
{
Project.Schedule.RemoveSpecialization(specialization);
UpdateAll();
}
/// <summary>
/// Получение списка учебных планов из БД
/// </summary>
/// <returns>Список учебных планов</returns>
public List<EducationalPlan> GetListEducationalPlans ()
{
List<EducationalPlan> listEdPlans = new List<EducationalPlan>();
OleDbDataReader dataReader = null;
OleDbCommand commandSelect = new OleDbCommand("SELECT * FROM УчебныйПлан", dbCon);
try
{
dataReader = commandSelect.ExecuteReader();
}
catch
{
MessageBox.Show("Ошибка, при выполнении запроса на добавление УП", "Внимание!", MessageBoxButtons.OK, MessageBoxIcon.Information);
return null;
}
//вытаскиваем инфу
while (dataReader.Read())
{
try
{
OleDbDataReader localReader = GetReaderRecord(new OleDbCommand("SELECT * FROM УровеньОбразования WHERE КодУрОбр =" + dataReader.GetValue(1), this.dbCon));
string edLevel = localReader.GetValue(1).ToString();
localReader = GetReaderRecord(new OleDbCommand("SELECT * FROM Специализация WHERE (Специализация.IDСпециализации)= " + dataReader.GetValue(3), this.dbCon));
Specialization specialization = new Specialization(null,null);
specialization.CodeSpecialization=localReader.GetValue(1).ToString();
specialization.NameSpecialization=localReader.GetValue(2).ToString();
localReader = GetReaderRecord(new OleDbCommand("SELECT * FROM Специальность WHERE (Специальность.IDСпециальности)= " + dataReader.GetValue(2), this.dbCon));
Specialty specialty = new Specialty(null, null);
specialty.CodeSpecialty=localReader.GetValue(1).ToString();
specialty.NameSpecialty=localReader.GetValue(2).ToString();
int year = GetRecord(new OleDbCommand("SELECT Год FROM Годы WHERE КодГода ="+ dataReader.GetValue(5),this.dbCon));
listEdPlans.Add(new EducationalPlan(specialization, specialty, year, edLevel));
listEdPlans[listEdPlans.Count-1].IdInBase = dataReader.GetValue(0).ToString();
}
catch (System.InvalidCastException)
{
//listEdPlans.Add("");
}
}
return listEdPlans;
}
/// <summary>
/// Add all spell-lines and other things that are new when this skill is trained
/// </summary>
/// <param name="player">player to modify</param>
/// <param name="skill">The skill to train</param>
public override void OnSkillTrained(GamePlayer player, Specialization skill)
{
base.OnSkillTrained(player, skill);
switch (skill.KeyName)
{
case Specs.Stealth:
if (skill.Level >= 5) player.AddAbility(SkillBase.GetAbility(Abilities.Distraction));
if (skill.Level >= 8) player.AddAbility(SkillBase.GetAbility(Abilities.DangerSense));
if (skill.Level >= 10) player.AddAbility(SkillBase.GetAbility(Abilities.SafeFall, 1));
if (skill.Level >= 20) player.AddAbility(SkillBase.GetAbility(Abilities.SafeFall, 2));
if (skill.Level >= 25) player.AddAbility(SkillBase.GetAbility(Abilities.Climbing));
if (skill.Level >= 30) player.AddAbility(SkillBase.GetAbility(Abilities.SafeFall, 3));
if (skill.Level >= 40) player.AddAbility(SkillBase.GetAbility(Abilities.SafeFall, 4));
if (skill.Level >= 50) player.AddAbility(SkillBase.GetAbility(Abilities.SafeFall, 5));
break;
}
}
public SpecializationCardViewModel(Specialization specialization)
{
Specialization = specialization;
}
public GameObject spawnEffect(Vector2 position, Specialization s)
{
GameObject effect;
if (s is AS_Wormhole)
{
effect = TrashMan.spawn("WormholeEffect", position, new Quaternion(0,0,0,0));
TrashMan.despawnAfterDelay(effect, 3f);
return effect;
}
if (s is AS_EMPburst)
{
effect = TrashMan.spawn("EMPBurstEffect", position, new Quaternion(0, 0, 0, 0));
TrashMan.despawnAfterDelay(effect, 3f);
return effect;
}
if (s is AS_CosmicStorm)
{
effect = TrashMan.spawn("CosmicstormEffect", position, new Quaternion(0, 0, 0, 0));
TrashMan.despawnAfterDelay(effect, AS_CosmicStorm.duration);
return effect;
}
if (s is AS_Singularity)
{
effect = TrashMan.spawn("SingularityEffect", position, new Quaternion(0, 0, 0, 0));
TrashMan.despawnAfterDelay(effect, AS_Singularity.duration);
return effect;
}
if (s is AS_AIHacking)
{
effect = TrashMan.spawn("SabotageEffect", position, new Quaternion(0, 0, 0, 0));
TrashMan.despawnAfterDelay(effect, 3);
return effect;
}
return null;
}
public void AddGroup(Specialization spec)
{
UpdateStatus("Создание новой группы...");
Mouse.OverrideCursor = Cursors.Wait;
_tableController.AddGroup(Project.ActiveYearOfStudy, spec);
Mouse.OverrideCursor = Cursors.Arrow;
UpdateStatus("Новая группа создана");
}
private static void LoadSpecializations(Schedule schedule, SQLiteCommand command)
{
command.CommandText = "select * from specializations";
var reader = command.ExecuteReader();
while (reader.Read())
{
var specialization = new Specialization {Name = (string) reader["name"]};
schedule.Specializations.Add(specialization);
}
reader.Close();
}
public decimal GetCustomerPrice(Specialization specialization, BookingType type)
{
decimal rate;
try
{
switch (type)
{
case BookingType.TalkNow:
rate = GetCustomerRate(specialization.TalkNowRate, specialization.GST);
break;
case BookingType.ASAP:
rate = GetCustomerRate(specialization.StandardRate, specialization.GST);
break;
case BookingType.StandardHour:
rate = GetCustomerRate(specialization.StandardRate, specialization.GST);
break;
case BookingType.OutOfHour:
rate = GetCustomerRate(specialization.OutOfHourRate, specialization.GST);
break;
default:
rate = 0;
break;
}
return rate;
}
catch (Exception e)
{
Log.Error(e.Message, e);
throw new ArgumentException(e.Message);
}
}
