public void CheckCompanyCreation(ClientCompany input)
{
if (string.IsNullOrEmpty(input.Name) || string.IsNullOrEmpty(input.Description))
{
throw new UserFriendlyException("Info not valid");
}
}
public async Task <ActionResult <ClientCompany> > PostClientCompany(ClientCompany clientCompany)
{
_context.ClientCompanies.Add(clientCompany);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetClientCompany", new { id = clientCompany.ClientId }, clientCompany));
}
public async Task <IActionResult> Edit(int id, [Bind("ClientCompanyID,Address,Name")] ClientCompany clientCompany)
{
if (id != clientCompany.ClientCompanyID)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(clientCompany);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ClientCompanyExists(clientCompany.ClientCompanyID))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction("Index"));
}
return(View(clientCompany));
}
// Write a program to model the bank system by classes and interfaces.
// Identify the classes, interfaces, base classes and abstract actions
// and implement the calculation of the interest functionality through overridden methods.
private static void Main()
{
Client client1 = new ClientIndividual("Neo");
Client client2 = new ClientCompany("Office 1");
Client client3 = new ClientIndividual("Nakov");
Account acc1 = new DepositAccount(client1, 5, "BG13TLRK01");
Account acc2 = new LoanAccount(client2, 4.5m, "BG13TLRK02");
Account acc3 = new MortgageAccount(client3, 8.8m, "BG13TLRK03");
acc1.DepositMoney(1000);
((DepositAccount)acc1).WithdrawMoney(500);
acc2.DepositMoney(10000);
Bank bank = new Bank("New Bank");
bank.AddAccount(acc1);
bank.AddAccount(acc2);
bank.AddAccount(acc3);
Console.WriteLine(bank.Accounts);
Console.WriteLine();
Console.WriteLine("IBAN: {0} ({1}), Interest: {2:F2}", acc1.IBAN, acc1.Owner.Name, acc1.CalculateInterest(5));
Console.WriteLine("IBAN: {0} ({1}), Interest: {2:F2}", acc2.IBAN, acc2.Owner.Name, acc2.CalculateInterest(6));
Console.WriteLine("IBAN: {0} ({1}), Interest: {2:F2}", acc3.IBAN, acc3.Owner.Name, acc3.CalculateInterest(18));
Console.WriteLine("\nRemoving account 1");
bank.RemoveAccount(acc1);
Console.WriteLine(bank.Accounts);
}
public ClientCompanyDto CreateCompanyAndClient(ClientCompanyInput input)
{
var company = ClientCompany.CreateClientCompany(input.CompanyName, input.Description);
_clientsManager.CreateClientCompany(company);
var client = ClientInfo.CreateClientInfo(
//Name
input.Name,
//Last name
input.LastName,
//Address
"No definido",
//Gender
input.Gender,
//Phone
"No definido",
input.BirthDate,
//Obs
"No definido",
company);
_clientsManager.CreateClient(client);
_projectManager.AddClientCompany(input.ProjectId, company.Id);
return(company.MapTo <ClientCompanyDto>());
}
public async Task <IActionResult> PutClientCompany(long id, ClientCompany clientCompany)
{
if (id != clientCompany.ClientId)
{
return(BadRequest());
}
_context.Entry(clientCompany).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ClientCompanyExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public int CreateClientCompany(ClientCompany input)
{
_clientPolicy.CheckCompanyCreation(input);
var id = _clientCompanyRepository.InsertOrUpdateAndGetId(input);
_unitOfWorkManager.Current.SaveChanges();
return(id);
}
public void AddClientCompany(ClientCompany company)
{
_context.ClientCompanies.Add(company);
_context.SaveChanges();
var ctasks = _context.CommonTasks.ToList();
AddClientCompanyTasks(company, ctasks);
}
public async Task <IActionResult> Create([Bind("ClientCompanyID,Address,Name")] ClientCompany clientCompany)
{
if (ModelState.IsValid)
{
_context.Add(clientCompany);
await _context.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(clientCompany));
}
public void AddClientCompany(ClientComanyDto dto)
{
var model = new ClientCompany
{
FkCompanyId = dto.CompanyId,
FkEmployeeId = dto.UserId,
CreatedOn = DateTime.Now
};
_context.ClientCompany.Add(model);
_context.SaveChanges();
}
public HttpResponseMessage NewCompany([FromBody] ClientCompany data)
{
SLW_DatabaseInfo db = new SLW_DatabaseInfo();
try
{
int client_id = db.NewLocalClientCompany(data);
return(Request.CreateResponse(HttpStatusCode.OK, client_id));
}
catch (Exception e)
{
return(Request.CreateResponse(HttpStatusCode.InternalServerError, "something went wrong"));
}
}
//[Authorization]
public ActionResult AddCompany(ClientCompany company)
{
if (!authUser.is_admin)
{
return(NotFound());
}
if (company == null)
{
return(NotFound());
}
company.IsActive = true;
_repo.AddClientCompany(company);
return(Ok());
}
public IActionResult CreateCase()
{
Company c = new Company()
{
TicketSysUrl = "http://58.185.112.2:8550",
TicketSysId = "*****@*****.**",
TicketSysPassword = Utility.ParseEInfo("DevS@b3r", _appSettings.General.SysInfo)
};
ClientCompany cl = new ClientCompany()
{
TicketSysCompanyCode = "124"
};
return(Ok(_caseMgmtService
.CreateCaseAsync(c, cl, $"Issue in test on {DateTime.Now.ToString("dd MMM yyyy")}",
"I have an issue in my system. please HELPPPPP!!!").Result));
}
public void AddClientCompanyTasks(ClientCompany company, List <CommonTask> ctasks)
{
ctasks.ForEach(task =>
{
var newTask = new List <Task>();
if (task.ActiveStartMonth <= 0)
{
task.ActiveStartMonth = 1;
}
if (task.ActiveEndMonth == 0 || task.ActiveEndMonth > 12)
{
task.ActiveEndMonth = 12;
}
if ((task.ActiveEndMonth - task.ActiveStartMonth) < 0)
{
return;
}
List <int> activeMonthes = new List <int>();
for (var activeMonthIndex = task.ActiveStartMonth; activeMonthIndex <= task.ActiveEndMonth; activeMonthIndex++)
{
activeMonthes.Add(activeMonthIndex);
}
if (_context.Tasks.Count(x => x.ClientCompanyId == company.Id && x.CommonTaskId == task.Id && activeMonthes.Contains(x.ActiveMonth) && x.ActiveYear == DateTime.Now.Year) == 0)
{
activeMonthes.ForEach(month =>
{
newTask.Add(new Models.EF_Tables.Task()
{
ClientCompanyId = company.Id, Status = 1, CommonTaskId = task.Id, ActiveMonth = month, ActiveYear = DateTime.Now.Year
});
//_context.Tasks.Add(new Models.EF_Tables.Task() { ClientCompanyId = company.Id, Status = 1, CommonTaskId = task.Id, ActiveMonth = month, ActiveYear = DateTime.Now.Year });
//_context.SaveChanges();
//_context.Tasks.FromSqlInterpolated($"EXECUTE dbo.AddTask {task.Id},{company.Id},{1},{month},{DateTime.Now.Year}").ToList();
});
}
_context.Tasks.AddRange(newTask);
_context.SaveChanges();
});
}
public HttpResponseMessage ApplicantInfo([FromBody] dynamic data)
{
SLW_DatabaseInfo db = new SLW_DatabaseInfo();
ClientCompany clientCompany = null;
KeyDetail keyDetail = db.GetKeyDetail((string)data.access_key);
if (keyDetail.data_present)
{
if (keyDetail.user_type == "company")
{
AssignedCompany company = db.GetAssignedCompany(keyDetail.username);
if (company == null)
{
return(Request.CreateResponse(HttpStatusCode.OK, "empty"));
}
else
{
if (company.source == Commons.Constants.LOCAL_SOURCE)
{
clientCompany = db.GetLocalClientCompany(company.clientId);
}
else
{
clientCompany = db.GetClientDetail(company.clientId);
}
return(Request.CreateResponse(HttpStatusCode.OK, clientCompany));
}
}
else
{
clientCompany = db.GetIndividualDetail(keyDetail.username);
return(Request.CreateResponse(HttpStatusCode.OK, clientCompany));
}
}
else
{
return(Request.CreateResponse(HttpStatusCode.Unauthorized, "unauthorized"));
}
}
private void saveCompanyData()
{
if (txtName.Text != "" &&
txtEmail.Text != "")
{
if (emailIsValid(txtEmail.Text))
{
if (cbTerms.Checked)
{
ClientCompany CodeStompIndustries = new ClientCompany();
CodeStompIndustries.ClientName = txtName.Text.Trim();
CodeStompIndustries.Email = txtEmail.Text.Trim();
using (var context = new UniDBContext())
{
context.ClientCompanys.Add(CodeStompIndustries);
context.SaveChanges();
}
clearText();
MessageBox.Show("Submitted Successfully");
}
else
{
MessageBox.Show("you must agree to the terms and conditions to continue");
}
}
else
{
MessageBox.Show("please enter a valid email");
}
}
else
{
MessageBox.Show("please complete all fields");
}
}
public void CleanupTests()
{
testJob = null;
testCompany = null;
testLocation = null;
}
/// <summary>
/// Used to create a new case in JIRA
/// </summary>
/// <param name="company"></param>
/// <param name="clientCompany"></param>
/// <param name="CaseSubject"></param>
/// <param name="CaseDescription"></param>
/// <returns></returns>
public async Task <CaseDetail> CreateCaseAsync(Company company, ClientCompany clientCompany, string CaseSubject, string CaseDescription)
{
HttpResponseMessage resp = null;
try
{
CaseDetail caseDetail = new CaseDetail();
if (company == null)
{
throw new ArgumentException($"Company details should not be empty", "Company");
}
if (string.IsNullOrWhiteSpace(CaseSubject))
{
throw new ArgumentException($"Please enter correct Case subject", "CaseSubject");
}
var JIRAReq = getJIRARequestObj(company.TicketSysId, Utility.ParseDInfo(company.TicketSysPassword, _appSettings.General.SysInfo));
JIRAReq.Method = HttpMethod.Post;
JIRAReq.RequestUri = new Uri(string.Format(_appSettings.JIRAApiEndpoint.CreateCase, company.TicketSysUrl));
var caseDt = new ServiceDeskRequest()
{
serviceDeskId = clientCompany.TicketSysCompanyCode,
requestTypeId = "1240",
requestFieldValues = new RequestFieldValues()
{
summary = CaseSubject,
description = CaseDescription,
duedate = DateTime.Now.AddDays(7).ToString("yyyy-MM-dd")
},
};
JIRAReq.Content = new StringContent(
JsonConvert.SerializeObject(caseDt),
Encoding.UTF8,
"application/json");
resp = await RestApiHelper.SendAsync(JIRAReq);
resp.EnsureSuccessStatusCode();
var caseInfo = JsonConvert.DeserializeObject <JIRACaseDetail>(await resp.Content.ReadAsStringAsync());
caseDetail = new CaseDetail()
{
CaseID = caseInfo.issueId,
CaseKey = caseInfo.issueKey,
CreatedOn = caseInfo.createdDate.jira,
Status = caseInfo.currentStatus.status,
Subject = caseInfo.requestFieldValues.Where(x => x.fieldId == "summary").FirstOrDefault()?.value.ToString(),
Detail = caseInfo.requestFieldValues.Where(x => x.fieldId == "description").FirstOrDefault()?.value.ToString(),
WebURL = caseInfo.Links.Web
};
return(caseDetail);
}
catch (Exception ex)
{
_logger.Error(ex);
string APIError = "<EMPTY>";
if (resp != null)
{
var error = JsonConvert.DeserializeObject <Error>(await resp.Content.ReadAsStringAsync());
if (error != null)
{
APIError = error.errorMessage;
}
}
throw new Exception($"Error: {ex.Message}. API Error:{APIError}");
}
}
public void EditClientCompany(ClientCompany input)
{
throw new NotImplementedException();
}
private void testDatabase()
{
ClientCompany CodeStompIndustries = new ClientCompany();
CodeStompIndustries.ClientName = "Codestomp Industries";
CodeStompIndustries.Email = "*****@*****.**";
Job CodeStompJob = new Job();
CodeStompJob.MachineDescription = "Rubbish computer";
CodeStompJob.FaultDescription = "It's broken";
CodeStompJob.JobUrgency = 5;
CodeStompJob.MachineComplexity = 5;
Address CodeStompFactoryLocation = new Address();
CodeStompFactoryLocation.HouseNumber = "54";
CodeStompFactoryLocation.Street = "Stupid Street";
CodeStompFactoryLocation.Town = "Newcastle";
CodeStompFactoryLocation.PostCode = "NE11 8FM";
CodeStompJob.FactoryLocation.Add(CodeStompFactoryLocation);
CodeStompIndustries.Jobs.Add(CodeStompJob);
using (var context = new UniDBContext())
{
//Remove everything
//var delquery = from b in context.ClientCompanys
// orderby b.Name
// select b;
//foreach (var item in delquery)
//{
// context.ClientCompanys.Remove(item);
// context.SaveChanges();
//}
context.Database.ExecuteSqlCommand("DELETE FROM [Addresses]");
context.Database.ExecuteSqlCommand("DELETE FROM [Jobs]");
context.Database.ExecuteSqlCommand("DELETE FROM [ClientCompanies]");
context.ClientCompanys.Add(CodeStompIndustries);
context.SaveChanges();
var query = from b in context.ClientCompanys
orderby b.ClientName
select b;
Console.WriteLine("All Jobs in the database:");
foreach (var item in query)
{
Console.WriteLine(item.ClientName);
Console.WriteLine(item.Email);
var queryTwo = from b in item.Jobs
orderby b.JobID
select b;
foreach (var itemTwo in queryTwo)
{
Console.WriteLine(itemTwo.MachineDescription);
Console.WriteLine(itemTwo.FaultDescription);
Console.WriteLine(itemTwo.FactoryLocation);
Console.WriteLine(itemTwo.JobUrgency);
Console.WriteLine(itemTwo.MachineComplexity);
}
}
}
Console.WriteLine("Demo completed.");
//Console.ReadLine();
}
public async Task CreateClientCompanyAsync(ClientCompany company)
{
await context.AddAsync(company);
await context.SaveChangesAsync();
}
public void SetCompany(ClientCompany company)
{
ClientCompany = company;
}
