public async Task DeleteAsync(int id, SubmissionFile model)
{
var modelToDelete = await _context.SubmissionFiles.FirstOrDefaultAsync(u => u.Id == id);
_context.SubmissionFiles.Remove(modelToDelete);
await _context.SaveChangesAsync();
}
public void SubmissionByAccessNumberFile_InvalidName()
{
SECApi api = new SECApi();
IConfiguration config = GetConfiguration();
string cik = config.GetValue(typeof(string), "SEC_CIK_AAPL").ToString();
string accessNum = config.GetValue(typeof(string), "SEC_CIK_AAPL_SUBMISSION_FOLDER_20170701").ToString();
string fileName = "2FA82DB1-8BFF-4363-B947-5A3BC70AA89D.xml";
try
{
SubmissionFile file = api.ArchivesEdgarDataCIKSubmissionFile(cik, accessNum, fileName);
}
catch (WebException ex)
{
if (ex.Status == WebExceptionStatus.ProtocolError &&
ex.Response != null)
{
var resp = (HttpWebResponse)ex.Response;
if (resp.StatusCode != HttpStatusCode.NotFound)
{
Assert.Fail(string.Format("Invalid error code returned - {0}", resp.StatusCode));
}
}
else
{
Assert.Fail(string.Format("Invalid exception returned - {0}", ex.ToString()));
}
}
}
public long EditAcceptenceForReviewer(long fileid, string attr)
{
try
{
using (LMJEntities db = new LMJEntities())
{
SubmissionFile submissionfile = db.SubmissionFiles.Where(e => e.Id == fileid).FirstOrDefault();
if (attr == "isAcceptedforReview")
{
submissionfile.isAcceptedforReview = true;
}
if (attr == "isAcceptedforCopyEditing")
{
submissionfile.isAcceptedforCopyEditing = true;
}
if (attr == "isAcceptedforProduction")
{
submissionfile.isAcceptedforProduction = true;
}
submissionfile.isSubmission = false;
submissionfile.isRevision = false;
submissionfile.isCopyedited = false;
db.SaveChanges();
return(fileid);
}
}
catch (Exception ex)
{
throw;
}
}
public async Task <IActionResult> EditResubFile(int id, [Bind("Id,SubmissionId,JournalFileTypeId,FileName,Description")] SubmissionFile submissionFile, IFormFile myfile)
{
if (id != submissionFile.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
submissionFile.FileName = await UserFile.UploadeNewFileAsync(submissionFile.FileName,
myfile, _environment.WebRootPath, Properties.Resources.Secured);
_context.Update(submissionFile);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!SubmissionFileExists(submissionFile.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction("ResubmissionFiles", "SubmissionFiles", new { /* routeValues, for example: */ sid = submissionFile.SubmissionId }));
}
ViewData["JournalFileTypeId"] = new SelectList(_context.JournalFileTypes, "Id", "Id", submissionFile.JournalFileTypeId);
ViewData["SubmissionId"] = new SelectList(_context.Submissions, "Id", "CoverLetter", submissionFile.SubmissionId);
return(View(submissionFile));
}
public async Task <IActionResult> TechnicalCreate(int sid, [Bind("Id,SubmissionId,JournalFileTypeId,FileName,Description")] SubmissionFile submissionFile, IFormFile myfile)
{
var sub = _context.Submissions.SingleOrDefault(a => a.Id == submissionFile.SubmissionId);
var ManuscriptId = sub.ManuscriptId;
var journalfile = _context.JournalFileTypes.SingleOrDefault(a => a.Id == submissionFile.JournalFileTypeId);
if (ModelState.IsValid)
{
if (submissionFile.Description != null)
{
submissionFile.Description = submissionFile.Description.Replace("\n", "<br/>");
}
if (journalfile.FileTypeId == 4)
{
submissionFile.FileName = await UserFile.UploadeNewFileAsync(submissionFile.FileName,
myfile, _environment.WebRootPath, Properties.Resources.PublicationFiles);
}
else
{
submissionFile.FileName = await UserFile.UploadeNewFileAsync(submissionFile.FileName,
myfile, _environment.WebRootPath, Properties.Resources.Secured);
}
_context.Add(submissionFile);
await _context.SaveChangesAsync();
return(RedirectToAction("TechnicalEditorDetails", "Manuscripts", new { /* routeValues, for example: */ id = ManuscriptId }));
}
ViewData["JournalFileTypeId"] = new SelectList(_context.JournalFileTypes, "Id", "Id", submissionFile.JournalFileTypeId);
ViewData["SubmissionId"] = new SelectList(_context.Submissions, "Id", "CoverLetter", submissionFile.SubmissionId);
return(View(submissionFile));
}
public void SubmissionByAccessNumberFileZip_Success()
{
SECApi api = new SECApi();
string cik = ConfigurationManager.AppSettings["SEC_CIK_AAPL"];
string accessNum = ConfigurationManager.AppSettings["SEC_CIK_AAPL_SUBMISSION_FOLDER"];
string fileName = ConfigurationManager.AppSettings["SEC_CIK_AAPL_10Q_FILE_ZIP"];
SubmissionFile file = api.ArchivesEdgarDataCIKSubmissionFile(cik, accessNum, fileName);
Assert.AreNotEqual(file, null, "Submission is NULL");
Assert.AreEqual(file.Name, fileName, "Invalid file name");
Assert.IsTrue(file.Content.Count > 0, "File content is empty");
}
public void SubmissionByAccessNumberFileZip_Success()
{
SECApi api = new SECApi();
IConfiguration config = GetConfiguration();
string cik = config.GetValue(typeof(string), "SEC_CIK_AAPL").ToString();
string accessNum = config.GetValue(typeof(string), "SEC_CIK_AAPL_SUBMISSION_FOLDER_20170701").ToString();
string fileName = config.GetValue(typeof(string), "SEC_CIK_AAPL_10Q_FILE_ZIP").ToString();
SubmissionFile file = api.ArchivesEdgarDataCIKSubmissionFile(cik, accessNum, fileName);
Assert.AreNotEqual(file, null, "Submission is NULL");
Assert.AreEqual(file.Name, fileName, "Invalid file name");
Assert.IsTrue(file.Content.Count > 0, "File content is empty");
}
public async Task <IActionResult> OnGetAsync(int?id)
{
if (id == null)
{
return(NotFound());
}
SubmissionFile = await _context.SubmissionFiles
.Include(s => s.Owner).FirstOrDefaultAsync(m => m.Id == id);
if (SubmissionFile == null)
{
return(NotFound());
}
return(Page());
}
public void SubmissionByAccessNumberFile_InvalidName()
{
SECApi api = new SECApi();
string cik = ConfigurationManager.AppSettings["SEC_CIK_AAPL"];
string accessNum = ConfigurationManager.AppSettings["SEC_CIK_AAPL_SUBMISSION_FOLDER"];
string fileName = "2FA82DB1-8BFF-4363-B947-5A3BC70AA89D.xml";
try
{
SubmissionFile file = api.ArchivesEdgarDataCIKSubmissionFile(cik, accessNum, fileName);
}
catch (WebServiceException ex)
{
Assert.AreEqual(ex.IsAny400(), string.Format("Invalid error code returned - {0}", ex.ErrorCode));
}
}
public async Task <IActionResult> OnGetAsync(int?id)
{
if (id == null)
{
return(NotFound());
}
SubmissionFile = await _context.SubmissionFiles
.Include(s => s.Owner).FirstOrDefaultAsync(m => m.Id == id);
if (SubmissionFile == null)
{
return(NotFound());
}
ViewData["SubmissionId"] = new SelectList(_context.Submissions, "Id", "Id");
return(Page());
}
public async Task <IActionResult> OnPostAsync(int?id)
{
if (id == null)
{
return(NotFound());
}
SubmissionFile = await _context.SubmissionFiles.FindAsync(id);
if (SubmissionFile != null)
{
_context.SubmissionFiles.Remove(SubmissionFile);
await _context.SaveChangesAsync();
}
return(RedirectToPage("./Index"));
}
private SubmissionFile LoadFromStorage(string regulatorCode, string companyCode, string filingName, string name)
{
SubmissionFile file = null;
if (_storage != null)
{
List <byte> content = new List <byte>();
EErrorCodes loadRes = _storage.Load(regulatorCode, companyCode, filingName, name, content);
if (loadRes == EErrorCodes.Success)
{
file = new SubmissionFile(name);
file.Content = content;
}
}
return(file);
}
public async Task <IActionResult> ResubmissionFiles([Bind("Id,SubmissionId,JournalFileTypeId,FileName,Description")] SubmissionFile submissionFile, IFormFile myfile)
{
if (ModelState.IsValid)
{
submissionFile.Description = submissionFile.Description.Replace("\n", "<br/>");
submissionFile.FileName = await UserFile.UploadeNewFileAsync(submissionFile.FileName,
myfile, _environment.WebRootPath, Properties.Resources.Secured);
_context.Add(submissionFile);
await _context.SaveChangesAsync();
return(RedirectToAction("ResubmissionFiles", "SubmissionFiles", new { /* routeValues, for example: */ sid = submissionFile.SubmissionId }));
}
ViewData["JournalFileTypeId"] = new SelectList(_context.JournalFileTypes, "Id", "Id", submissionFile.JournalFileTypeId);
ViewData["SubmissionId"] = new SelectList(_context.Submissions, "Id", "CoverLetter", submissionFile.SubmissionId);
return(View(submissionFile));
}
public SubmissionFile Get(long submissionId, bool isSubmission, bool isRevision, bool isCopyEdited)
{
try
{
SubmissionFile data = new SubmissionFile();
using (LMJEntities db = new LMJEntities())
{
data = db.SubmissionFiles.Where(e => e.SubmissionId == submissionId &&
e.isRevision == isRevision && e.isSubmission == isSubmission && e.isCopyedited == isCopyEdited &&
e.isDeleted == false).FirstOrDefault();
}
return(data);
}
catch (Exception ex)
{
throw;
}
}
public async Task <ActionResult> Upload(UploadCourseViewModel viewModel)
{
if (!ModelState.IsValid)
{
return(View(viewModel));
}
if (!viewModel.CheckFileExtentions(viewModel.File.FileName))
{
return(View(viewModel));
}
var reader = new BinaryReader(viewModel.File.InputStream);
var data = reader.ReadBytes(viewModel.File.ContentLength);
var path = Server.MapPath("~/uploads/");
if (!Directory.Exists(path))
{
Directory.CreateDirectory(path);
}
viewModel.File.SaveAs(Path.Combine(path, viewModel.File.FileName));
var urlBase = ConfigurationManager.AppSettings["SiteUrlBase"];
var fileUpload = new SubmissionFile
{
FileName = viewModel.File.FileName,
ContentType = viewModel.File.ContentType,
ContentLength = viewModel.File.ContentLength,
ExternalUrl = $"{urlBase}uploads/{viewModel.File.FileName}",
Data = data,
SubmissionId = viewModel.SubmissionId,
CreateDate = DateTime.UtcNow
};
var currentSubmission = await _context.Submissions.FirstOrDefaultAsync(i => i.Id == fileUpload.SubmissionId);
currentSubmission.SubmissionFiles = new List <SubmissionFile>();
currentSubmission.SubmissionFiles.Add(fileUpload);
await _uploadService.AddAsync(fileUpload);
return(RedirectToRoute("SubmissionDetails", new { submissionId = currentSubmission.Id }));
}
public ISourceExtractResult ExtractFilingItems(ISourceExtractFilingItemsParams extractItemsParams)
{
SECSourceExtractResult result = new SECSourceExtractResult();
SECSourceExtractFilingItemsParams extractSECItemsParams = extractItemsParams as SECSourceExtractFilingItemsParams;
if (extractSECItemsParams != null)
{
string cik = _dictionary.LookupRegulatorCompanyCode(extractSECItemsParams.RegulatorCode, extractSECItemsParams.CompanyCode); // TODO: lookup in dictionary
if (!string.IsNullOrEmpty(cik))
{
foreach (var item in extractSECItemsParams.Items)
{
SubmissionFile file = null;
if (!_extractFromStorage)
{
file = _secApi.ArchivesEdgarDataCIKSubmissionFile(cik, extractSECItemsParams.Filing.Name, item.Name);
}
else
{
file = LoadFromStorage(extractSECItemsParams.RegulatorCode, extractSECItemsParams.CompanyCode, extractSECItemsParams.Filing.Name, item.Name);
}
if (file != null)
{
SECSourceItem sourceItem = ToSourceItem(extractItemsParams.RegulatorCode, extractItemsParams.CompanyCode, extractSECItemsParams.Filing.Name, file);
result.Items.Add(sourceItem);
}
}
if (!_extractFromStorage)
{
PutToStorage(result.Items);
}
}
}
return(result);
}
public ISourceSubmissionsInfoResult GetSubmissionsInfo(ISourceSubmissionsInfoParams infoParams)
{
ISourceSubmissionsInfoResult result = new SECSourceSubmissionsInfoResult();
SECSourceSubmissionsInfoParams secInfoParams = infoParams as SECSourceSubmissionsInfoParams;
if (secInfoParams != null)
{
string cik = _dictionary.LookupRegulatorCompanyCode(infoParams.RegulatorCode, infoParams.CompanyCode); // TODO: lookup in dictionary
// for each submission - extracting content and checking type
int count = 0;
foreach (var item in secInfoParams.Items)
{
Submission submission = !_extractFromStorage?
GetSubmissionFromApi(cik, item.Name) :
GetSubmissionFromStorage(infoParams.RegulatorCode, infoParams.CompanyCode, item.Name);
if (submission != null)
{
try
{
// extracting txt index file
SubmissionFileInfo subFileInfo = submission.Files.FirstOrDefault(s => s.Name.Contains("-index.html"));
SubmissionFile indexFile = null;
if (subFileInfo != null)
{
indexFile = !_extractFromStorage?
_secApi.ArchivesEdgarDataCIKSubmissionFile(cik, item.Name, subFileInfo.Name) :
LoadFromStorage(infoParams.RegulatorCode, infoParams.CompanyCode, item.Name, subFileInfo.Name);
}
if (indexFile != null)
{
SECSourceSubmissionInfo submissionInfo = ExtractReportDetailsIndexHTML(indexFile);
if (submissionInfo != null && !string.IsNullOrEmpty(submissionInfo.Type))
{
if (!_extractFromStorage)
{
PutToStorage(infoParams.RegulatorCode, infoParams.CompanyCode, submission.Name, indexFile);
}
submissionInfo.Name = item.Name;
result.Submissions.Add(submissionInfo);
}
}
}
catch (Exception ex)
{
result.AddError(new Error()
{
Code = EErrorCodes.ImporterError, Message = string.Format("Report'{0}', Error: {1}", item.Name, ex.Message)
});
}
}
else
{
result.Errors.Add(new Error()
{
Code = EErrorCodes.SubmissionNotFound, Type = EErrorType.Warning, Message = string.Format("Submission '{0}' was not found", item.Name)
});
}
++count;
}
result.Success = true;
}
else
{
result.Success = false;
result.Errors.Add(new Error()
{
Code = EErrorCodes.InvalidSourceParams, Type = EErrorType.Error, Message = "Invalid parameter provided"
});
}
return(result);
}
private SECSourceItem ToSourceItem(string regulatorCode, string companyCode, string filingName, SubmissionFile file)
{
SECSourceItem result = new SECSourceItem();
result.RegulatorCode = regulatorCode;
result.CompanyCode = companyCode;
result.FilingName = filingName;
result.Name = file.Name;
result.Content = file.Content;
return(result);
}
private void PutToStorage(string regulatorCode, string companyCode, string filingName, SubmissionFile file)
{
List <ISourceItem> items = new List <ISourceItem>();
items.Add(ToSourceItem(regulatorCode, companyCode, filingName, file));
PutToStorage(items);
}
public ISourceExtractResult ExtractReports(ISourceExtractParams extractParams)
{
SECSourceExtractResult result = new SECSourceExtractResult();
SECSourceExtractParams extractSECParams = extractParams as SECSourceExtractParams;
if (extractSECParams != null)
{
string cik = _dictionary.LookupRegulatorCompanyCode(extractSECParams.RegulatorCode, extractSECParams.CompanyCode); // TODO: lookup in dictionary
if (!string.IsNullOrEmpty(cik))
{
foreach (var filing in extractSECParams.Items)
{
// getting list of files for each filing
Submission submission = _secApi.ArchivesEdgarDataCIKSubmission(cik, filing.Name);
if (submission != null)
{
foreach (var fileInfo in submission.Files)
{
// to speed up we need to extract only xml files and index headers file
if (Path.GetExtension(fileInfo.Name) == ".xml" || fileInfo.Name.Contains(".txt"))
{
SubmissionFile file = _secApi.ArchivesEdgarDataCIKSubmissionFile(cik, filing.Name, fileInfo.Name);
if (file != null)
{
SECSourceItem sourceItem = new SECSourceItem();
sourceItem.Name = fileInfo.Name;
sourceItem.FilingName = filing.Name;
sourceItem.CompanyCode = extractSECParams.CompanyCode;
sourceItem.RegulatorCode = extractSECParams.RegulatorCode;
sourceItem.Content = file.Content;
result.Items.Add(sourceItem);
}
}
}
// saving all uploaded items to storage
PutToStorage(result.Items);
}
else
{
result.AddError(EErrorCodes.ImporterError, EErrorType.Warning, string.Format("Failed to import filing {0}", filing.Name));
}
}
result.Success = true;
}
else
{
result.Success = false;
result.AddError(EErrorCodes.InvalidParserParams, EErrorType.Error, string.Format("Cannot find the SEC CIK for company with code {0}", extractSECParams.CompanyCode));
}
}
else
{
result.Success = false;
result.AddError(EErrorCodes.InvalidParserParams, EErrorType.Error, "Parameters of invalid type were provided");
}
return(result);
}
public async Task <ActionResult> Delete(SubmissionFile model)
{
return(RedirectToRoute("UploadIndex"));
}
private SECSourceSubmissionInfo ExtractReportDetailsIndexHTML(SubmissionFile submissionIndexFile)
{
SECSourceSubmissionInfo subInfo = new SECSourceSubmissionInfo();
string txtContent = System.Text.Encoding.Default.GetString(submissionIndexFile.Content.ToArray());
var doc = new HtmlDocument();
doc.LoadHtml(txtContent);
HtmlNode nodeType = doc.DocumentNode.SelectSingleNode("//div[@id='formDiv']/div[@id='formHeader']/div[@id='formName']/strong"); //
if (nodeType != null)
{
if (nodeType.InnerText.Equals("10-Q"))
{
subInfo.Type = "10-Q";
}
else if (nodeType.InnerText.Equals("10-K"))
{
subInfo.Type = "10-K";
}
else if (nodeType.InnerText.Equals("Form 424B2"))
{
subInfo.Type = "424B2";
}
else if (nodeType.InnerText.Equals("Form 4"))
{
subInfo.Type = "4";
}
else if (nodeType.InnerText.Equals("13F-HR"))
{
subInfo.Type = "13F-HR";
}
if (!string.IsNullOrEmpty(subInfo.Type))
{
// extracting dates
var nodesMetadata = doc.DocumentNode.SelectNodes("//div[@id='formDiv']/div/div/div[@class='infoHead']");
if (nodesMetadata != null)
{
foreach (HtmlNode node in nodesMetadata)
{
HtmlNode nodeDate = node.SelectSingleNode("../div[@class='info']");
if (nodeDate != null)
{
if (node.InnerText == "Accepted")
{
subInfo.Submitted = DateTime.Parse(nodeDate.InnerText);
}
else if (node.InnerText == "Period of Report")
{
subInfo.PeriodEnd = DateTime.Parse(nodeDate.InnerText);
}
}
}
}
// extracting report file name
HtmlNode nodeFilingData = doc.DocumentNode.SelectSingleNode("//div[@id='formDiv']/div/table/tr/td[text()='EX-101.INS']/..");
if (nodeFilingData == null)
{
switch (subInfo.Type)
{
case "10-Q":
case "10-K":
nodeFilingData = doc.DocumentNode.SelectSingleNode("//div[@id='formDiv']/div/table/tr/td[text()='XML']/..");
break;
case "4":
{
var fileNodes = doc.DocumentNode.SelectNodes("//div[@id='formDiv']/div/table/tr/td[text()='4']/..");
nodeFilingData = fileNodes.FirstOrDefault(x => x.SelectSingleNode("td/a") != null && x.SelectSingleNode("td/a").InnerText.IndexOf(".xml") >= 0);
}
break;
case "13F-HR":
subInfo.Report.Add("primary_doc.xml");
subInfo.Report.Add("form13fInfoTable.xml");
break;
}
}
if (nodeFilingData != null)
{
HtmlNode nodeFileName = nodeFilingData.SelectSingleNode("td/a");
subInfo.Report.Add(nodeFileName.InnerText.Trim());
}
}
}
return(subInfo);
}
public async Task AddAsync(SubmissionFile model)
{
_context.SubmissionFiles.Add(model);
await _context.SaveChangesAsync();
}
