public T GetSetting <T>(string settingName)
{
ConditionExpression condition = new ConditionExpression(
"dia_name",
ConditionOperator.Equal,
settingName
);
ConditionExpression condition2 = new ConditionExpression(
"statuscode",
ConditionOperator.Equal,
dia_configuration_statuscode.Active
);
QueryExpression query = new QueryExpression
{
EntityName = "dia_configuration",
ColumnSet = new ColumnSet(true)
};
query.Criteria.AddCondition(condition);
query.Criteria.AddCondition(condition2);
var settings = OrgService.RetrieveMultiple(query).Entities;
var setting = settings.FirstOrDefault();
return(setting.GetAttributeValue <T>("dia_value"));
}
private IEnumerable <BordereauImportRow> RetrieveImportRows()
{
var rowsQuery = new QueryExpression("new_bordereauximportrow");
rowsQuery.ColumnSet.AllColumns = true;
rowsQuery.Criteria.AddCondition("new_bordereauxprocess", ConditionOperator.Equal, this.Id);
var result = OrgService.RetrieveMultiple(rowsQuery);
return(result.Entities.Select(e => new BordereauImportRow(OrgService, TracingService, e)));
}
private IEnumerable <PolicyVersion> RetrievePolicyVersions()
{
var policyVersionQuery = new QueryExpression("new_policy");
policyVersionQuery.ColumnSet.AllColumns = true;
policyVersionQuery.Criteria.AddCondition("new_policy", ConditionOperator.Equal, this.Entity.Id);
var result = OrgService.RetrieveMultiple(policyVersionQuery);
return(result.Entities.Select(e => new PolicyVersion(OrgService, TracingService, e)));
}
private IEnumerable <Entity> RetrieveCovers()
{
var coverQuery = new QueryExpression("new_cover");
coverQuery.ColumnSet.AllColumns = true;
coverQuery.Criteria.AddCondition("new_riskid", ConditionOperator.Equal, this.Id);
var result = OrgService.RetrieveMultiple(coverQuery);
return(result.Entities);
}
private IEnumerable <Entity> RetrieveOptionSets()
{
var optionSetTableRef = this.GetAttributeFromMapping <EntityReference>("new_optionset");
if (optionSetTableRef == null)
{
return(Enumerable.Empty <Entity>());
}
var optQuery = new QueryExpression("new_optionset");
optQuery.ColumnSet.AllColumns = true;
optQuery.Criteria.AddCondition("new_optionsettable", ConditionOperator.Equal, optionSetTableRef.Id);
return(OrgService.RetrieveMultiple(optQuery).Entities);
}
/// <summary>
/// Retrieves import rows for current process, but only as entity references without any fields.
/// </summary>
public IEnumerable <EntityReference> RetrieveImportRowRefs(BordereauImportRowStatus?status = null)
{
var rowsQuery = new QueryExpression("new_bordereauximportrow");
rowsQuery.NoLock = true;
rowsQuery.Criteria.AddCondition("new_bordereauxprocess", ConditionOperator.Equal, this.Id);
if (status != null)
{
rowsQuery.Criteria.AddCondition("statuscode", ConditionOperator.Equal, (int)status.Value);
}
var result = OrgService.RetrieveMultiple(rowsQuery);
return(result.Entities.Select(e => e.ToEntityReference()));
}
/// <summary>
/// Retrieves Bordereau template columns for current template. Returned template columns
/// are linked to their Field mappings (new_fieldmapping).
/// </summary>
/// <returns></returns>
private IEnumerable <BordereauTemplateColumn> RetrieveTemplateColumns()
{
var tempColumnQuery = new QueryExpression("new_bordereauxtemplatecolumn");
tempColumnQuery.ColumnSet.AllColumns = true;
tempColumnQuery.Criteria.AddCondition("new_bordereauxtemplate", ConditionOperator.Equal, this.Entity.Id);
var mappingLink = tempColumnQuery.AddLink("new_fieldmapping", "new_bordereauxfieldmaping", "new_fieldmappingid");
mappingLink.EntityAlias = BordereauTemplateColumn.FieldMappingAlias;
mappingLink.Columns.AllColumns = true;
var result = OrgService.RetrieveMultiple(tempColumnQuery);
return(result.Entities.Select(e => new BordereauTemplateColumn(OrgService, TracingService, e)));
}
private T[] GetAllWithPaging <T>(QueryExpression query, Func <Entity, T> transformer)
{
int?topCount = query.TopCount;
query.TopCount = null;
List <T> result = new List <T>();
int pageNr = 1;
query.PageInfo = new PagingInfo
{
PageNumber = pageNr,
Count = topCount != null ? topCount.Value : 5000
};
while (true)
{
EntityCollection ecoll = OrgService.RetrieveMultiple(query);
foreach (Entity entity in ecoll.Entities)
{
var record = transformer(entity);
if (record != null)
{
result.Add(record);
}
}
if (ecoll.MoreRecords && topCount == null)
{
pageNr++;
query.PageInfo.PageNumber = pageNr;
query.PageInfo.PagingCookie = ecoll.PagingCookie;
}
else
{
break;
}
}
return(result.ToArray());
}
public Entity RetrieveLookupByOptionSet(string optSetAttribute, int optSetValue)
{
ThrowIf.Argument.IsNullOrEmpty(optSetAttribute, "optSetAttribute");
var targetEntity = this.LookupTargetEntityName;
if (string.IsNullOrEmpty(targetEntity))
{
throw new InvalidPluginExecutionException("Field mapping error, lookup target entity is empty.");
}
var query = new QueryExpression(this.LookupTargetEntityName);
query.ColumnSet.AllColumns = true;
query.Criteria.AddCondition(optSetAttribute, ConditionOperator.Equal, optSetValue);
var result = OrgService.RetrieveMultiple(query);
return(result.Entities.FirstOrDefault());
}
static int test(string[] args)
{
closeNow = true;
if (config == null)
{
LoadCec();
}
if (config == null)
{
ConCol = ConsoleColor.Red;
Console.WriteLine("CEC not configured.");
ConColReset();
return(args.Length);
}
if (orgService == null)
{
ConnectCec();
}
var res = OrgService.RetrieveMultiple(new QueryExpression("systemuser")
{
TopCount = 1,
});
if (res != null && res.Entities != null && res.Entities.Count == 1)
{
ConCol = ConsoleColor.Green;
Console.WriteLine("CEC can connect!");
}
else
{
ConCol = ConsoleColor.Red;
Console.WriteLine("CEC can not connect!");
}
ConColReset();
return(args.Length);
}
private Entity RetrieveBordereauTemplate(Guid?brokerId)
{
var templateQuery = new QueryExpression("new_bordereauxriskclasssettings");
templateQuery.ColumnSet.AllColumns = true;
templateQuery.Criteria.AddCondition("new_bordereauxtype", ConditionOperator.Equal, (int)this.BordereauType);
templateQuery.Criteria.AddCondition("new_riskclassid", ConditionOperator.Equal, this.RiskClassRef.Id);
if (brokerId == null)
{
templateQuery.Criteria.AddCondition("new_broker", ConditionOperator.Null);
}
else
{
templateQuery.Criteria.AddCondition("new_broker", ConditionOperator.Equal, brokerId.Value);
}
templateQuery.Criteria.AddCondition("statuscode", ConditionOperator.Equal, 1); // active
var result = OrgService.RetrieveMultiple(templateQuery);
return(result.Entities.FirstOrDefault());
}
public override void Execute(string[] args)
{
if (types.Contains("?"))
{
HelpTypes();
return;
}
foreach (var t in types)
{
try {
DownloadTarget downTarg = null;
if (typeQueries.ContainsKey(t.ToLower()))
{
downTarg = typeQueries[t.ToLower()];
}
else if (typeQueries.ContainsKey(t.ToLower() + "s"))
{
downTarg = typeQueries[t.ToLower() + "s"];
}
if (downTarg == null)
{
Console.WriteLine("No ability to download " + t);
Console.WriteLine("---------");
continue;
}
Console.WriteLine("Downloading " + t);
downTarg.Query.PageInfo = new PagingInfo()
{
Count = 50,
PageNumber = 1,
};
var entList = new List <Entity>();
EntityCollection entRes = null;
while (true)
{
entRes = OrgService.RetrieveMultiple(downTarg.Query);
foreach (var res in entRes.Entities)
{
if (!files.Any() || files.Contains(res.GetAttributeValue <string>(downTarg.Name)))
{
entList.Add(res);
}
}
Console.WriteLine("Currently " + entList.Count + " records in queue...");
if (entRes.MoreRecords)
{
downTarg.Query.PageInfo.PageNumber++;
downTarg.Query.PageInfo.PagingCookie = entRes.PagingCookie;
}
else
{
break;
}
}
var targDir = t;
if (custdlConfig != null && custdlConfig.Sections.ContainsSection("map"))
{
if (custdlConfig["map"].ContainsKey(t))
{
targDir = custdlConfig["map"][t];
}
}
Console.WriteLine("Writing to: " + targDir);
System.IO.Directory.CreateDirectory(targDir);
foreach (var r in entList)
{
if (r.Attributes.ContainsKey(downTarg.Filename) && r.Attributes.ContainsKey(downTarg.Data))
{
var data = r.GetAttributeValue <string>(downTarg.Data);
if (downTarg.Process != null)
{
data = downTarg.Process(data, r);
}
if (data == null)
{
continue;
}
var fname = r.GetAttributeValue <string>(downTarg.Filename);
fname = fname.Replace("/", "_");
fname = fname.Replace("\\", "_");
if (!string.IsNullOrWhiteSpace(downTarg.FileExten) && new FileInfo(fname).Extension != "." + downTarg.FileExten)
{
fname = Path.ChangeExtension(fname, downTarg.FileExten);
}
File.WriteAllText(targDir + "/" + fname, data);
Console.WriteLine("Downloaded " + r.GetAttributeValue <string>(downTarg.Filename));
}
else
{
Console.WriteLine("Failed " + r.GetAttributeValue <string>(downTarg.Name));
}
}
}
catch {
throw;
}
}
}