public async Task <ActionResult> Upload(string companyName, string vat, string ownerName)
{
if (companyName != null)
{
var inputCity = new CompanyInputModel
{
Name = companyName,
VAT = vat,
Owner = ownerName
};
var companyOutputModel = new CompanyOutputModel
{
Name = await companiesService.UploadCompany(inputCity),
VAT = vat,
Owner = ownerName
};
return(this.View(companyOutputModel));
}
else
{
return(Redirect("Index"));
}
}
public void CreateCompany(CompanyInputModel companyInputModel)
{
var createdCompany = InsertCompany(companyInputModel.CompanyName, companyInputModel.ParentCompanyId);
InsertStock(createdCompany, companyInputModel.StockCode, companyInputModel.BussinessCategoryId);
InsertCompanyProductRelation(companyInputModel.ProductIds, createdCompany);
}
public async Task <string> AddCompanyAsync(CompanyInputModel input)
{
if (this.companiesRepository.All().Any(c => c.Name == input.Name))
{
return(null);
}
var company = new Company
{
Name = input.Name,
TaxNumber = input.TaxNumber,
Address = new CompanyAddress
{
MOLFirstName = input.MOLFirstName,
MOLLastName = input.MOLLastName,
Address = new Address
{
StreetLine = input.StreetLine,
Area = input.Area,
City = input.City,
Postcode = input.Postcode,
State = input.State,
},
},
Comunicators = new Comunicators
{
Mobile1 = input.Mobile1,
Mobile2 = input.Mobile2,
Phone1 = input.Phone1,
Phone2 = input.Phone2,
Email1 = input.Email1,
Email2 = input.Email2,
Details = input.Details,
},
};
var taxCoutry = this.taxCtrRepo.All().FirstOrDefault(c => c.Name == input.TaxCountry);
if (taxCoutry == null)
{
taxCoutry = new TaxCountry {
Name = input.TaxCountry
};
}
company.TaxCountry = taxCoutry;
await this.companiesRepository.AddAsync(company);
company.Address.AdminId = company.AdminId;
company.Address.Address.AdminId = company.AdminId;
company.Comunicators.AdminId = company.AdminId;
company.TaxCountry.AdminId = company.AdminId;
await this.companiesRepository.SaveChangesAsync();
return(company.Id);
}
public Company Add(CompanyInputModel company)
{
return(_companyService.Add(
new Company
{
CompanyName = company.CompanyName,
CompanyAdress = company.CompanyAdress,
ContactName = company.ContactName
}
));
}
public async void AddCompanyTest()
{
using var dbContext = this.GetDbContext();
var service = this.GetContactsService(dbContext);
var company = new CompanyInputModel {
Name = "test"
};
var res = await service.AddCompanyAsync(company);
Assert.NotNull(res);
Assert.True(dbContext.Companies.Any(x => x.Name == company.Name));
}
public async void AddingSameCompanyTwiceShouldReturnNull()
{
using var dbContext = this.GetDbContext();
var service = this.GetContactsService(dbContext);
var company = new CompanyInputModel {
Name = "test"
};
await service.AddCompanyAsync(company);
var res = await service.AddCompanyAsync(company);
Assert.Null(res);
}
public async Task <CompanyOutputModel> AddCompany(CompanyInputModel model, CancellationToken cancellationToken)
{
var existCompany = await companyRepository.Any(e => e.Name.Equals(model.Name), cancellationToken);
if (existCompany)
{
throw new System.Exception("A empresa informada já existe!");
}
var company = mapper.Map <Company>(model);
return(mapper.Map <CompanyOutputModel>(await companyRepository.Add(company, cancellationToken)));
}
public async void Test()
{
using var dbContext = this.GetDbContext();
var service = this.GetContactsService(dbContext);
var company = new CompanyInputModel {
Name = "testC"
};
await service.AddCompanyAsync(company);
var res = await service.DeleteAsync(dbContext.Companies.First().Id);
Assert.True(res);
Assert.Equal(0, dbContext.Companies.Count());
}
public async Task <CompanyInputModel> GetCompanyAsync(string searchStr)
{
var urlSearch = string.Format(BaseUrlSearch, searchStr);
var document = await this.context.OpenAsync(urlSearch);
if (document.StatusCode == System.Net.HttpStatusCode.NotFound ||
document.DocumentElement.OuterHtml.Contains("Няма намерени резултати"))
{
throw new InvalidOperationException("Not found");
}
var company = new CompanyInputModel();
var companyPath = document.QuerySelectorAll("table > tbody > tr > td > a").FirstOrDefault().GetAttribute("href");
var url = string.Format(GlobalConstants.RegistryAgencyUrl, companyPath);
document = await this.context.OpenAsync(url);
var data = new Stack <IElement>(document.All.Where(e => e.ClassList.Any(c => c == "col-sm-3" || c == "col-sm-9")));
var elements = new Dictionary <string, string>();
while (data.Any())
{
var value = data.Pop().TextContent.Trim();
var key = data.Pop().TextContent.Trim();
elements.Add(key, value);
}
var mol = elements["Управители/Съдружници"].Trim();
var address = elements["Седалище адрес"].Split("\n\n")[0]
.Trim()
.Split(", ")
.ToArray();
company.Name = elements["Наименование"];
company.TaxCountry = address[0];
company.StreetLine = string.Join(", ", address.Skip(1));
company.TaxNumber = $"BG{elements["ЕИК/ПИК"]}";
company.Details = elements["Предмет на дейност"].Contains("прочети още") ?
Regex.Match(elements["Предмет на дейност"], @"(?<=\.\.\.\n)(\n|.)+(?=прочети още)").Value.Trim() :
elements["Предмет на дейност"];
// company.Details = elements["Предмет на дейност"].Split("\n", StringSplitOptions.RemoveEmptyEntries)[2]
// .TrimStart();
company.MOLFirstName = Regex.Match(mol, @"(?<=: )([А-Яа-я]+)").Value;
company.MOLLastName = Regex.Match(mol, @"([А-Яа-я]+)(?= \()").Value;
return(company);
}
public async Task <IActionResult> AddCompanyAsync(CompanyInputModel model)
{
if (string.IsNullOrEmpty(model.Name))
{
return(BadRequest(ResponseResult.Failed(ErrorCode.ValidationError, "Company name can't be empty.")));
}
var company = Company.New(model.Name, model.NumOfEmpolyees);
await _companyRepository.AddCompanyAsync(company);
var result = Mapper.Map <CompanyOutputModel>(company);
return(Ok(ResponseResult.SucceededWithData(result)));
}
private CompanyInputModel ConvertCompanyToInputModel(TweetStockAnalyzer.Model.Company company)
{
var companyInputModel = new CompanyInputModel();
companyInputModel.CompanyId = company.CompanyId;
companyInputModel.CompanyName = company.CompanyName;
companyInputModel.ParentCompanyId = company.ParentCompanyId;
if (company.Stock != null)
{
companyInputModel.StockCode = company.Stock.StockCode;
companyInputModel.BussinessCategoryId = company.Stock.BussinessCategoryId;
}
return(companyInputModel);
}
public void UpdateCompany(CompanyInputModel companyInputModel)
{
var targetCompany = _companyRepository.ReadAll()
.Include(c => c.Stock)
.SingleOrDefault(c => c.CompanyId == companyInputModel.CompanyId);
targetCompany.CompanyName = companyInputModel.CompanyName;
targetCompany.ParentCompanyId = companyInputModel.ParentCompanyId;
_companyRepository.Update(targetCompany);
ManipulateStock(targetCompany, companyInputModel.StockCode, companyInputModel.BussinessCategoryId);
ManipulateCompanyProductRelation(targetCompany, companyInputModel.ProductIds);
}
public CompanyServiceTest()
{
//Models
company = new Company("League of Legends");
companyInput = new CompanyInputModel {
Name = "League of Legends"
};
companyOutput = new CompanyOutputModel {
Id = Guid.NewGuid(), Name = "League of Legends"
};
cancellationToken = new CancellationToken();
//Mocks
mockMapper = new Mock <IMapper>();
mockCompanyRepository = new Mock <ICompanyRepository>();
}
public async Task <IActionResult> AddCompanyModal(CompanyInputModel model)
{
if (!this.ModelState.IsValid)
{
return(this.Json(new { isValid = false, redirectToUrl = string.Empty, html = this.View(model) }));
}
var res = await this.contactsService.AddCompanyAsync(model);
if (res == null)
{
this.ModelState.AddModelError(string.Empty, "Company allready exists.");
return(this.Json(new { isValid = false, redirectToUrl = string.Empty, html = this.View(model) }));
}
return(this.Json(new { isValid = true, redirectToUrl = "reload" }));
}
public async Task <IActionResult> AddCompany(CompanyInputModel model)
{
if (!this.ModelState.IsValid)
{
return(this.View(model));
}
var res = await this.contactsService.AddCompanyAsync(model);
if (res == null)
{
this.ModelState.AddModelError(string.Empty, "Company allready exists.");
return(this.View(model));
}
return(this.Redirect(GlobalConstants.Index));
}
public async Task <string> UploadCompany(CompanyInputModel company)
{
if (company.Name != null)
{
var companyModel = new Company
{
Name = company.Name,
VAT = company.VAT,
Owner = company.Owner
};
await this.db.Companies.AddAsync(companyModel);
await this.db.SaveChangesAsync();
return(company.Name);
}
else
{
return("");
}
}
public ActionResult Update(int companyId)
{
using (var repository = _container.Resolve <ICompanyRepository>())
{
var company = repository.Read(companyId);
var model = new CompanyInputModel();
model.CompanyId = companyId;
model.ParentCompanyId = company.ParentCompanyId;
model.CompanyName = company.CompanyName;
if (company.Stock != null && !company.Stock.IsDeleted)
{
model.StockCode = company.Stock.StockCode;
model.BussinessCategoryId = company.Stock.BussinessCategoryId;
}
model.Products = company.Products.ToArray();
return(View(model));
}
}
private Company[] PrepareCompanies()
{
var companyInputModel1 = new CompanyInputModel
{
CompanyName = "TestCompany1",
ProductIds = new[] { _testProduct1.ProductId }
};
_workerService.CreateCompany(companyInputModel1);
var company1 = _companyRepository.ReadAll().First();
var companyInputModel2 = new CompanyInputModel
{
CompanyName = "TestCompany2",
ParentCompanyId = company1.CompanyId,
StockCode = "100",
BussinessCategoryId = _testBussinessCategory.BussinessCategoryId,
ProductIds = new[] { _testProduct1.ProductId }
};
_workerService.CreateCompany(companyInputModel2);
var company2 = _companyRepository.ReadAll().ToArray()[1];
var companyInputModel3 = new CompanyInputModel
{
CompanyName = "TestCompany3",
BussinessCategoryId = _testBussinessCategory.BussinessCategoryId
};
_workerService.CreateCompany(companyInputModel3);
var company3 = _companyRepository.ReadAll().ToArray()[2];
return(_companyRepository.ReadAll()
.Include(c => c.Products)
.ToArray());
}
public IActionResult Save(CompanyInputModel model)
{
this.service.Save(model);
return(this.Ok());
}
public async Task <ActionResult> ImportAsync()
{
IFormFile file = Request.Form.Files[0];
string folderName = "UploadExcel";
string webRootPath = hostEnvironment.WebRootPath;
string newPath = Path.Combine(webRootPath, folderName);
var errorDictionary = new Dictionary <int, string>();
if (!Directory.Exists(newPath))
{
Directory.CreateDirectory(newPath);
}
if (file.Length > 0)
{
string sFileExtension = Path.GetExtension(file.FileName).ToLower();
ISheet sheet;
string fullPath = Path.Combine(newPath, file.FileName);
using (var stream = new FileStream(fullPath, FileMode.Create))
{
file.CopyTo(stream);
stream.Position = 0;
if (sFileExtension == ".xls")
{
HSSFWorkbook hssfwb = new HSSFWorkbook(stream); //This will read the Excel 97-2000 formats
sheet = hssfwb.GetSheetAt(0); //get first sheet from workbook
}
else
{
XSSFWorkbook hssfwb = new XSSFWorkbook(stream); //This will read 2007 Excel format
sheet = hssfwb.GetSheetAt(0); //get first sheet from workbook
}
IRow headerRow = sheet.GetRow(0); //Get Header Row
int cellCount = headerRow.LastCellNum;
for (int j = 0; j < cellCount; j++)
{
ICell cell = headerRow.GetCell(j);
if (cell == null || string.IsNullOrWhiteSpace(cell.ToString()))
{
continue;
}
}
for (int i = (sheet.FirstRowNum + 1); i <= sheet.LastRowNum; i++) //Read Excel File
{
IRow row = sheet.GetRow(i);
if (row == null)
{
continue;
}
if (row.Cells.All(d => d.CellType == CellType.Blank))
{
continue;
}
var newCompany = new CompanyInputModel();
for (int j = row.FirstCellNum; j < cellCount; j++)
{
string currentRow = "";
if (row.GetCell(j) != null)
{
currentRow = row.GetCell(j).ToString().TrimEnd();
}
switch (j)
{
case 0:
if (currentRow != null)
{
newCompany.Name = currentRow;
}
else
{
errorDictionary[i] = currentRow;
}
break;
case 1:
newCompany.VAT = currentRow;
break;
}
}
await this.companiesService.UploadCompany(newCompany);
}
}
}
var errorsCombined = new CustomErrorDictionaryOutputModel
{
Errors = errorDictionary
};
return(this.View(errorsCombined));
}
public async Task <CompanyOutputModel> Post([FromBody] CompanyInputModel model, CancellationToken cancellationToken)
{
var result = await companyService.AddCompany(model, cancellationToken);
return(result);
}
public ActionResult Update(CompanyInputModel companyInputModel)
{
_workerService.UpdateCompany(companyInputModel);
return(RedirectToIndex(string.Format("{0} is updated!", companyInputModel.CompanyName)));
}
