public async Task <GetResponse <IRuleGrammarTerminal> > GetAsync(int id)
{
var getResponse = new GetResponse <IRuleGrammarTerminal>();
try
{
getResponse = await _ruleGrammarTerminalRepository.GetByIdAsync(id);
}
catch (Exception ex)
{
Console.WriteLine(ex);
getResponse.AddError(ex);
_logManager.LogError(ex, "Error retrieving ruleGrammarTerminal");
}
return(getResponse);
}
public async Task <GetResponse <ISystemInfo> > GetAsync()
{
var getResponse = new GetResponse <ISystemInfo>();
try
{
getResponse = await _systemInfoRepository.GetAsync();
}
catch (Exception ex)
{
Console.WriteLine(ex);
getResponse.AddError(ex);
_logManager.LogError(ex, "Error retrieving systemInfo");
}
return(getResponse);
}
public async Task <GetResponse <IWpdConfig> > GetAsync(int id)
{
var getResponse = new GetResponse <IWpdConfig>();
try
{
getResponse = await _wpdConfigRepository.GetByIdAsync(id);
}
catch (Exception ex)
{
Console.WriteLine(ex);
getResponse.AddError(ex);
_logManager.LogError(ex, "Error retrieving wpdConfig");
}
return(getResponse);
}
public async Task <GetResponse <IReadOnlyList <IAddress> > > GetAllAsync(int entityId)
{
var getResponse = new GetResponse <IReadOnlyList <IAddress> >();
try
{
getResponse = await _addressRepository.GetAllAsync(entityId);
}
catch (Exception ex)
{
Console.WriteLine(ex);
getResponse.AddError(ex);
_logManager.LogError(ex, "Error retrieving addresss");
}
return(getResponse);
}
public async Task <GetResponse <IReadOnlyList <IPayrollLimit> > > GetAllAsync(PayrollLimitRequest request)
{
var getResponse = new GetResponse <IReadOnlyList <IPayrollLimit> >();
try
{
getResponse = await _payrollLimitRepository.GetAllAsync(request);
}
catch (Exception ex)
{
Console.WriteLine(ex);
getResponse.AddError(ex);
_logManager.LogError(ex, "Error retrieving payrollLimits");
}
return(getResponse);
}
public async Task <GetResponse <IReadOnlyList <ISupportActivityData> > > GetSupportActivityReportDataAsync(int carrierId, int userId)
{
var getResponse = new GetResponse <IReadOnlyList <ISupportActivityData> >();
try
{
getResponse = await _reportRepository.GetSupportActivityReportDataAsync(carrierId, userId);
}
catch (Exception ex)
{
Console.WriteLine(ex);
getResponse.AddError(ex);
_logManager.LogError(ex, "Error retrieving data for the Support Activity Report");
}
return(getResponse);
}
public GetResponse <MemoryStream> MergeDocumentToShare(int clientId, DocumentTypes documentType, IList <MergeDocumentValue> values, string shareFolder)
{
var response = new GetResponse <MemoryStream>();
try
{
var repositoryResponse = _documentRepository.GetByTypeAsync(clientId, documentType).Result;
if (repositoryResponse.IsSuccessful)
{
var mergeDocument = repositoryResponse.Content;
// Create a share and get the link to merge
var shareReponse = _fileShareProvider.CreateShareFolderLink(shareFolder, "Share Audit Folder");
if (shareReponse.IsSuccessful)
{
values.Add(new MergeDocumentValue {
Key = "ShareFileLink", Value = shareReponse.Content, Type = MergeDocumentFieldTypes.Hyperlink
});
}
var fieldValues = values
.ToDictionary(value => value.Key, value =>
new MergeDocumentField {
Value = value.Value, FieldType = value.Type
});
using (var ms = new MemoryStream(mergeDocument.Data))
{
var providerResponse = _documentProvider.MergeDocumentAsync(ms, fieldValues).Result;
if (providerResponse.IsSuccessful)
{
response.Content = providerResponse.Content;
}
}
}
}
catch (Exception e)
{
_logManager.LogError(e, "DocumentApplicationService.GenerateDocumentToShare");
response.AddError(e);
}
return(response);
}
public async Task <GetResponse <IRuleSet> > GetByNameAsync(string name)
{
var getResponse = new GetResponse <IRuleSet>();
try
{
getResponse = await _ruleSetRepository.GetByNameAsync(name);
}
catch (Exception ex)
{
Console.WriteLine(ex);
getResponse.AddError(ex);
_logManager.LogError(ex, "Error retrieving ruleSet");
}
return(getResponse);
}
public async Task <GetResponse <IReadOnlyList <IClient> > > GetAllAsync()
{
var getResponse = new GetResponse <IReadOnlyList <IClient> >();
try
{
getResponse = await _clientRepository.GetAllAsync();
}
catch (Exception ex)
{
Console.WriteLine(ex);
getResponse.AddError(ex);
_logManager.LogError(ex, "Error retrieving clients");
}
return(getResponse);
}
public async Task <GetResponse <IList <IDocumentHistory> > > GetDocumentHistoryAsync(DocumentHistoryRequest request)
{
var response = new GetResponse <IList <IDocumentHistory> >();
try
{
using (var connection = ConnectionFactory.GetConnection())
{
var conditions = new List <string>();
if (request.PeriodStart.HasValue)
{
conditions.Add($@"CreatedOn BETWEEN {request.PeriodStart:d} AND {request.PeriodEnd:d};");
}
if (request.AuditId > 0)
{
conditions.Add($@"AuditId = {request.AuditId}");
}
var condition = string.Join(" AND ", conditions);
var sql = string.IsNullOrEmpty(condition)
? $@"{GetDocumentHistorySelectStatement()}"
: $@"{GetDocumentHistorySelectStatement()} AND {condition};";
var results = await connection.QueryAsync <DocumentHistoryDto>(sql);
response.Content = results
.Select(d => d.ToModel())
.AsList();
}
}
catch (Exception e)
{
var message = $@"Unable to retrieve document records for request: {request}";
response.AddError(e);
LogManager.LogError(e, message);
Console.WriteLine(e);
}
return(response);
}
public override async Task <GetResponse <IReadOnlyList <IClient> > > GetAllAsync()
{
var response = new GetResponse <IReadOnlyList <IClient> >();
try
{
using (var connection = ConnectionFactory.GetConnection())
{
var sql = $@"{GetSelectStatement()};
{GetSettingsSelectStatement()}";
var results = await connection.QueryMultipleAsync(sql);
var clients = results.Read <CarriersDto>()
.Select(dto => dto.ToModel())
.AsList();
var clientSettings = results.Read <CarrierSettingsDto>()
.GroupBy(g => g.CarrierID)
.ToDictionary(x => x.Key, x => x.First().ToModel(_auditConfiguration));
foreach (var client in clients)
{
if (clientSettings.ContainsKey(client.Id))
{
client.Settings = clientSettings[client.Id];
}
}
response.Content = clients;
}
}
catch (Exception e)
{
var messaage = $@"Unable to retrieve Client records.";
response.AddError(e);
LogManager.LogError(e, messaage);
Console.WriteLine(e);
}
return(response);
}
public override async Task <GetResponse <IClient> > GetByIdAsync(int id)
{
var response = new GetResponse <IClient>();
try
{
using (var connection = ConnectionFactory.GetConnection())
{
var sql = $@"{GetSelectStatement()}
WHERE CarrierId = @id;
{GetSettingsSelectStatement()}
WHERE s.CarrierId = @id;";
var result = await connection.QueryMultipleAsync(sql, new { Id = id });
var client = result.Read <CarriersDto>()
.Select(dto => dto.ToModel())
.FirstOrDefault();
var clientSettings = result.Read <CarrierSettingsDto>()
.Select(dto => dto.ToModel(_auditConfiguration))
.FirstOrDefault();
if (client != null)
{
client.Settings = clientSettings;
}
response.Content = client;
}
}
catch (Exception e)
{
var message = $@"Unable to retrieve the audit with Id:{id}.";
response.AddError(e);
LogManager.LogError(e, message);
Console.WriteLine(e);
}
return(response);
}
public async Task <GetResponse <ICertificateOfInsurance> > GetForLaborAsync(int laborId)
{
var response = new GetResponse <ICertificateOfInsurance>();
try
{
using (var connection = ConnectionFactory.GetConnection())
{
var sql = $@"{GetSelectStatement()} AND LaborId = @laborId";
var results = await connection.QueryAsync <CertificateOfInsuranceDto>(sql, new { LaborId = laborId });
var dto = results.FirstOrDefault();
if (dto != null)
{
var certificate = dto.ToModel();
if (dto?.UploadedFileId != null)
{
var fileResult = await _auditUploadRepository.GetByIdAsync(dto.UploadedFileId.Value);
if (fileResult.IsSuccessful)
{
certificate.File = fileResult.Content;
}
}
response.Content = certificate;
}
}
}
catch (Exception e)
{
var message = $@"Unable to locate any merge documents.";
response.AddError(e);
LogManager.LogError(e, message);
Console.WriteLine(e);
}
return(response);
}
public async Task <GetResponse <IAuditStep> > GetPage(int auditId, int entityId, WizardPageEnum pageType)
{
var getResponse = new GetResponse <IAuditStep>();
try
{
var stepsResponse = await GetAllAsync(auditId);
if (stepsResponse.IsSuccessful)
{
getResponse.Content = stepsResponse.Content
.FirstOrDefault(s => s.WizardPageType == pageType && s.EntityId == entityId);
}
}
catch (Exception ex)
{
Console.WriteLine(ex);
getResponse.AddError(ex);
_logManager.LogError(ex, "Error retrieving auditStep");
}
return(getResponse);
}
public async Task <GetResponse <IClient> > GetAsync(int id)
{
var getResponse = new GetResponse <IClient>();
try
{
var getClientTask = _clientRepository.GetByIdAsync(id);
var getAddressTask = _addressApplicationService.GetAllAsync(id);
var getContactTask = _contactApplicationService.GetAllAsync(id);
await Task.WhenAll(getAddressTask, getClientTask, getContactTask);
getResponse = getClientTask.Result;
if (getResponse.IsSuccessful)
{
var client = getResponse.Content;
if (getAddressTask.Result.IsSuccessful)
{
var addresses = getAddressTask.Result.Content.ToList();
client.Address = addresses.FirstOrDefault();
}
if (getContactTask.Result.IsSuccessful)
{
client.Contacts = getContactTask.Result.Content.ToList();
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex);
getResponse.AddError(ex);
_logManager.LogError(ex, "Error retrieving client");
}
return(getResponse);
}
public async Task <GetResponse <MemoryStream> > MergeDocumentAsync(int clientId, DocumentTypes documentType, IList <MergeDocumentValue> values)
{
var response = new GetResponse <MemoryStream>();
try
{
var repositoryResponse = await _documentRepository.GetByTypeAsync(clientId, documentType);
if (repositoryResponse.IsSuccessful)
{
var mergeDocument = repositoryResponse.Content;
var fieldValues = values
.ToDictionary(value => value.Key, value =>
new MergeDocumentField {
Value = value.Value, FieldType = value.Type
});
using (var ms = new MemoryStream(mergeDocument.Data))
{
var providerResponse = await _documentProvider.MergeDocumentAsync(ms, fieldValues);
if (providerResponse.IsSuccessful)
{
response.Content = providerResponse.Content;
}
}
}
}
catch (Exception e)
{
_logManager.LogError(e, "DocumentApplicationService.GenerateDocumentAsync");
response.AddError(e);
}
return(response);
}
public GetResponse <IRuleSet> CreateAssembly(IRuleSet ruleSet, bool forTesting = false)
{
var response = new GetResponse <IRuleSet>();
try
{
// 1. Translate the code
ruleSet.Code = _ruleSetTranslator.Translate(ruleSet, forTesting);
// 2. Create the assembly
ruleSet.GeneratedAssembly = _ruleAssemblyService.CreateAssembly(ruleSet);
response.Content = ruleSet;
}
catch (Exception ex)
{
Console.WriteLine(ex);
response.AddError(ex);
_logManager.LogError(ex, "RuleApplicationService.CreateAssembly");
}
return(response);
}
public async Task <GetResponse <IContact> > GetAsync(int id)
{
var getResponse = new GetResponse <IContact>();
try
{
getResponse = await _contactRepository.GetByIdAsync(id);
//if (getResponse.IsSuccessful)
//{
// var addressResponse = await _addressApplicationService.GetAllAsync(id);
// if (addressResponse.IsSuccessful)
// getResponse.Content.Address = addressResponse.Content.FirstOrDefault();
//}
}
catch (Exception ex)
{
Console.WriteLine(ex);
getResponse.AddError(ex);
_logManager.LogError(ex, "Error retrieving contact");
}
return(getResponse);
}
public async Task <GetResponse <IReadOnlyList <ISales> > > GetAllSalesAsync(int auditId, int entityId, int locationId, SalesPeriodType periodType)
{
var getResponse = new GetResponse <IReadOnlyList <ISales> >();
try
{
getResponse = await _salesRepository.GetAllSalesAsync(auditId, entityId, periodType);
if (getResponse.IsSuccessful)
{
getResponse.Content = getResponse.Content
.Where(s => s.LocationId == locationId)
.ToList();
}
}
catch (Exception ex)
{
Console.WriteLine(ex);
getResponse.AddError(ex);
_logManager.LogError(ex, "Error retrieving saless");
}
return(getResponse);
}
public Task <GetResponse <MemoryStream> > MergeDocumentAsync(Stream documentStream, IDictionary <string, MergeDocumentField> values)
{
return(Task.Run(() =>
{
var response = new GetResponse <MemoryStream> {
Content = new MemoryStream()
};
try
{
using (var ms = new MemoryStream())
{
documentStream.CopyTo(ms);
using (var document = WordprocessingDocument.Open(ms, true))
{
// 1. Get the fields to merge
var fields = GetFieldsToMerge(document);
// 2. Set the values
SetValues(values, fields);
// 3. Save new document with merged values
document.MainDocumentPart.Document.Save();
document.Save();
}
ms.Position = 0;
using (var wordGlue = new WebSupergoo.WordGlue.Doc(ms))
{
var tempFileName = Path.GetTempFileName();
var xpsFilename = tempFileName.Replace("tmp", "xps");
File.Move(tempFileName, xpsFilename);
wordGlue.SaveAs(xpsFilename);
using (var pdf = new Doc())
{
//wordGlue.Render(pdf);
pdf.Read(xpsFilename);
if (values.Values.Any(v => v.FieldType == MergeDocumentFieldTypes.Hyperlink))
{
ProcessHyperLink(pdf,
values.Values.Where(v => v.FieldType == MergeDocumentFieldTypes.Hyperlink));
}
pdf.Save(response.Content);
}
File.Delete(xpsFilename);
}
}
}
catch (Exception e)
{
_logManager.LogError(e, "DocumentMergeProvider.MergeDocument");
response.AddError(e);
}
return response;
}));
}
