public void RecordField_SetValue_5()
{
bool save = RecordField.TrimValue;
RecordField.TrimValue = true;
try
{
RecordField field = new RecordField(200);
field.SetValue(" Value ");
Assert.AreEqual("Value", field.Value);
}
finally
{
RecordField.TrimValue = save;
}
}
/// <summary>
/// Asserts that the field must not contains subfields.
/// </summary>
protected void MustNotContainSubfields
(
[NotNull] RecordField field
)
{
if (field.SubFields.Count != 0)
{
AddDefect
(
field,
20,
"Поле {0} содержит подполя",
field.Tag
);
}
}
public void RecordField_GetSubFieldValue_1()
{
const string expected1 = "SubfieldA1";
const string expected2 = "SubfieldA2";
RecordField field = new RecordField();
SubField subField1 = new SubField('a', expected1);
field.SubFields.Add(subField1);
SubField subField2 = new SubField('a', expected2);
field.SubFields.Add(subField2);
Assert.AreEqual(expected1, field.GetSubFieldValue('a', 0));
Assert.AreEqual(expected2, field.GetSubFieldValue('a', 1));
Assert.IsNull(field.GetSubFieldValue('a', 2));
Assert.IsNull(field.GetSubFieldValue('b', 0));
}
/// <summary>
/// Decode the field.
/// </summary>
public RecordField DecodeField
(
[NotNull] MstDictionaryEntry32 entry
)
{
string catenated = string.Format
(
"{0}#{1}",
entry.Tag,
entry.Text
);
RecordField result = RecordField.Parse(catenated);
return(result);
}
private void _fixPlaceButton_Click
(
object sender,
EventArgs e
)
{
if (_currentRecord == null ||
_currentExemplar == null)
{
XtraMessageBox.Show
(
"Нечего исправлять!"
);
return;
}
RecordField field = _currentExemplar.Field;
if (field == null)
{
return;
}
field.SetSubField('a', "0");
field.SetSubField('d', CurrentFond);
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
_client.WriteRecord
(
_currentRecord,
false,
true
);
stopwatch.Stop();
_logBox.Output.WriteLine
(
"Исправлено место/статус для номера {0}: {1} ({2})",
_currentExemplar.Number,
_currentRecord.UserData,
stopwatch.Elapsed
);
_SetHtml(string.Empty);
_currentRecord = null;
_currentExemplar = null;
}
public static MarcRecord ParseResponseForAllFormat
(
[NotNull] string line,
[NotNull] MarcRecord record
)
{
Sure.NotNull(record, "record");
if (string.IsNullOrEmpty(line))
{
return(null);
}
try
{
record.Fields.BeginUpdate();
record.Fields.Clear();
string[] split = line.Split('\x1F');
ParseMfnStatusVersion
(
split[1],
split[2],
record
);
for (int i = 3; i < split.Length; i++)
{
line = split[i];
if (!string.IsNullOrEmpty(line))
{
RecordField field = ParseLine(line);
if (field.Tag > 0)
{
record.Fields.Add(field);
}
}
}
}
finally
{
record.Fields.EndUpdate();
record.Modified = false;
}
return(record);
}
public static ExemplarInfo Parse
(
[JetBrains.Annotations.NotNull] RecordField field
)
{
if (ReferenceEquals(field, null))
{
throw new ArgumentNullException("field");
}
ExemplarInfo result = new ExemplarInfo
{
Status = field.GetSubFieldText('a', 0),
Number = field.GetSubFieldText('b', 0),
Date = field.GetSubFieldText('c', 0),
Place = field.GetSubFieldText('d', 0),
Collection = field.GetSubFieldText('q', 0),
ShelfIndex = field.GetSubFieldText('r', 0),
Price = field.GetSubFieldText('e', 0),
Barcode = field.GetSubFieldText('h', 0),
Amount = field.GetSubFieldText('1', 0),
Purpose = field.GetSubFieldText('t', 0),
Coefficient = field.GetSubFieldText('=', 0),
OffBalance = field.GetSubFieldText('4', 0),
KsuNumber1 = field.GetSubFieldText('u', 0),
ActNumber1 = field.GetSubFieldText('y', 0),
Channel = field.GetSubFieldText('f', 0),
OnHand = field.GetSubFieldText('2', 0),
ActNumber2 = field.GetSubFieldText('v', 0),
WriteOff = field.GetSubFieldText('x', 0),
Completion = field.GetSubFieldText('k', 0),
ActNumber3 = field.GetSubFieldText('w', 0),
Moving = field.GetSubFieldText('z', 0),
NewPlace = field.GetSubFieldText('m', 0),
CheckedDate = field.GetSubFieldText('s', 0),
CheckedAmount = field.GetSubFieldText('0', 0),
RealPlace = field.GetSubFieldText('!', 0),
BindingIndex = field.GetSubFieldText('p', 0),
BindingNumber = field.GetSubFieldText('i', 0),
OtherSubFields = field.SubFields
.Where(sub => KnownCodes
.IndexOf(char.ToLower(sub.Code)) < 0)
.ToArray()
};
return(result);
}
public void RecordField_SetValue_6()
{
const string expected = " Value ";
bool save = RecordField.TrimValue;
RecordField.TrimValue = false;
try
{
RecordField field = new RecordField(200);
field.SetValue(expected);
Assert.AreEqual(expected, field.Value);
}
finally
{
RecordField.TrimValue = save;
}
}
public void RecordField_ToString_1()
{
RecordField field = _GetField();
string actual = field.ToString();
int result = string.CompareOrdinal
(
"200#Значение^aЗаглавие^eподзаголовочные^fоб ответственности ",
actual
);
Assert.AreEqual
(
0,
result
);
}
private void CheckField
(
[NotNull] RecordField field
)
{
List <string> result = CheckText(field.Text);
if (result.Count != 0)
{
AddDefect
(
field,
15,
FormatDefect(result)
);
}
}
public void RecordField_AssignFrom_1()
{
RecordField source = new RecordField(100, "Value")
.AddSubField('a', "SubfieldA")
.AddSubField('b', "SubfieldB");
RecordField target = new RecordField(200);
target.AssignFrom(source);
Assert.AreEqual(200, target.Tag);
Assert.AreEqual(source.Value, target.Value);
Assert.AreEqual(source.SubFields.Count, target.SubFields.Count);
for (int i = 0; i < source.SubFields.Count; i++)
{
Assert.AreEqual(source.SubFields[i].Code, target.SubFields[i].Code);
Assert.AreEqual(source.SubFields[i].Value, target.SubFields[i].Value);
}
}
public void RecordField_GetSubField_2()
{
RecordField field = new RecordField();
SubField subField1 = new SubField('a', "SubfieldA1");
field.SubFields.Add(subField1);
SubField subField2 = new SubField('a', "SubfieldA2");
field.SubFields.Add(subField2);
SubField found = field.GetSubField('a', 0);
Assert.AreSame(subField1, found);
found = field.GetSubField('a', 1);
Assert.AreEqual(subField2, found);
found = field.GetSubField('a', 2);
Assert.IsNull(found);
}
public void RecordField_GetValueOrFirstSubField_1()
{
const string expected0 = "Value";
const string expected1 = "SubfieldA1";
const string expected2 = "SubfieldA2";
RecordField field = new RecordField(200, expected0)
.AddSubField('a', expected1)
.AddSubField('a', expected2);
Assert.AreEqual(expected0, field.GetValueOrFirstSubField());
field.Value = null;
Assert.AreEqual(expected1, field.GetValueOrFirstSubField());
field.SubFields.RemoveAt(0);
Assert.AreEqual(expected2, field.GetValueOrFirstSubField());
field.SubFields.Clear();
Assert.IsNull(field.GetValueOrFirstSubField());
}
/// <summary>
///
/// </summary>
private void AddColumnToGridPanel()
{
var arguments = ArgumentController.GetAll(null, false, KpiStatus.Active, null, null, null);
var count = 0;
foreach (var item in arguments)
{
var recordField = new RecordField()
{
Name = item.Code,
Mapping = "ArgumentDetailModels[{0}].Value".FormatWith(count++)
};
var col = new Column
{
ColumnID = recordField.Name,
Header = item.Name,
DataIndex = recordField.Name,
Width = 150,
Renderer = { Fn = "RenderArgument" }
};
switch (item.ValueType)
{
case KpiValueType.Percent:
col.Renderer.Fn = "RenderPercent";
col.Align = Alignment.Left;
break;
case KpiValueType.String:
col.Align = Alignment.Center;
break;
case KpiValueType.Number:
break;
case KpiValueType.Formula:
break;
default:
throw new ArgumentOutOfRangeException();
}
storeEmployeeArgument.AddField(recordField);
gpEmployeeArgument.ColumnModel.Columns.Add(col);
}
}
/*========================================================*/
public MarcRecord Execute
(
IrbisConnection client,
MarcRecord record
)
{
MarcRecord result = new MarcRecord();
foreach (FstLine fstLine in Lines)
{
string formatted = client.FormatRecord
(
fstLine.Code,
record
);
if (!string.IsNullOrEmpty(formatted))
{
formatted = formatted.Trim();
if (!string.IsNullOrEmpty(formatted))
{
formatted = formatted.Replace("\r", string.Empty);
string[] parts = formatted.Split
(
new[] { '\n' },
StringSplitOptions.RemoveEmptyEntries
);
foreach (string part in parts)
{
string trimmed = part.Trim();
if (!string.IsNullOrEmpty(trimmed))
{
RecordField field = RecordFieldUtility.Parse
(
fstLine.Tag,
trimmed
);
result.Fields.Add(field);
}
}
}
}
}
return(result);
}
private MarcRecord _GetRecord
(
int titleNumber
)
{
MarcRecord result = new MarcRecord();
RecordField field = new RecordField("700");
field.AddSubField('a', "Иванов");
field.AddSubField('b', "И. И.");
result.Fields.Add(field);
field = new RecordField("701");
field.AddSubField('a', "Петров");
field.AddSubField('b', "П. П.");
result.Fields.Add(field);
field = new RecordField("200");
field.AddSubField('a', "Заглавие " + titleNumber);
field.AddSubField('e', "подзаголовочное");
field.AddSubField('f', "И. И. Иванов, П. П. Петров");
result.Fields.Add(field);
field = new RecordField("210");
field.AddSubField('a', "Иркутск");
field.AddSubField('d', "2016");
result.Fields.Add(field);
field = new RecordField("215");
field.AddSubField('a', "123");
result.Fields.Add(field);
field = new RecordField("300", "Первое примечание");
result.Fields.Add(field);
field = new RecordField("300", "Второе примечание");
result.Fields.Add(field);
field = new RecordField("300", "Третье примечание");
result.Fields.Add(field);
field = new RecordField("920", "PAZK");
result.Fields.Add(field);
return(result);
}
public RecordField ToField()
{
RecordField result = new RecordField("900")
.AddNonEmptySubField('t', DocumentType)
.AddNonEmptySubField('b', DocumentKind)
.AddNonEmptySubField('c', DocumentCharacter1)
.AddNonEmptySubField('2', DocumentCharacter2)
.AddNonEmptySubField('3', DocumentCharacter3)
.AddNonEmptySubField('4', DocumentCharacter4)
.AddNonEmptySubField('5', DocumentCharacter5)
.AddNonEmptySubField('6', DocumentCharacter6)
.AddNonEmptySubField('x', PurposeCode1)
.AddNonEmptySubField('y', PurposeCode2)
.AddNonEmptySubField('9', PurposeCode3)
.AddNonEmptySubField('z', AgeRestrictions);
return(result);
}
public Dictionary <Guid, RecordField> GetAllRecordFields(Record record, Form form)
{
string sql = "SELECT * FROM UFRecordFields where Record = @record";
Dictionary <Guid, RecordField> l = new Dictionary <Guid, RecordField>();
IRecordsReader rr = sqlHelper.ExecuteReader(sql, sqlHelper.CreateParameter("@record", record.Id));
while (rr.Read())
{
RecordField r = RecordField.CreateFromDataReader(rr);
r.Values = recordFieldValueStorage.GetRecordFieldValues(r);
l.Add(r.FieldId, r);
}
rr.Dispose();
return(l);
}
public IrbisRecord DecodeRecord()
{
IrbisRecord result = new IrbisRecord
{
Mfn = Leader.Mfn,
Status = (RecordStatus)Leader.Status,
PreviousOffset = Leader.Previous,
Version = Leader.Version
};
foreach (MstDictionaryEntry64 entry in Dictionary)
{
RecordField field = DecodeField(entry);
result.Fields.Add(field);
}
return(result);
}
private void LoadFieldForStore(DataTable datatable)
{
JsonReader jsonReader = new JsonReader();
jsonReader.Root = "Data";
if (PageSize <= 0)
{
PageSize = 30;
}
Store1.BaseParams.Add(new Ext.Net.Parameter("PageSize", PageSize.ToString()));
StaticPagingToolbar.PageSize = PageSize;
jsonReader.IDProperty = IDProperty;
jsonReader.TotalProperty = "TotalRecords";
jsonReader.Fields.Add(new RecordField()
{
Name = IDProperty
});
foreach (DataColumn item in datatable.Columns)
{
RecordField field = new RecordField();
field.Name = item.ColumnName;
jsonReader.Fields.Add(field);
}
if (!string.IsNullOrEmpty(MoreStoreField))
{
foreach (var item in MoreStoreField.Split(','))
{
if (!string.IsNullOrEmpty(item))
{
RecordField field = new RecordField();
field.Name = item;
jsonReader.Fields.Add(field);
}
}
}
Store1.Reader.Add(jsonReader);
if (!string.IsNullOrEmpty(GroupField))
{
Store1.GroupField = GroupField;
}
}
/// <summary>
/// Subfields of the field must not contain bad characters.
/// </summary>
protected void MustNotContainWhitespace
(
[NotNull] RecordField field,
params char[] codes
)
{
foreach (char code in codes)
{
SubField[] subFields = field.GetSubField(code);
foreach (SubField subField in subFields)
{
MustNotContainWhitespace
(
field,
subField
);
}
}
}
/// <summary>
/// The field must not contain whitespace.
/// </summary>
/// <param name="field"></param>
protected void MustNotContainWhitespace
(
[NotNull] RecordField field
)
{
string text = field.Text;
if (!string.IsNullOrEmpty(text) &&
text.ContainsWhitespace())
{
AddDefect
(
field,
3,
"Поле {0} содержит пробельные символы",
field.Tag
);
}
}
/// <summary>
/// Add the detected defect.
/// </summary>
protected void AddDefect
(
[NotNull] RecordField field,
int damage,
[NotNull] string format,
params object[] args
)
{
FieldDefect defect = new FieldDefect
{
Field = field.Tag,
FieldRepeat = field.Repeat,
Value = field.ToText(),
Damage = damage,
Message = string.Format(format, args)
};
Report.Defects.Add(defect);
}
public void RecordField_SetValue_2()
{
bool save = RecordField.BreakOnValueContainDelimiters;
RecordField.BreakOnValueContainDelimiters = false;
try
{
RecordField field = new RecordField(200);
field.SetValue("Value^aSubfieldA^bSubfieldB");
Assert.AreEqual(2, field.SubFields.Count);
Assert.AreEqual("SubfieldA", field.GetFirstSubFieldValue('a'));
Assert.AreEqual("SubfieldB", field.GetFirstSubFieldValue('b'));
Assert.AreEqual("Value", field.Value);
}
finally
{
RecordField.BreakOnValueContainDelimiters = save;
}
}
private void CheckField
(
[NotNull] RecordField field
)
{
MustNotContainText(field);
SubField isbn = field.GetFirstSubField('a');
if (!ReferenceEquals(isbn, null))
{
if (Utilities.SafeContains
(
isbn.Text,
"(", " ", ".", ";", "--"
))
{
AddDefect
(
field,
isbn,
1,
"Неверно введен ISBN в поле 10"
);
}
}
SubField price = field.GetFirstSubField('d');
if (price != null)
{
if (!Regex.IsMatch(price.Text, @"\d+\.\d{2}"))
{
AddDefect
(
field,
price,
5,
"Неверный формат цены в поле 10"
);
}
}
}
/// <summary>
/// Sinh cột và record field động
/// </summary>
private void InitDynamicColumn()
{
if (string.IsNullOrEmpty(hdfSalaryBoardListID.Text))
{
return;
}
// get payroll
var payroll = PayrollController.GetById(Convert.ToInt32(hdfSalaryBoardListID.Text));
if (payroll == null)
{
return;
}
// get payroll config
var salaryBoardConfigs = SalaryBoardConfigController.GetAll(payroll.ConfigId, true, null, null,
SalaryConfigDataType.DynamicValue, null, null);
foreach (var salaryBoardConfig in salaryBoardConfigs)
{
// init record field
var recordField = new RecordField
{
Name = salaryBoardConfig.ColumnCode,
};
// init column
var column = new Column
{
DataIndex = recordField.Name,
Header = salaryBoardConfig.Display,
Width = 120,
Align = Alignment.Right,
Tooltip = salaryBoardConfig.Description,
Editor = { new TextField() },
Renderer = { Fn = "RenderValue" }
};
storeAdjustment.AddField(recordField);
gridColumnDynamic.ColumnModel.Columns.Add(column);
}
}
private void CheckField
(
[NotNull] RecordField field
)
{
MustNotContainSubfields(field);
string text = field.Text;
if (Utilities.SafeContains(text, "."))
{
AddDefect
(
field,
1,
"Ключевые слова с сокращениями"
);
}
}
private void CheckField
(
[NotNull] RecordField field
)
{
MustNotContainSubfields
(
field
);
if (!CheckForMenu(_menu, field.Text))
{
AddDefect
(
field,
10,
"Поле 102 (страна) не из словаря"
);
}
}
public void RecordFieldUtility_GetFirstField_2()
{
IEnumerable <RecordField> enumeration = _GetFieldEnumeration();
RecordField field = RecordFieldUtility.GetFirstField(enumeration, 100, 200);
Assert.IsNotNull(field);
enumeration = _GetFieldEnumeration();
field = RecordFieldUtility.GetFirstField(enumeration, 200);
Assert.IsNotNull(field);
enumeration = _GetFieldEnumeration();
field = RecordFieldUtility.GetFirstField(enumeration, 900, 1000);
Assert.IsNull(field);
enumeration = _GetFieldEnumeration();
field = RecordFieldUtility.GetFirstField(enumeration, 900, 200);
Assert.IsNotNull(field);
}
private ServerResponse ExecuteFormatCommand
(
[NotNull] FormatCommand command,
bool emptyRecords
)
{
IIrbisConnection connection = command.Connection;
List <int> list = command.MfnList;
int count = list.Count;
command.FormatResult = new string[count];
for (int i = 0; i < count; i++)
{
MarcRecord record = new MarcRecord
{
Database = connection.Database,
Mfn = list[i],
Version = 1,
Status = RecordStatus.Last
};
if (!emptyRecords)
{
record.Fields.Add(RecordField.Parse(100, "Field100"));
record.Fields.Add(RecordField.Parse(300, "Field200"));
record.Fields.Add(RecordField.Parse(300, "Field300"));
}
string line = EncodeRecord(record);
command.FormatResult[i] = line;
}
byte[] rawAnswer = new byte[0];
byte[] rawRequest = new byte[0];
ServerResponse response = new ServerResponse
(
connection,
rawAnswer,
rawRequest,
true
);
return(response);
}
/// <summary>
/// record_stmt = identifier ":" type
/// </summary>
private RecordField parseRecordStmt()
{
var node = new RecordField();
node.Name = ensure(LexemType.Identifier, ParserMessages.RecordFieldIdentifierExpected).Value;
ensure(LexemType.Colon, ParserMessages.SymbolExpected, ':');
node.Type = ensure(parseType, ParserMessages.RecordFieldTypeExpected);
return node;
}
public static string SaveToContour(this DynaForm dynaform, string formGuid, out string insertedRecordId, string userIpAddress = "", int umbracoPageId = 0)
{
var message = "";
insertedRecordId = "";
using (var recordStorage = new RecordStorage())
using (var formStorage = new FormStorage())
{
var form = formStorage.GetForm(new Guid(formGuid));
using (var recordService = new RecordService(form))
{
recordService.Open();
var record = recordService.Record;
record.IP = userIpAddress;
record.UmbracoPageId = umbracoPageId;
recordStorage.InsertRecord(record, form);
foreach (var field in recordService.Form.AllFields)
{
string currentFieldValue = "";
string contourFieldName = field.Caption.TrimStart('#');
if (dynaform.ModelDictionary.ContainsKey("f" + field.Id.ToString().Replace('-', '_')))
{
currentFieldValue = dynaform.ModelDictionary["f" + field.Id.ToString().Replace('-', '_')].ToString();
}
else if (dynaform.ModelDictionary.ContainsKey(contourFieldName))
{
currentFieldValue = dynaform.ModelDictionary[contourFieldName].ToString();
}
var key = Guid.NewGuid();
var recordField = new RecordField
{
Field = field,
Key = key,
Record = record.Id,
Values = new List<object> { currentFieldValue }
};
using (var recordFieldStorage = new RecordFieldStorage())
recordFieldStorage.InsertRecordField(recordField);
record.RecordFields.Add(key, recordField);
insertedRecordId = record.Id.ToString();
}
recordService.Submit();
recordService.SaveFormToRecord();
}
message=form.MessageOnSubmit;
}
return message;
}
/// <summary>
/// Stores a form record.
/// </summary>
/// <param name="form">The form to store a record to.</param>
/// <param name="fieldValues">The field values to store.</param>
/// <param name="ipAddress">The user's IP address.</param>
/// <param name="pageId">The current page ID.</param>
/// <param name="recordId">Outputs the ID of the record stored to Contour.</param>
/// <returns>True, if the record was stored; otherwise, false.</returns>
private static bool StoreRecord(Form form, Dictionary<string, List<object>> fieldValues,
string ipAddress, int pageId, out Guid recordId) {
using (var recordStorage = new RecordStorage())
using (var recordService = new RecordService(form)) {
// Open record service.
recordService.Open();
// Create record.
var record = recordService.Record;
record.IP = ipAddress;
record.UmbracoPageId = pageId;
record = recordStorage.InsertRecord(record, form);
// Assign field values for record.
foreach (var field in recordService.Form.AllFields) {
// Check which field this is.
var knownField = false;
var values = default(List<object>);
if (fieldValues.TryGetValue((field.Caption ?? string.Empty).ToLower(), out values)) {
knownField = true;
}
// If the field is one of those that are known, store it.
if (knownField && values != null && values.Any(x => x != null)) {
// Create field.
var key = Guid.NewGuid();
var recordField = new RecordField {
Field = field,
Key = key,
Record = record.Id,
Values = values
};
// Store field.
using (var recordFieldStorage = new RecordFieldStorage()) {
recordFieldStorage.InsertRecordField(recordField);
}
// Add field to record.
record.RecordFields.Add(key, recordField);
}
}
// Submit / save record.
recordService.Submit();
var result = recordService.SaveFormToRecord();
recordId = record.Id;
return result;
}
}
private bool IsFileUpload(RecordField r)
{
return
r.Field.FieldTypeId == Guid_FileUpload ||
r.Field.FieldTypeId == Guid_PerplexFileUpload ||
r.Field.FieldTypeId == Guid_PerplexImageUpload;
}
/// <summary>
/// Dit levert een List van EmailTags op omdat sommige RecordFields tot meerdere
/// EmailTags leiden. Bijvoorbeeld een File Upload is standaard type multiple, dus kan leiden
/// tot meer dan 1 EmailTag ([#file-1#], [#file-2#], etc.). Het was dus noodzakelijk hier
/// meerdere EmailTags op te kunnen leveren per RecordField.
/// </summary>
/// <param name="recordField"></param>
/// <returns></returns>
private List<EmailTag> ParseRecordField(RecordField recordField)
{
string tag = "[#" + recordField.Field.Caption + "#]";
// Over het algemeen hebben we de eerste waarde nodig, we handelen hier meteen
// de case af dat de waarde niet is meegestuurd en/of null is.
string value = recordField.Values.Count == 0 || recordField.Values[0] == null
? ""
: recordField.Values[0].ToString();
// Hoe we de value uitlezen is afhankelijk van het datatype
// Guids kunnen niet in een switch staan, dus we gebruiken simpelweg if / else statements
Guid fieldTypeId = recordField.Field.FieldTypeId;
if(fieldTypeId == Guid_Checkbox)
{
// Bij een checkbox gaat het om een boolean waarde, deze geven we dus ook als zodanig terug en niet als string
return new List<EmailTag>() { new EmailTag(tag, bool.Parse(value)) };
}
else if(fieldTypeId == Guid_TextArea)
{
// Newlines vervangen door HTMl newlines
value = value.Replace("\n", "<br/>");
}
else if(fieldTypeId == Guid_DatePicker)
{
// De .ToString van de DateTime moeten we wellicht instelbaar maken in de WorkFlow
// Dan kan je per formulier aangeven hoe de datum naar een string moet worden omgezet
if (value != "")
{
DateTime dateTime;
if (DateTime.TryParse(value, out dateTime))
{
value = dateTime.ToShortDateString();
}
else
{
value = "The DatePicker value could not be parsed into a DateTime instance. The DatePicker value was " + value;
}
}
}
else if(IsFileUpload(recordField))
{
// Een FileUpload kan meerdere waardes hebben (voor elk geüpload bestand)
// We gaan nog steeds 1 tag genereren, maar die kan dan dus meerdere linkjes
// bevatten, 1 voor elk bestand.
// Lijstje met <a href="...">'s
List<string> links = recordField.Values.Select((filePath, idx) =>
{
// filePath is een relatief pad, iets als "~/media/forms/upload/<GUID>/bestandsnaam.txt
string fileName = Path.GetFileName(filePath.ToString());
var httpContext = HttpContext.Current;
string host = ""; // Root van website
if (httpContext != null)
{
host = httpContext.Request.Url.GetLeftPart(UriPartial.Authority);
}
string url = host + filePath.ToString().Replace("~", "");
string link = "<a title=\"" + fileName + "\" href=\"" + url + "\">" + fileName + "</a>";
// Eerder hadden we losse tags voor Bestandsnaam en URL,
// maar in de praktijk zijn die niet zinnig om terug te geven
// want in de formsautogenerate toont hij alle tags + values.
// Daar willen we echter alleen maar een aanklikbare link en niet
// ook nog los bestandsnaam + url.
// Nu dus alleen nog een anchor tag met aanklikbare link
return link;
}).ToList();
string htmlValue;
// Indien het 1 bestand is leveren we 1 <a> tag op, verder niets.
// Indien er meer dan 1 bestand is zetten we er enters tussen en doen we
// ook een enter voor het eerste bestand zodat we een lijstje onder elkaar krijgen.
if (links.Count == 1)
{
htmlValue = links.First();
}
else
{
htmlValue = "<br/>" + string.Join("<br/>", links);
}
return new List<EmailTag>() { new EmailTag("[#" + recordField.Field.Caption + "#]", htmlValue) };
}
// Default case voor de overige waardes:
// Value wordt de stringwaarde (bij 1 waarde),
// ofwel een kommagescheiden lijst van de stringwaardes (bij 2+ waardes)
else
{
value = string.Join(", ", recordField.Values.Where(v => v != null).Select(v => v.ToString()));
}
return new List<EmailTag>() { new EmailTag(tag, value) };
}
