public RecordExtractToDocumentResponse ExtractRecordToDocument(LogController controller, Lookup lookup,
Section section, DetailLevel relatedDetail)
{
var request = new RecordExtractToDocumentRequest(lookup, section, controller, relatedDetail);
var response = ExtractRecordToDocument(request);
return(response);
}
private RecordExtractToDocumentResponse ExtractRecordToDocument(RecordExtractToDocumentRequest request)
{
var container = new RecordExtractContainer(request);
var recordToExtract = ExtractMainRecord(container);
var hasRelatedRecordOutput = false;
ContentBookmark bookmark = null;
try
{
var relatedTypes = GetRelatedTypes(container);
foreach (var relatedType in relatedTypes.OrderBy(r => Service.GetDisplayName(r)))
{
var recordType = relatedType;
try
{
var recordsToOutput = new Dictionary <string, IRecord>();
GetOneToManyRelated(container, relatedType, recordsToOutput);
GetManyToManyRelated(container, relatedType, recordsToOutput);
GetActivityPartyRelated(container, relatedType, recordsToOutput);
hasRelatedRecordOutput = AppendRelatedToDocument(recordsToOutput, hasRelatedRecordOutput,
container, recordType, ref bookmark, request);
}
catch (Exception ex)
{
container.Response.AddResponseItem(new RecordExtractResponseItem(
"Error Loading Related Records",
recordType, ex));
}
}
}
catch (Exception ex)
{
container.Response.AddResponseItem(new RecordExtractResponseItem("Error Loading Relationships",
recordToExtract.Type, ex));
}
return(container.Response);
}
public override void ExecuteExtention(RecordExtractRequest request, RecordExtractResponse response,
ServiceRequestController controller)
{
var document = DocumentWriter.NewDocument();
var firstSection = document.AddSection();
var nextSection = document.AddSection();
var extractToDocumentRequest = new RecordExtractToDocumentRequest(request.RecordLookup, nextSection,
controller.Controller, request.DetailOfRelatedRecords
, request.RecordTypesOnlyDisplayName.Where(r => r.RecordType != null).Select(r => r.RecordType.Key).ToArray()
, request.FieldsToExclude, request.RecordTypesToExclude.Where(r => r.RecordType != null).Select(r => r.RecordType.Key).ToArray()
, request.IncludeCreatedByAndOn, request.IncludeModifiedByAndOn, request.IncludeCrmOwner, request.IncludeState, request.IncludeStatus, request.StripHtmlTags, request.CustomHtmlFields);
var extractResponse = ExtractRecordToDocument(extractToDocumentRequest);
response.AddResponseItems(extractResponse.ResponseItems);
//insert title/summary
firstSection.AddTitle("Record Extract");
var table = firstSection.Add2ColumnTable();
table.AddFieldToTable("Execution Time", DateTime.Now.ToString(StringFormats.DateTimeFormat));
table.AddFieldToTable("Record Type", Service.GetDisplayName(request.RecordLookup.RecordType));
table.AddFieldToTable("Record Name",
extractResponse.Record.GetStringField(Service.GetPrimaryField(request.RecordLookup.RecordType)));
firstSection.AddTableOfContents(extractResponse.Bookmarks);
//save document
controller.UpdateProgress(1, 2, "Creating Document");
var folder = request.SaveToFolder;
var recordToExtractname =
extractResponse.Record.GetStringField(Service.GetPrimaryField(request.RecordLookup.RecordType));
var fileName = string.Format("Record Extract - {0} - {1}", recordToExtractname,
DateTime.Now.ToString("yyyyMMddHHmmss"));
fileName = document.Save(folder, fileName, request.DocumentFormat);
response.Folder = request.SaveToFolder.FolderPath;
response.FileName = fileName;
response.Message = "The Document Has Been Generated";
}
private bool IsHtmlField(string recordType, string fieldName, RecordExtractToDocumentRequest request)
{
var fields = ExtractUtility.GetSystemHtmlFields().Union(request.CustomHtmlFields ?? new RecordFieldSetting[0]);
return(fields.Any(f => f.RecordType.Key == recordType && f.RecordField.Key == fieldName));
}
private void WriteRecordToSection(IRecord record, Section section, DetailLevel detailLevel, RecordExtractToDocumentRequest request)
{
if (detailLevel == DetailLevel.CountsOnly)
{
return;
}
var primaryField = Service.GetPrimaryField(record.Type);
var recordName = Service.GetFieldAsDisplayString(record, primaryField);
var table = section.Add2ColumnTable();
table.AddFieldToTable(Service.GetFieldLabel(primaryField, record.Type),
ExtractUtility.CheckStripFormatting(recordName, record.Type, primaryField));
if (detailLevel == DetailLevel.Names || request.OnlyDisplayName(record.Type))
{
return;
}
var fields = Service.GetFields(record.Type).Intersect(record.GetFieldsInEntity()).ToArray();
if (fields.Any())
{
var primaryKey = Service.GetPrimaryKey(record.Type);
var actualFieldsToExclude = new List <string> {
primaryField, primaryKey
};
actualFieldsToExclude.AddRange(request.GetAllFieldsToExclude(record.Type));
foreach (var field in fields)
{
var fieldType = Service.GetFieldType(field, record.Type);
if (fieldType == RecordFieldType.Uniqueidentifier)
{
actualFieldsToExclude.Add(field);
}
else if (Service.GetFieldType(field, record.Type) == RecordFieldType.String &&
new[] { TextFormat.PhoneticGuide, TextFormat.VersionNumber }.Contains(
Service.GetFieldMetadata(field, record.Type).TextFormat))
{
actualFieldsToExclude.Add(field);
}
if (field.EndsWith("_base") && fields.Contains(field.Left(field.Length - 5)))
{
actualFieldsToExclude.Add(field);
}
}
var orderedFieldsToDisplay = fields
.Where(f => !actualFieldsToExclude.Contains(f))
.OrderBy(f => Service.GetFieldLabel(f, record.Type));
foreach (var field in orderedFieldsToDisplay)
{
var label = Service.GetFieldLabel(field, record.Type);
var display = Service.GetFieldAsDisplayString(record, field);
if (request.StripHtmlTags && IsHtmlField(record.Type, field, request))
{
display = display.StripHtml();
}
if (!label.IsNullOrWhiteSpace() && !display.IsNullOrWhiteSpace() &&
!GetStringValuesToExclude().Contains(display))
{
table.AddFieldToTable(label, display);
}
}
}
}
private bool AppendRelatedToDocument(Dictionary <string, IRecord> recordsToOutput, bool hasRelatedRecordOutput,
RecordExtractContainer container, string recordType, ref ContentBookmark bookmark, RecordExtractToDocumentRequest request)
{
if (recordsToOutput.Any())
{
var outputNumbers = recordsToOutput.Count > 1 && container.Request.RelatedDetail == DetailLevel.AllFields;
recordsToOutput.Values.PopulateEmptyLookups(Service, GetRecordTypesToExclude());
var recordTypeCollectionLabel = Service.GetCollectionName(recordType);
var recordTypeLabel = Service.GetDisplayName(recordType);
if (!hasRelatedRecordOutput)
{
hasRelatedRecordOutput = true;
bookmark = container.Section.AddHeading2WithBookmark("Related Records");
container.AddBookmark(bookmark);
}
var todoDone = 0;
var todoCount = recordsToOutput.Count;
var thisBookmark =
container.Section.AddHeading3WithBookmark(string.Format("{0} ({1})", recordTypeCollectionLabel, recordsToOutput.Count));
bookmark.AddChildBookmark(thisBookmark);
var i = 1;
foreach (var match in recordsToOutput.Values)
{
if (outputNumbers)
{
container.Section.AddParagraph(string.Format("{0} {1}", recordTypeLabel, i++), true);
}
container.Controller.UpdateProgress(todoDone++, todoCount,
string.Format("Appending Related {0} To Document", recordTypeCollectionLabel));
WriteRecordToSection(match, container.Section, container.Request.RelatedDetail, request);
}
}
return(hasRelatedRecordOutput);
}
public RecordExtractContainer(RecordExtractToDocumentRequest request)
{
Request = request;
Response = new RecordExtractToDocumentResponse();
}
