public async Task <IActionResult> Edit(int id, [Bind("TypeOfWorkId,WorkName,Description,Price")] TypeOfWork typeOfWork)
{
if (id != typeOfWork.TypeOfWorkId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(typeOfWork);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TypeOfWorkExists(typeOfWork.TypeOfWorkId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(typeOfWork));
}
public async Task <IActionResult> PutTypeOfWork(int id, TypeOfWork typeOfWork)
{
if (id != typeOfWork.Id)
{
return(BadRequest());
}
_context.Entry(typeOfWork).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TypeOfWorkExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(Ok());
}
public async Task <ActionResult <TypeOfWork> > PostTypeOfWork(TypeOfWork typeOfWork)
{
_context.TypeOfWorks.Add(typeOfWork);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetTypeOfWork", new { id = typeOfWork.Id }, typeOfWork));
}
/// <summary>
/// Загрузить тип работы
/// </summary>
/// <param name="reader">Считыватель</param>
/// <returns></returns>
private static TypeOfWork LoadTypeOfWork(SqlDataReader reader)
{
TypeOfWork work = new TypeOfWork();
work.WorkID = reader.GetInt32(reader.GetOrdinal("WorkID"));
work.Name = reader.GetString(reader.GetOrdinal("Name"));
return(work);
}
protected override void OnActivityResult(int requestCode, [GeneratedEnum] Result resultCode, Intent data)
{
base.OnActivityResult(requestCode, resultCode, data);
if (resultCode == Result.Ok)
{
var opSystem = data.GetExtra <OpSystem>("OpSystem");
TypeOfWork typeOfWork = (TypeOfWork)data.GetIntExtra("TypeOfWork", (int)TypeOfWork.Add);
UpdateCollection(typeOfWork, opSystem);
}
}
public async Task <IActionResult> Create([Bind("TypeOfWorkId,WorkName,Description,Price")] TypeOfWork typeOfWork)
{
if (ModelState.IsValid)
{
_context.Add(typeOfWork);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(typeOfWork));
}
public void NotifyCollectionChanged(TypeOfWork typeOfWork, OpSystem opSystem)
{
if (typeOfWork == TypeOfWork.Add)
{
dataAdapter.AddItem(opSystem);
}
else if (typeOfWork == TypeOfWork.Edit)
{
dataAdapter.UpdateItem(opSystem);
}
}
public static TypeOfWork Convert(TypeOfWorkDto workDto)
{
if (workDto == null)
{
return(null);
}
TypeOfWork work = new TypeOfWork();
work.WorkID = workDto.WorkID;
work.Name = workDto.Name;
return(work);
}
/// <summary>
/// Добавить тип работы
/// </summary>
/// <param name="work">Тип работы</param>
public void Add(TypeOfWork work)
{
using (var conn = GetConnection())
{
conn.Open();
using (var cmd = conn.CreateCommand())
{
cmd.CommandText = "INSERT INTO TypeOfWork(Name)VALUES(@Name)";
cmd.Parameters.AddWithValue("@Name", work.Name);
cmd.ExecuteNonQuery();
}
}
}
/// <summary>
/// Изменить тип работы
/// </summary>
/// <param name="work">Тип работы</param>
public void Update(TypeOfWork work)
{
using (var conn = GetConnection())
{
conn.Open();
using (var cmd = conn.CreateCommand())
{
cmd.CommandText = "UPDATE TypeOfWork SET Name=@Name WHERE WorkID=@WorkID)";
cmd.Parameters.AddWithValue("@WorkID", work.WorkID);
cmd.Parameters.AddWithValue("@Name", work.Name);
cmd.ExecuteNonQuery();
}
}
}
public static TypeOfWork GetTypeOfWorkFromGrammar(string grammarId)
{
TypeOfWork res = new TypeOfWork();
using (OleDbConnection connection = new OleDbConnection(connectionString))
{
connection.Open();
OleDbCommand query = new OleDbCommand("SELECT Grammar, Description, tw.Type_Work as work_id FROM Grammars g INNER JOIN Type_Work tw ON tw.Type_Work = g.Type_Work WHERE g.Grammar = ?", connection);
OleDbParameter param_grammar = query.CreateParameter();
param_grammar.Value = grammarId;
query.Parameters.Add(param_grammar);
OleDbDataReader reader = query.ExecuteReader();
if (reader.Read())
{
res.Code = reader["work_id"].ToString();
res.Type_description = reader["Description"].ToString();
}
}
return(res);
}
public void GetBudgetPlannerTowHeader_ShouldIncludePreviousFiscalYearName()
{
#region Data Setup
const int planId = 10;
var budgetPlanTypeOfWork = new BudgetPlanTypeOfWork();
budgetPlanTypeOfWork.Id = 10;
budgetPlanTypeOfWork.PreviousFYTypeOfWorkId = 1234;
var listBudgetPlanTypeOfWork = new List <BudgetPlanTypeOfWork>();
listBudgetPlanTypeOfWork.Add(budgetPlanTypeOfWork);
var testQueryableBudgetPlanTypeOfWork = listBudgetPlanTypeOfWork.AsQueryable();
var tow = new TypeOfWork
{
Id = 1234,
Name = "MyTestTOW"
};
var testTOWs = new List <TypeOfWork>();
testTOWs.Add(tow);
var testQueryableTOWs = testTOWs.AsQueryable();
var vmPlannerTowHeader = new PlannerTowHeaderViewModel
{
Id = 10,
PreviousFYTypeOfWorkId = 1234,
PreviousFYTypeOfWorkName = null
};
var testListPlannerTowHeaderViewModel = new List <PlannerTowHeaderViewModel>();
testListPlannerTowHeaderViewModel.Add(vmPlannerTowHeader);
var testQueryableTypeOfWorkCategories = new List <TypeOfWorkCategory>().AsQueryable();
var testQueryableBudgetPlanBudgetTypes = new List <BudgetPlanBudgetType>().AsQueryable();
var testQueryableRatings = new List <Rating>().AsQueryable();
#endregion
#region Mocking
mockBudgetPlanTowService.Setup(x => x.GetBudgetPlannerTowHeader(planId)).Returns(testQueryableBudgetPlanTypeOfWork);
mockBudgetPlanTowService.Setup(x => x.GetTypeOfWorkCategory()).Returns(testQueryableTypeOfWorkCategories);
mockBudgetPlanTowService.Setup(x => x.GetBudgetTypes()).Returns(testQueryableBudgetPlanBudgetTypes);
mockBudgetPlanTowService.Setup(x => x.GetRatings()).Returns(testQueryableRatings);
mockBudgetService.Setup(x => x.GetTOWS()).Returns(testTOWs.AsQueryable());
mockMappingEngine.Setup(x => x.Map <IQueryable <BudgetPlanTypeOfWork>, List <PlannerTowHeaderViewModel> >(It.IsAny <IQueryable <BudgetPlanTypeOfWork> >()))
.Returns(testListPlannerTowHeaderViewModel);
var budgetPlannerTowManager = new BudgetPlannerTowManagerMock(budgetPlanTowService: mockBudgetPlanTowService.Object,
budgetService: mockBudgetService.Object,
mapper: mockMappingEngine.Object);
#endregion
//Act
var vmBudgetPlan = budgetPlannerTowManager.GetBudgetPlannerTowHeader(planId);
//Assert
Assert.IsTrue(vmBudgetPlan.HeaderList.FirstOrDefault().PreviousFYTypeOfWorkName == testTOWs.FirstOrDefault().Name);
}
public static Grammar[] GetAllGrammars_v2()
{
ArrayList grammars = new ArrayList();
using (OleDbConnection connection = new OleDbConnection(connectionString))
{
connection.Open();
OleDbCommand storedProcedure = new OleDbCommand("GetAllGrammars_incomplete", connection);
storedProcedure.CommandType = CommandType.StoredProcedure;
OleDbDataReader reader = storedProcedure.ExecuteReader();
while (reader.Read())
{
//Tengo que crear un autor y un libro de gramatica para irlos rellenando poco a poco.
Author grammarAuthor = new Author();
/**
* En el caso del autor rellenamos todos los campos menos:
* - city_name -> Se puede rellenar luego teniendo la lista con las ciudades
* - county_name -> Se puede rellenar luego teniendo la lista con las provincias
* - country_name -> Se puede rellenar luego teniendo la lista con los paises
*
* - occupations -> Se puede rellenar luego teniendo una lista con todos los oficios de los autores
* */
grammarAuthor.Author_id = Convert.ToInt32(reader["authors.Author_Id"]);
grammarAuthor.Name = reader["author_name"].ToString();
grammarAuthor.Gender = reader["authors.gender_info"].ToString();
grammarAuthor.Country_id = Convert.ToInt32(reader["authors.country_id"]);
grammarAuthor.County_id = Convert.ToInt32(reader["authors.county_id"]);
grammarAuthor.City_id = Convert.ToInt32(reader["authors.city_id"]);
grammarAuthor.Biographical_details = reader["bio"].ToString();
Grammar grammar = new Grammar();
/**
* En el caso del libro de gramática rellenamos todos los campos menos:
* # GrammarImprint
* - city_name -> Se puede rellenar luego teniendo la lista con las ciudades
* - county_name -> Se puede rellenar luego teniendo la lista con las provincias
* - country_name -> Se puede rellenar luego teniendo la lista con los paises
*
* - GrammarReferences -> Se puede rellenar luego teniendo una lista con todas las referencias de los libros
* - GrammarLibraries -> Se puede rellenar luego teniendo una lista con las bibliotecas que tienen los libros
* - GrammarSubsidiaryContents -> Se puede rellenar luego teniendo una lista con los contenidos que tienen los libros
*
* */
grammar.GrammarId = Convert.ToInt32(reader["Grammar"]);
grammar.GrammarPublicationYear = reader["YearP"].ToString();
grammar.GrammarTitle = reader["Title"].ToString();
grammar.GrammarAuthor = grammarAuthor;
grammar.GrammarFirstEdition = Convert.ToInt32(reader["Edition"]);
Imprint grammarImprint = new Imprint();
grammarImprint.Grammar_id = grammar.GrammarId;
grammarImprint.Country_id = Convert.ToInt32(reader["Grammars.country_id"]);
grammarImprint.County_id = Convert.ToInt32(reader["Grammars.county_id"]);
grammarImprint.City_id = Convert.ToInt32(reader["Grammars.city_id"]);
grammarImprint.Printers = reader["Printers"].ToString();
grammarImprint.Booksellers = reader["BookSellers"].ToString();
grammarImprint.Price = reader["Price"].ToString();
grammarImprint.Description = reader["Physical_Description"].ToString();
grammar.GrammarImprint = grammarImprint;
TypeOfWork grammarToW = new TypeOfWork();
grammarToW.Code = reader["Grammars.Type_Work"].ToString();
grammarToW.Type_description = reader["Description"].ToString();
grammar.GrammarTypeOfWork = grammarToW;
GrammarDivision grammarDivision = new GrammarDivision();
grammarDivision.Category_id = Convert.ToInt32(reader["Group"]);
grammarDivision.Category_name = reader["Division"].ToString();
grammar.GrammarDivision = grammarDivision;
TargetAudience grammarAgeAudience = new TargetAudience();
grammarAgeAudience.AudienceCriteria = Convert.ToInt32(reader["age_id"]);
grammarAgeAudience.AudienceName = reader["age_info"].ToString();
TargetAudience grammarGenderAudience = new TargetAudience();
grammarGenderAudience.AudienceCriteria = Convert.ToInt32(reader["gender_id"]);
grammarGenderAudience.AudienceName = reader["audience_genders.gender_info"].ToString();
TargetAudience grammarInstructionAudience = new TargetAudience();
grammarInstructionAudience.AudienceCriteria = Convert.ToInt32(reader["instruction_id"]);
grammarInstructionAudience.AudienceName = reader["instruction_info"].ToString();
TargetAudience grammarPurposeAudience = new TargetAudience();
grammarPurposeAudience.AudienceCriteria = Convert.ToInt32(reader["purpose_id"]);
grammarPurposeAudience.AudienceName = reader["purpose_info"].ToString();
grammar.GrammarTargetAge = grammarAgeAudience;
grammar.GrammarTargetGender = grammarGenderAudience;
grammar.GrammarTargetInstruction = grammarInstructionAudience;
grammar.GrammarTargetSP = grammarPurposeAudience;
grammar.GrammarCommments = reader["Comments"].ToString();
grammars.Add(grammar);
}
}
return((Grammar[])grammars.ToArray(typeof(Grammar)));
}
public Work(IEmployee responsibleEmployee, TypeOfWork job, IValidateModel modelValidator)
{
this.responsibleEmployee = responsibleEmployee;
this.job = job;
this.modelValidator = modelValidator;
}
public OrderPartForClient(IEmployee responsibleEmployee, decimal price, TypeOfWork job) : base(responsibleEmployee, price, job)
{
}
public void UpsertBillingWorkOrderTransactions_ForFY2017()
{
#region Data Setup
WorkOrderTransaction workOrderTransaction1 = new WorkOrderTransaction()
{
TransactionNumber = "11111111",
BillingAmount = 5000,
CreatedBy = 496,
Id = 1,
WorkOrderId = 1,
BeginDate = new DateTime(2017, 5, 19)
};
WorkOrderTransaction workOrderTransactionExist = new WorkOrderTransaction()
{
TransactionNumber = "22222222",
BillingAmount = 3000,
CreatedBy = 496,
Id = 2,
BeginDate = new DateTime(2016, 5, 19)
};
List <WorkOrderTransaction> workOrderTransactionList = new List <WorkOrderTransaction>();
workOrderTransactionList.Add(workOrderTransaction1);
DeliverableGroup testDeliverableGroup = new DeliverableGroup()
{
Code = "VID"//Video
};
Channel testChannel = new Channel()
{
Code = "ROM"//Radio Disney
};
WBSElement wbsElement1 = new WBSElement()
{
Id = 1,
FullWBSNumber = "123456.011.001",
TypeOfWorkId = 1000,
};
WBSElement wbsElement2 = new WBSElement()
{
Id = 2,
FullWBSNumber = "123456.011.002",
TypeOfWorkId = 1001,
};
Deliverable testDeliverable = new Deliverable()
{
Id = 1,
DeliverableTypeId = 94, //Affiliate Marketing
ProducingDepartmentId = 84, //MRM Team
Name = "Radio Disney Video Deliverable",
//ChannelId = 10,//Radio Disney
DeliverableGroupId = 2,//Video
DeliverableGroup = testDeliverableGroup,
Channel = testChannel,
};
DeliverableBudget deliverableBudget1 = new DeliverableBudget()
{
DeliverableId = 1,
Id = 100,
WBSElement = wbsElement1,
MasterVendorId = 418,
Deliverable = testDeliverable,
PHApplyPercent = 40
};
DeliverableBudget deliverableBudget2 = new DeliverableBudget()
{
DeliverableId = 1,
Id = 101,
WBSElement = wbsElement2,
MasterVendorId = 418,
Deliverable = testDeliverable,
};
WorkOrder workOrder = new WorkOrder()
{
WorkOrderNumber = 1122,
Id = 1,
VendorId = 418,
DeliverableId = 1,
Deliverable = testDeliverable
};
TypeOfWork tow = new TypeOfWork()
{
Id = 1,
ChannelId = 1,
FiscalYear = 2016
};
WBSFiscalYear_Channel wBSFiscalYear_Channel = new WBSFiscalYear_Channel()
{
FiscalYear = "2016",
Id = 52,
WBSNumber = "12345",
CreatedBy = 496
};
List <WorkOrder> workOrderList = new List <WorkOrder>();
workOrderList.Add(workOrder);
List <Deliverable> deliverableList = new List <Deliverable>();
deliverableList.Add(testDeliverable);
List <DeliverableBudget> deliverableBudgetList = new List <DeliverableBudget>();
deliverableBudgetList.Add(deliverableBudget1);
tow.DeliverableBudget = deliverableBudgetList;
List <TypeOfWork> towList = new List <TypeOfWork>();
towList.Add(tow);
List <WBSFiscalYear_Channel> wbsFiscalYear_ChannelList = new List <WBSFiscalYear_Channel>();
wbsFiscalYear_ChannelList.Add(wBSFiscalYear_Channel);
//wBSFiscalYear_Channel.TypeOfWork = towList;
List <int> deliverableBudgetIdList = new List <int>();
deliverableBudgetIdList.Add(deliverableBudget1.Id);
Calendar calendar = new Calendar()
{
Id = 1,
CalendarYear = "2016",
FiscalYear = "2017"
};
MRMUser user = new MRMUser()
{
Id = 496,
UserName = "******"
};
#endregion
#region Mocking
mockWorkOrderTransactionRepositry.Setup(i => i.GetSingle(It.IsAny <Expression <Func <WorkOrderTransaction, bool> > >()))
.Returns(workOrderTransactionExist);
mockWorkOrderRepository.Setup(i => i.GetAll()).Returns(workOrderList.AsQueryable());
mockDeliverableRepository.Setup(i => i.GetAll()).Returns(deliverableList.AsQueryable());
mockDeliverableBudgetRepository.Setup(i => i.GetAll()).Returns(deliverableBudgetList.AsQueryable());
mockTypeOfWorkRepository.Setup(i => i.GetAll()).Returns(towList.AsQueryable());
mockDeliverableRepository.Setup(i => i.CreateCrossoverDeliverable(It.IsAny <int>(), It.IsAny <string>(), It.IsAny <int>(), It.IsAny <int>()))
.Returns(deliverableBudgetIdList.AsQueryable());
mockDeliverableBudgetRepository.Setup(i => i.GetByDeliverableBudgetId(It.IsAny <int>()))
.Returns(deliverableBudget1);
mockDeliverableBudgetRepository.Setup(i => i.Update(It.IsAny <DeliverableBudget>()));
mockWorkOrderTransactionRepositry.Setup(i => i.Add(It.IsAny <WorkOrderTransaction>()));
mockWorkOrderTransactionRepositry.Setup(i => i.Update(It.IsAny <WorkOrderTransaction>()));
mockInvoiceLineRepository.Setup(i => i.GetSingle(It.IsAny <Expression <Func <InvoiceLine, bool> > >()))
.Returns(() => null);
mockUnitOfWork.Setup(i => i.Commit());
mockUserRepository.Setup(i => i.GetSingle(It.IsAny <Expression <Func <MRMUser, bool> > >())).Returns(user);
mockCalendarRepository.Setup(i => i.GetSingle(It.IsAny <Expression <Func <Calendar, bool> > >())).Returns(calendar);
mockWBSFiscalYear_ChannelRepository.Setup(i => i.GetAll()).Returns(wbsFiscalYear_ChannelList.AsQueryable());
#endregion
#region Service
var integrationService = new IntegrationServiceMock(workOrderRepository: mockWorkOrderRepository.Object,
iBillingWorkOrderTransactionRepositry: mockWorkOrderTransactionRepositry.Object,
iDeliverableRepository: mockDeliverableRepository.Object, iDeliverableBudgetRepository: mockDeliverableBudgetRepository.Object,
iTypeOfWorkRepository: mockTypeOfWorkRepository.Object, iInvoiceLineRepository: mockInvoiceLineRepository.Object,
unitOfWork: mockUnitOfWork.Object, iUserRepository: mockUserRepository.Object, iCalendarRepository: mockCalendarRepository.Object,
iWBSFiscalYear_ChannelRepository: mockWBSFiscalYear_ChannelRepository.Object);
bool result = integrationService.UpsertBillingWorkOrderTransactions(workOrderTransactionList);
#endregion
#region Asserts
Assert.IsTrue(result == true);
#endregion
}
public WorkEventArgs(string name, TypeOfWork work)
{
Name = name;
Work = work;
}
public void GetBudgetActualDetailss_Test()
{
#region Data
TypeOfWork typeOfWork1 = new TypeOfWork()
{
Id = 88,
FiscalYear = 2016
};
WBSElement wBSElement1 = new WBSElement()
{
Id = 4569,
TypeOfWork = typeOfWork1
};
SAPActualsFileRow sAPActualsFileRow1 = new SAPActualsFileRow()
{
DocumentNumber = "55",
OffsettingAccountNo = "778899",
NameOfOffsettingAccountGKONT_LTXT = "OffSet 1",
CostElement = "CE1",
CostElementDescription = "CE1 + Desc",
};
TypeOfWork typeOfWork2 = new TypeOfWork()
{
Id = 99,
FiscalYear = 2017
};
WBSElement wBSElement2 = new WBSElement()
{
Id = 9657,
TypeOfWork = typeOfWork2
};
SAPActualsFileRow sAPActualsFileRow2 = new SAPActualsFileRow()
{
DocumentNumber = "63",
OffsettingAccountNo = "112233",
NameOfOffsettingAccountGKONT_LTXT = "OffSet 2",
CostElement = "CE2",
CostElementDescription = "CE2 + Desc",
};
ActualsReconciliation actualsReconciliation1 = new ActualsReconciliation()
{
Id = 1,
Name = "Recon 1",
PostingDate = DateTime.Now,
ActualAmount = 1001,
SAPActualsFileRow = sAPActualsFileRow1,
WBSElement = wBSElement1
};
ActualsReconciliation actualsReconciliation2 = new ActualsReconciliation()
{
Id = 2,
Name = "Recon 2",
PostingDate = DateTime.Now,
ActualAmount = 9009,
SAPActualsFileRow = sAPActualsFileRow2,
WBSElement = wBSElement2
};
List <ActualsReconciliation> actualsReconciliationList = new List <ActualsReconciliation>();
actualsReconciliationList.Add(actualsReconciliation1);
actualsReconciliationList.Add(actualsReconciliation2);
#endregion
#region Mock
mockfinanceservice.Setup(x => x.GetActualsByWBS(It.IsAny <int>()))
.Returns(actualsReconciliationList);
mockfinanceservice.Setup(x => x.GetActualsByDeliverableandWBS(It.IsAny <int>(), It.IsAny <int>()))
.Returns(actualsReconciliationList);
//Finance Controller Mock
var FinanceController = new FinanceControllerMock(financeServicee: mockfinanceservice.Object);
#endregion
#region Service
List <BudgetActualsAmountDetailsViewModel> result = FinanceController.GetBudgetActualDetailss(It.IsAny <int>(), It.IsAny <int>(), It.IsAny <int>(), It.IsAny <int>(), It.IsAny <string>());
#endregion
#region Assertions
Assert.IsFalse(result == null);
Assert.IsTrue(result.ElementAt(0).CostElementGLAccount == "CE1");
Assert.IsTrue(result.ElementAt(1).CostElementGLAccount == "CE2");
Assert.IsTrue(result.ElementAt(0).FiscalYear == "2016");
Assert.IsTrue(result.ElementAt(1).FiscalYear == "2017");
Assert.IsTrue(result.ElementAt(0).OffsettingAccountName == "OffSet 1");
Assert.IsTrue(result.ElementAt(1).OffsettingAccountName == "OffSet 2");
Assert.IsTrue(result.ElementAt(0).SAPDocumentNumber == "55");
Assert.IsTrue(result.ElementAt(1).SAPDocumentNumber == "63");
Assert.IsTrue(result.ElementAt(0).OffsettingAccountNumber == "778899");
Assert.IsTrue(result.ElementAt(1).OffsettingAccountNumber == "112233");
#endregion
}
public static int OnDidSomeWorkWithReturn(string nameOfThing, TypeOfWork typeOfThing)
{
Console.WriteLine("Handling delegate invocation.");
return(0);
}
public static void OnDidSomeWork(string nameOfThing, TypeOfWork typeOfThing)
{
Console.WriteLine("Handling delegate invocation." + " Work type: " + typeOfThing);
}
public ResponseIdName(TypeOfWork type)
{
this.Id = type.Id;
this.Name = type.Name;
}
public RegisterForm(TypeOfWork work, NameValueCollection nameValueCollection)
{
InitializeComponent();
try
{
foreach (var strDeviceType in Enum.GetNames(typeof(DeviceType)))
{
cbType.Items.Add(strDeviceType);
}
currWork = work;
switch (work)
{
case TypeOfWork.UpdateDevice:
txtIP.Enabled = false;
txtHostname.Enabled = true;
break;
case TypeOfWork.FromScannedDevice:
txtIP.Enabled = false;
txtHostname.Enabled = false;
break;
}
foreach (var val in nameValueCollection.AllKeys)
{
switch (val)
{
case "RegisteredDevicePK":
RegisteredDevicePK = int.Parse(nameValueCollection["RegisteredDevicePK"]);
break;
case "IP":
txtIP.Text = nameValueCollection["IP"];
break;
case "Name":
txtName.Text = nameValueCollection["Name"];
break;
case "Hostname":
txtHostname.Text = nameValueCollection["Hostname"];
break;
case "Type":
cbType.SelectedItem = nameValueCollection["Type"];
break;
case "Port":
numPort.Value = int.Parse(nameValueCollection["Port"]);
break;
}
}
}
catch (Exception ex)
{
MessageBox.Show("Internal error occur! Check log file");
LoggingHelper.LogEntry(SystemCategories.GeneralError, $"{ex.Message} {ex.StackTrace}");
}
}
public Work(IEmployee responsibleEmployee, TypeOfWork job)
{
this.ResponsibleEmployee = responsibleEmployee;
this.job = job;
}
