/// <summary>
/// Get multiple properties asynchronously
/// </summary>
/// <param name="props"></param>
/// <returns></returns>
public async Task <Dictionary <PROPERTIES, object> > GetProps(PROPERTIES props)
{
List <object> names = props.GetRealNames();
CommandResult <List <string> > commandResult = await ExecuteCommandWithResponse <List <string> >(
method : METHODS.GetProp,
id : ((int)METHODS.GetProp),// + 1000 + props.Count,
parameters : names
);
if (commandResult != null)
{
Dictionary <PROPERTIES, object> result = new Dictionary <PROPERTIES, object>();
for (int n = 0; n < names.Count; n++)
{
string name = names[n].ToString();
if (Enum.TryParse <PROPERTIES>(name, out PROPERTIES p))
{
result.Add(p, commandResult.Result[n]);
}
}
return(result);
}
return(null);
}
/// <summary>
/// parse a <code><job-acquisition .../></code> element and add it to the
/// list of parsed elements
/// </summary>
protected internal virtual void parseJobAcquisition(Element element, IList <JobAcquisitionXml> jobAcquisitions)
{
JobAcquisitionXmlImpl jobAcquisition = new JobAcquisitionXmlImpl();
// set name
jobAcquisition.Name = element.attribute(NAME);
IDictionary <string, string> properties = new Dictionary <string, string>();
foreach (Element childElement in element.elements())
{
if (JOB_EXECUTOR_CLASS_NAME.Equals(childElement.TagName))
{
jobAcquisition.JobExecutorClassName = childElement.Text;
}
else if (PROPERTIES.Equals(childElement.TagName))
{
parseProperties(childElement, properties);
}
}
// set collected properties
jobAcquisition.Properties = properties;
// add to list
jobAcquisitions.Add(jobAcquisition);
}
public void Save()
{
PROPERTIES property = new PROPERTIES();
property.DESCRIPTION = this.DESCRIPTION;
property.ADDRESS = this.ADDRESS;
property.OWNERID = this.OWNERID;
property.SIZE = this.SIZE;
property.SELL = decimal.Round(this.SELL, 2);
property.RENT = decimal.Round(this.RENT, 2);
property.REGIONID = this.REGIONID;
property.IsActive = this.IsActive;
property.PROPERTYTYPEID = this.PROPERTYTYPEID;
DbContext.PROPERTIES.Add(property);
DbContext.SaveChanges();
PARAMS = GetParams(property.PROPERTYID);
foreach (var param in this.PARAMS)
{
DbContext.PARAMS.Add(param);
}
foreach (var img in IMAGES.Images)
{
var str = img.Remove(0, 93);
DbContext.IMAGES.Add(new IMAGES()
{
IMAGE = str, PID = property.PROPERTYID
});
}
DbContext.SaveChanges();
}
/// <summary>
/// Gets a flat report from the data source. The returned report can be displayed in a data grid.
/// </summary>
public IList <ReportItem> GetReport()
{
var items = from CO in co
join PROP in props on CO.co_Id equals PROP.co_Id
join RULE in rules on CO.co_Id equals RULE.co_Id
let PROPERTIES = GetProperties(PROP)
join CHECKS in rule on RULE.rules_Id equals CHECKS.rules_Id
join ITEM in item on CHECKS.rule_Id equals ITEM.rule_Id
where ITEM.result == "True"
select new ReportItem
{
FileName = PROPERTIES.Single(p => p.name == "LcxFileName").value,
ResourceID = PROPERTIES.Single(p => p.name == "LSResID").value,
CheckName = CHECKS.name,
Language = PROPERTIES.Single(p => p.name == "TargetCulture").value,
Project = PROPERTIES.Single(p => p.name == "Project").value,
Locgroup = PROPERTIES.Single(p => p.name == "Locgroup").value,
Comments = PROPERTIES.Single(p => p.name == "Comments").value,
SourceString = PROPERTIES.Single(p => p.name == "SourceString").value,
TargetString = PROPERTIES.Single(p => p.name == "TargetString").value,
Message = ITEM.message,
Severity = ITEM.severity
};
return(items.ToList());
}
public static string BuildNuGetPack
(string aTokenizedCommandLine, bool aUseNuSpecFileIfAvailable)
{
StringBuilder vResult = new StringBuilder(aTokenizedCommandLine);
string vSourcePath =
aUseNuSpecFileIfAvailable
? NuSpecFilePath
: ProjectPath;
vResult
.Replace(BASE_PATH.AsToken(), BasePath)
.Replace(EXCLUDE.AsToken(), Exclude)
.Replace(MIN_CLIENT_VERSION.AsToken(), MinClientVersion)
.Replace(MS_BUILD_PATH.AsToken(), MSBuildPath)
.Replace(MS_BUILD_VERSION.AsToken(), MSBuildVersion)
// .Replace(OUTPUT_PACKAGE_TO.AsToken(), PackagePath)
.Replace
(
OUTPUT_PACKAGE_TO.AsToken()
, PackageDir + Path.DirectorySeparatorChar
)
.Replace(PACKAGE_VERSION.AsToken(), PackageVersion)
.Replace(PROJECT_PATH.AsToken(), vSourcePath)
.Replace(PROPERTIES.AsToken(), Properties)
.Replace(VERSION_SUFFIX_NUGET.AsToken(), VersionSuffixNuGet)
.Replace(VERBOSITY_NUGET.AsToken(), VerbosityNuGet);
return(vResult.ToString());
}
public ActionResult DeleteConfirmed(int id)
{
PROPERTIES pROPERTIES = db.PROPERTIES.Find(id);
db.PROPERTIES.Remove(pROPERTIES);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public void Search()
{
PROPERTIES property = DbContext.PROPERTIES.Where(p => this.PROPERTYID == p.PROPERTYID).FirstOrDefault();
if (property != null)
{
SearchHelper(property);
}
}
/// <summary>
/// Get the real name of the properties
/// </summary>
/// <param name="properties"></param>
/// <returns></returns>
public static List <object> GetRealNames(this PROPERTIES properties)
{
Array vals = Enum.GetValues(typeof(PROPERTIES));
return(vals
.Cast <PROPERTIES>()
.Where(m => properties.HasFlag(m) && m != PROPERTIES.ALL && m != PROPERTIES.NONE)
.Select(x => x.ToString())
.ToList <object>());
}
/// <summary>
/// Access property from its enum value
/// </summary>
/// <param name="property"></param>
/// <returns></returns>
public object this[PROPERTIES property]
{
get
{
return(this[property.ToString()]);
}
set
{
this[property.ToString()] = value;
}
}
/// <summary>
/// Get a single property value asynchronously
/// </summary>
/// <param name="prop"></param>
/// <returns></returns>
public async Task <object> GetProp(PROPERTIES prop)
{
CommandResult <List <string> > result = await ExecuteCommandWithResponse <List <string> >(
method : METHODS.GetProp,
parameters : new List <object>()
{
prop.ToString()
});
return(result?.Result?.Count == 1 ? result.Result[0] : null);
}
/// <summary>
/// parse a <code><process-engine .../></code> element and add it to the list of parsed elements
/// </summary>
protected internal virtual void parseProcessEngine(Element element, IList <ProcessEngineXml> parsedProcessEngines)
{
ProcessEngineXmlImpl processEngine = new ProcessEngineXmlImpl();
// set name
processEngine.Name = element.attribute(NAME);
// set default
string defaultValue = element.attribute(DEFAULT);
if (string.ReferenceEquals(defaultValue, null) || defaultValue.Length == 0)
{
processEngine.Default = false;
}
else
{
processEngine.Default = bool.Parse(defaultValue);
}
IDictionary <string, string> properties = new Dictionary <string, string>();
IList <ProcessEnginePluginXml> plugins = new List <ProcessEnginePluginXml>();
foreach (Element childElement in element.elements())
{
if (CONFIGURATION.Equals(childElement.TagName))
{
processEngine.ConfigurationClass = childElement.Text;
}
else if (DATASOURCE.Equals(childElement.TagName))
{
processEngine.Datasource = childElement.Text;
}
else if (JOB_ACQUISITION.Equals(childElement.TagName))
{
processEngine.JobAcquisitionName = childElement.Text;
}
else if (PROPERTIES.Equals(childElement.TagName))
{
parseProperties(childElement, properties);
}
else if (PLUGINS.Equals(childElement.TagName))
{
parseProcessEnginePlugins(childElement, plugins);
}
}
// set collected properties
processEngine.Properties = properties;
// set plugins
processEngine.Plugins = plugins;
// add the process engine to the list of parsed engines.
parsedProcessEngines.Add(processEngine);
}
public ActionResult Edit([Bind(Include = "PROPERTYID,SIZE,RENT,SELL,DESCRIPTION,ADDRESS,IsActive,PROPERTYTYPEID,REGIONID,OWNERID")] PROPERTIES pROPERTIES)
{
if (ModelState.IsValid)
{
db.Entry(pROPERTIES).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.OWNERID = new SelectList(db.OWNERS, "OWNERID", "FNAME", pROPERTIES.OWNERID);
ViewBag.PROPERTYTYPEID = new SelectList(db.PROPERTYTYPES, "ID", "TYPE", pROPERTIES.PROPERTYTYPEID);
ViewBag.REGIONID = new SelectList(db.REGIONS, "REGIONID", "REGIONNAME", pROPERTIES.REGIONID);
return(View(pROPERTIES));
}
/// <summary>
/// Get multiple properties asynchronously
/// </summary>
/// <param name="props"></param>
/// <returns></returns>
public async Task <Dictionary <PROPERTIES, object> > GetProps(PROPERTIES props)
{
List <object> names = props.GetRealNames();
List <string> results = new List <string>();
if (names.Count <= 20)
{
CommandResult <List <string> > commandResult = await ExecuteCommandWithResponse <List <string> >(
method : METHODS.GetProp,
id : ((int)METHODS.GetProp),// + 1000 + props.Count,
parameters : names
);
results.AddRange(commandResult?.Result);
}
else
{
CommandResult <List <string> > commandResult1 = await ExecuteCommandWithResponse <List <string> >(
method : METHODS.GetProp,
id : ((int)METHODS.GetProp),// + 1000 + props.Count,
parameters : names.Take(20).ToList()
);
CommandResult <List <string> > commandResult2 = await ExecuteCommandWithResponse <List <string> >(
method : METHODS.GetProp,
id : ((int)METHODS.GetProp),// + 1000 + props.Count,
parameters : names.Skip(20).ToList()
);
results.AddRange(commandResult1?.Result);
results.AddRange(commandResult2?.Result);
}
if (results.Count > 0)
{
Dictionary <PROPERTIES, object> result = new Dictionary <PROPERTIES, object>();
for (int n = 0; n < names.Count; n++)
{
string name = names[n].ToString();
if (Enum.TryParse <PROPERTIES>(name, out PROPERTIES p))
{
result.Add(p, results[n]);
}
}
return(result);
}
return(null);
}
// GET: Properties/Delete/5
public ActionResult Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
PROPERTIES pROPERTIES = db.PROPERTIES.Find(id);
if (pROPERTIES == null)
{
return(HttpNotFound());
}
return(View(pROPERTIES));
}
// GET: Property/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
PROPERTIES pROPERTIES = db.PROPERTIES.Find(id);
if (pROPERTIES == null)
{
return(HttpNotFound());
}
ViewBag.OWNERID = new SelectList(db.OWNERS, "OWNERID", "FNAME", pROPERTIES.OWNERID);
ViewBag.PROPERTYTYPEID = new SelectList(db.PROPERTYTYPES, "ID", "TYPE", pROPERTIES.PROPERTYTYPEID);
ViewBag.REGIONID = new SelectList(db.REGIONS, "REGIONID", "REGIONNAME", pROPERTIES.REGIONID);
return(View(pROPERTIES));
}
public void SearchHelper(PROPERTIES prop)
{
this.RENT = prop.RENT == null ? 0 : (decimal)prop.RENT;
this.SELL = prop.SELL == null ? 0 : (decimal)prop.SELL;
this.SIZE = prop.SIZE;
this.IsActive = prop.IsActive;
this.REGIONID = prop.REGIONID;
this.PROPERTYTYPEID = prop.PROPERTYTYPEID == null ? -1 : (int)prop.PROPERTYTYPEID;
this.DESCRIPTION = prop.DESCRIPTION;
this.ADDRESS = prop.ADDRESS;
this.OWNERID = prop.OWNERID;
this.CITIES.SelectedCity = this.CITIES.CitiesList.Where(c => c.CITYID == prop.REGIONS.CITYID).FirstOrDefault();
foreach (var category in CATEGORIES.CategoriesList)
{
foreach (var param in prop.PARAMS)
{
if (param.CATEGORYNAME == category.CATEGORYID)
{
foreach (var catValue in category.CategoryTypesListViewModel)
{
if (catValue.CATEGORYTYPEID == param.CATEGORYVALUES)
{
catValue.IsChecked = true;
}
else
{
catValue.IsChecked = false;
}
}
}
}
}
this.IMAGES.Images.Clear();
foreach (var image in prop.IMAGES)
{
if (!image.IMAGE.Contains(@"C:\Users\Стефан\Documents\Visual Studio 2015\Projects\RealEstateProject\RealEstateProject.Web"))
{
this.IMAGES.Images.Add(@"C:\Users\Стефан\Documents\Visual Studio 2015\Projects\RealEstateProject\RealEstateProject.Web" + image.IMAGE);
}
}
}
/// <summary>
/// parse a <code><job-executor .../></code> element and add it to the list of parsed elements
/// </summary>
protected internal virtual void parseJobExecutor(Element element, JobExecutorXmlImpl jobExecutorXml)
{
IList <JobAcquisitionXml> jobAcquisitions = new List <JobAcquisitionXml>();
IDictionary <string, string> properties = new Dictionary <string, string>();
foreach (Element childElement in element.elements())
{
if (JOB_ACQUISITION.Equals(childElement.TagName))
{
parseJobAcquisition(childElement, jobAcquisitions);
}
else if (PROPERTIES.Equals(childElement.TagName))
{
parseProperties(childElement, properties);
}
}
jobExecutorXml.JobAcquisitions = jobAcquisitions;
jobExecutorXml.Properties = properties;
}
/// <summary>
/// Transform a <code><plugin ... /></code> structure.
/// </summary>
protected internal virtual void parseProcessEnginePlugin(Element element, IList <ProcessEnginePluginXml> plugins)
{
ProcessEnginePluginXmlImpl plugin = new ProcessEnginePluginXmlImpl();
IDictionary <string, string> properties = new Dictionary <string, string>();
foreach (Element childElement in element.elements())
{
if (PLUGIN_CLASS.Equals(childElement.TagName))
{
plugin.PluginClass = childElement.Text;
}
else if (PROPERTIES.Equals(childElement.TagName))
{
parseProperties(childElement, properties);
}
}
plugin.Properties = properties;
plugins.Add(plugin);
}
/// <summary>
/// parse a <code><process-archive .../></code> element and add it to the list of parsed elements
/// </summary>
protected internal virtual void parseProcessArchive(Element element, IList <ProcessArchiveXml> parsedProcessArchives)
{
ProcessArchiveXmlImpl processArchive = new ProcessArchiveXmlImpl();
processArchive.Name = element.attribute(NAME);
processArchive.TenantId = element.attribute(TENANT_ID);
IList <string> processResourceNames = new List <string>();
IDictionary <string, string> properties = new Dictionary <string, string>();
foreach (Element childElement in element.elements())
{
if (PROCESS_ENGINE.Equals(childElement.TagName))
{
processArchive.ProcessEngineName = childElement.Text;
}
else if (PROCESS.Equals(childElement.TagName) || RESOURCE.Equals(childElement.TagName))
{
processResourceNames.Add(childElement.Text);
}
else if (PROPERTIES.Equals(childElement.TagName))
{
parseProperties(childElement, properties);
}
}
// set properties
processArchive.Properties = properties;
// add collected resource names.
processArchive.ProcessResourceNames = processResourceNames;
// add process archive to list of parsed archives.
parsedProcessArchives.Add(processArchive);
}
public async Task <object> GetProp(string deviceOrGroupName, PROPERTIES property)
{
IDeviceReader device = _all[deviceOrGroupName] as IDeviceReader;
return(await device.GetProp(property));
}
public async Task <Dictionary <PROPERTIES, object> > GetProps(string deviceOrGroupName, PROPERTIES properties)
{
IDeviceReader device = _all[deviceOrGroupName] as IDeviceReader;
return(await device.GetProps(properties));
}
public Dictionary <PROPERTIES, object> GetProps(string deviceOrGroupName, PROPERTIES properties)
{
IDeviceReader device = GetReaderDevice(deviceOrGroupName);
return(device.GetProps(properties).Result);
}
public object GetProp(string deviceOrGroupName, PROPERTIES property)
{
IDeviceReader device = GetReaderDevice(deviceOrGroupName);
return(device.GetProp(property).Result);
}
