private Object getImportConfigurationItem(ImportConfiguration importconfiguration)
{
return(new
{
TableColumn = importconfiguration.TableColumn, SheetColumn = importconfiguration.SheetColumn, UniqueColumn = importconfiguration.UniqueColumn, LastUpdate = importconfiguration.LastUpdate, LastUpdateUser = importconfiguration.LastUpdateUser, Name = importconfiguration.Name, ConcurrencyKey = importconfiguration.ConcurrencyKey == null?null:System.Convert.ToBase64String(importconfiguration.ConcurrencyKey, 0, importconfiguration.ConcurrencyKey.Length), DisplayValue = importconfiguration.DisplayValue, ID = importconfiguration.Id
});
}
public ActionResult DeleteConfirmed(ImportConfiguration importconfiguration, string UrlReferrer)
{
if (!User.CanDelete("ImportConfiguration"))
{
return(RedirectToAction("Index", "Error"));
}
//ImportConfiguration importconfiguration = db.ImportConfigurations.Find(id);
db.Entry(importconfiguration).State = EntityState.Deleted;
db.ImportConfigurations.Remove(importconfiguration);
db.SaveChanges();
if (!string.IsNullOrEmpty(UrlReferrer))
{
return(Redirect(UrlReferrer));
}
if (ViewData["ImportConfigurationParentUrl"] != null)
{
string parentUrl = ViewData["ImportConfigurationParentUrl"].ToString();
ViewData["ImportConfigurationParentUrl"] = null;
return(Redirect(parentUrl));
}
else
{
return(RedirectToAction("Index"));
}
}
public void TransactionEndPartTest()
{
ImportConfiguration config = getTestImportConfig();
StatementTransactionPart part = new StatementTransactionPart(config);
config.ErrorHandling.ImportAsTransaction = true;
string[] parts = part.GetTransactionEndPart()
.Split(new string[] { "\n", "\t" }, StringSplitOptions.None).Where(s => s.Length > 0).ToArray();
Assert.AreEqual(12, parts.Length);
Assert.AreEqual("COMMIT TRANSACTION [ImportTransaction]", parts[0]);
Assert.AreEqual("END TRY", parts[1]);
Assert.AreEqual("BEGIN CATCH", parts[2]);
Assert.AreEqual("ROLLBACK TRANSACTION [ImportTransaction]", parts[3]);
Assert.AreEqual("DECLARE @ErrorMessage NVARCHAR(MAX)", parts[4]);
Assert.AreEqual("DECLARE @ErrorSeverity INT", parts[5]);
Assert.AreEqual("DECLARE @ErrorState INT", parts[6]);
Assert.AreEqual("SET @ErrorMessage = ERROR_MESSAGE()", parts[7]);
Assert.AreEqual("SET @ErrorSeverity = ERROR_SEVERITY()", parts[8]);
Assert.AreEqual("SET @ErrorState = ERROR_STATE()", parts[9]);
Assert.AreEqual("RAISERROR (@ErrorMessage, @ErrorSeverity, @ErrorState)", parts[10]);
Assert.AreEqual("END CATCH", parts[11]);
config.ErrorHandling.ImportAsTransaction = false;
Assert.AreEqual("", part.GetTransactionEndPart());
}
public ActionResult EditWizard([Bind(Include = "Id,ConcurrencyKey,TableColumn,SheetColumn,UniqueColumn,LastUpdate,LastUpdateUser,Name,MappingName,IsDefaultMapping")] ImportConfiguration importconfiguration, string UrlReferrer)
{
if (ModelState.IsValid)
{
db.Entry(importconfiguration).State = EntityState.Modified;
db.SaveChanges();
if (!string.IsNullOrEmpty(UrlReferrer))
{
var uri = new Uri(UrlReferrer);
var query = HttpUtility.ParseQueryString(uri.Query);
if (Convert.ToBoolean(query.Get("IsFilter")) == true)
{
return(RedirectToAction("Index"));
}
else
{
return(Redirect(UrlReferrer));
}
}
else
{
return(RedirectToAction("Index"));
}
}
return(View(importconfiguration));
}
private ImportConfiguration GetConfigurationSetting(string jsonConfigData)
{
var config = new ImportConfiguration();
config = JsonConvert.DeserializeObject <ImportConfiguration>(jsonConfigData);
return(config);
}
public ActionResult Edit([Bind(Include = "Id,ConcurrencyKey,TableColumn,SheetColumn,UniqueColumn,LastUpdate,LastUpdateUser,Name,MappingName,IsDefaultMapping")] ImportConfiguration importconfiguration, string UrlReferrer)
{
if (ModelState.IsValid)
{
string command = Request.Form["hdncommand"];
importconfiguration.LastUpdate = DateTime.UtcNow;
importconfiguration.LastUpdateUser = User.Name;
db.Entry(importconfiguration).State = EntityState.Modified;
db.SaveChanges();
if (command == "Save & Continue")
{
return(RedirectToAction("Edit", new { Id = importconfiguration.Id, UrlReferrer = UrlReferrer }));
}
if (!string.IsNullOrEmpty(UrlReferrer))
{
var uri = new Uri(UrlReferrer);
var query = HttpUtility.ParseQueryString(uri.Query);
if (Convert.ToBoolean(query.Get("IsFilter")) == true)
{
return(RedirectToAction("Index"));
}
else
{
return(Redirect(UrlReferrer));
}
}
else
{
return(RedirectToAction("Index"));
}
}
return(View(importconfiguration));
}
// GET: /ImportConfiguration/EditWizard/5
public ActionResult EditWizard(int?id, string UrlReferrer)
{
if (!User.CanEdit("ImportConfiguration"))
{
return(RedirectToAction("Index", "Error"));
}
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
ImportConfiguration importconfiguration = db.ImportConfigurations.Find(id);
importconfiguration.LastUpdate = DateTime.UtcNow;
importconfiguration.LastUpdateUser = User.Name;
if (importconfiguration == null)
{
return(HttpNotFound());
}
if (UrlReferrer != null)
{
ViewData["ImportConfigurationParentUrl"] = UrlReferrer;
}
if (ViewData["ImportConfigurationParentUrl"] == null && Request.UrlReferrer != null && !Request.UrlReferrer.AbsolutePath.EndsWith("/ImportConfiguration"))
{
ViewData["ImportConfigurationParentUrl"] = Request.UrlReferrer;
}
return(View(importconfiguration));
}
// GET: /ImportConfiguration/Edit/5
public ActionResult Edit(int?id, string UrlReferrer)
{
if (!User.CanEdit("ImportConfiguration"))
{
return(RedirectToAction("Index", "Error"));
}
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
ImportConfiguration importconfiguration = db.ImportConfigurations.Find(id);
if (importconfiguration == null)
{
return(HttpNotFound());
}
if (UrlReferrer != null)
{
ViewData["ImportConfigurationParentUrl"] = UrlReferrer;
}
if (ViewData["ImportConfigurationParentUrl"] == null && Request.UrlReferrer != null && !Request.UrlReferrer.AbsolutePath.EndsWith("/ImportConfiguration") && !Request.UrlReferrer.AbsolutePath.EndsWith("/ImportConfiguration/Edit/" + importconfiguration.Id + "") && !Request.UrlReferrer.AbsolutePath.EndsWith("/ImportConfiguration/Create"))
{
ViewData["ImportConfigurationParentUrl"] = Request.UrlReferrer;
}
if (Request.AcceptTypes.Contains("text/html"))
{
return(View(importconfiguration));
}
else if (Request.AcceptTypes.Contains("application/json"))
{
var Result = getImportConfigurationItem(importconfiguration);
return(Json(Result, "application/json", System.Text.Encoding.UTF8, JsonRequestBehavior.AllowGet));
}
return(View(importconfiguration));
}
public ActionResult Create([Bind(Include = "Id,ConcurrencyKey,TableColumn,SheetColumn,UniqueColumn,LastUpdate,LastUpdateUser,Name,MappingName,IsDefaultMapping")] ImportConfiguration importconfiguration, string UrlReferrer, bool?IsDDAdd)
{
if (ModelState.IsValid)
{
string command = Request.Form["hdncommand"];
importconfiguration.LastUpdate = DateTime.UtcNow;
importconfiguration.LastUpdateUser = User.Name;
db.ImportConfigurations.Add(importconfiguration);
db.SaveChanges();
if (command == "Create & Continue")
{
return(RedirectToAction("Edit", new { Id = importconfiguration.Id, UrlReferrer = UrlReferrer }));
}
if (!string.IsNullOrEmpty(UrlReferrer))
{
return(Redirect(UrlReferrer));
}
else
{
return(RedirectToAction("Index"));
}
}
if (IsDDAdd != null)
{
ViewBag.IsDDAdd = Convert.ToBoolean(IsDDAdd);
}
return(View(importconfiguration));
}
public void TableBodyPartInsertTest()
{
DBTable table = new DBTable("dbo", "TestTable");
DBColumn col1 = new DBColumn(table, "TestCol1", true, DBDatatype.integer);
DBColumn col2 = new DBColumn(table, "TestCol2", false, DBDatatype.nvarchar);
table.Columns = new List <DBColumn>()
{
col1, col2
};
ColumnMapping colMap1 = new NullColumnMapping(col1, ColumnUse.Exclude);
ColumnMapping colMap2 = new LiteralColumnMapping("2", LiteralType.String, col2, ColumnUse.Insert);
TableMapping tableMapping = new TableMapping(table, TableMappingImportType.Insert, new ColumnMapping[] { colMap1, colMap2 });
ImportConfiguration config = getTestImportConfig();
SourceDataEntry[] entries = new SourceDataEntry[] { SourceDataEntry.CreateDataEntry("", DataType.String, "") };
SourceDataRow[] rows = new SourceDataRow[] { new SourceDataRow(entries, "0") };
SourceDataTable dt = new SourceDataTable(rows, new string[] { "" });
StatementTableMappingPart part = new StatementTableMappingPart(tableMapping, dt.GetDataRow(0));
string[] bodyParts = part.GetStatementBodyPart().Split(new string[] { "\n" }, StringSplitOptions.None).Where(s => s.Length > 0).ToArray();
Assert.AreEqual(3, bodyParts.Length);
Assert.AreEqual("INSERT INTO dbo.TestTable (TestCol2)", bodyParts[0]);
Assert.AreEqual("OUTPUT inserted.TestCol1, inserted.TestCol2 INTO @sqlimport_table_" + tableMapping.TableMappingReference.Replace(".", "_") +
"(TestCol1, TestCol2)", bodyParts[1]);
Assert.AreEqual("VALUES ('2')", bodyParts[2]);
}
public void DBNamePartTest()
{
ImportConfiguration config = getTestImportConfig();
StatementSetupPart part = new StatementSetupPart(config);
Assert.AreEqual("USE " + dbName, part.GetDatabasePart());
}
public void TableVariablePartTest()
{
DBTable table = new DBTable("dbo", "TestTable");
DBColumn col1 = new DBColumn(table, "TestCol1", true, DBDatatype.integer);
DBColumn col2 = new DBColumn(table, "TestCol2", false, DBDatatype.nvarchar);
table.Columns = new List <DBColumn>()
{
col1, col2
};
ColumnMapping colMap1 = new LiteralColumnMapping("1", LiteralType.Integer, col1, ColumnUse.Exclude);
ColumnMapping colMap2 = new LiteralColumnMapping("2", LiteralType.String, col2, ColumnUse.Insert);
TableMapping tableMapping = new TableMapping(table, TableMappingImportType.Insert, new ColumnMapping[] { colMap1, colMap2 });
ImportConfiguration config = getTestImportConfig();
StatementTableMappingPart part = new StatementTableMappingPart(tableMapping, null);
string partStatement = part.GetTableVariablePart().Replace("\n", "");
Assert.AreEqual("DECLARE @sqlimport_table_" + tableMapping.TableMappingReference.Replace(".", "_") + " TABLE (TestCol1 integer, TestCol2 nvarchar(max))",
partStatement);
}
public ImportViewModel(ImportConfiguration config, IDataReader reader, Database database)
{
this.config = config;
this.reader = reader;
this.database = database;
bw.WorkerSupportsCancellation = false;
bw.WorkerReportsProgress = true;
bw.DoWork += new DoWorkEventHandler(bw_DoWork);
bw.RunWorkerCompleted += new RunWorkerCompletedEventHandler(bw_DoWorkCompleted);
}
public JsonResult ImportFinalizeDelete(ImportConfiguration configuration)
{
var providerPair = FetchProviderPair(configuration.ProviderConfigName);
var selectedLocale = new Locale(configuration.Locale);
foreach (var delete in configuration.Data)
{
providerPair.ValueManager.DeleteValue(new Qualifier.Unique(Part.Parse(delete.Part), selectedLocale, delete.Key));
}
return(Json(new { ok = true }));
}
public void TransactionStartPartTest()
{
ImportConfiguration config = getTestImportConfig();
StatementTransactionPart part = new StatementTransactionPart(config);
config.ErrorHandling.ImportAsTransaction = true;
Assert.AreEqual("BEGIN TRANSACTION [ImportTransaction]\nBEGIN TRY\n", part.GetTransactionStartPart());
config.ErrorHandling.ImportAsTransaction = false;
Assert.AreEqual("", part.GetTransactionStartPart());
}
public void WarningsPartTest()
{
ImportConfiguration config = getTestImportConfig();
config.ErrorHandling.IgnoreWarnings = false;
StatementSetupPart part = new StatementSetupPart(config);
Assert.AreEqual("SET ANSI_WARNINGS ON", part.GetWarningsPart());
config.ErrorHandling.IgnoreWarnings = true;
Assert.AreEqual("SET ANSI_WARNINGS OFF", part.GetWarningsPart());
}
public JsonResult ImportFinalizeUpdate(ImportConfiguration configuration)
{
var providerPair = FetchProviderPair(configuration.ProviderConfigName);
var selectedLocale = new Locale(configuration.Locale);
foreach (var update in configuration.Data)
{
providerPair.ValueManager.UpdateCreateValue(new QualifiedValue(
new Qualifier.Unique(Part.Parse(update.Part), selectedLocale, update.Key),
new Value(ContentType.Unspecified, update.Value)
));
}
return(Json(new { ok = true }));
}
public void TimeoutTest()
{
string hostNameDoesntExist = "testest";
ConnectionSetup connectionSetup = new ConnectionSetup(hostNameDoesntExist, "", "", true);
connectionSetup.Timeout = 1;
ImportConfiguration config = new ImportConfiguration(null, connectionSetup, "", null);
ImportStatement[] statements = new ImportStatement[0];
SQLServerDataImporter importer = new SQLServerDataImporter(config);
importer.ImportData(statements);
}
public ArgumentRouter(string[] args, ImportConfiguration config)
{
PrintHeader();
this.ImportConfiguration = config;
var commandLineParser = new Parser(x =>
{
x.HelpWriter = null;
x.IgnoreUnknownArguments = false;
});
commandLineParser.ParseArguments <Options>(args)
.WithParsed <Options>(x => Execute(x))
.WithNotParsed <Options>((errs) => PrintHelp(errs));
}
public ActionResult CreateQuick([Bind(Include = "Id,ConcurrencyKey,TableColumn,SheetColumn,UniqueColumn,Name,MappingName,IsDefaultMapping")] ImportConfiguration importconfiguration, string UrlReferrer, bool?IsAddPop)
{
if (ModelState.IsValid)
{
importconfiguration.LastUpdate = DateTime.UtcNow;
importconfiguration.LastUpdateUser = User.Name;
db.ImportConfigurations.Add(importconfiguration);
db.SaveChanges();
//if (IsAddPop != null && IsAddPop == true)
// return Json("FROMPOPUP", "application/json", System.Text.Encoding.UTF8, JsonRequestBehavior.AllowGet);
//else
//return Redirect(Request.UrlReferrer.ToString());
return(Json("FROMPOPUP", "application/json", System.Text.Encoding.UTF8, JsonRequestBehavior.AllowGet));
}
return(View(importconfiguration));
}
internal void SaveConfiguration()
{
try
{
TableMapping[] tableMappings = mappingPageViewModel.TableMappingViewModels.Select(t => t.TableMapping).ToArray();
ImportConfiguration config = new ImportConfiguration(tableMappings, connectionPageViewModel.DatabaseConnector.ConnectionSetup,
connectionPageViewModel.SelectedDatabase.Name, importPageViewModel.ErrorHandling);
ConfigurationSaver saver = new ConfigurationSaver(config, configurationPath);
saver.Save();
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "Error", MessageBoxButton.OK, MessageBoxImage.Error);
}
}
public JsonResult GetLockBusinessRules(ImportConfiguration OModel)
{
string RulesApplied = "";
if (User.businessrules != null)
{
var BR = User.businessrules.Where(p => p.EntityName == "ImportConfiguration").ToList();
if (BR != null && BR.Count > 0)
{
var ResultOfBusinessRules = db.LockEntityRule(OModel, BR, "ImportConfiguration");
BR = BR.Where(p => ResultOfBusinessRules.Values.Select(x => x.BRID).ToList().Contains(p.Id)).ToList();
if (ResultOfBusinessRules.Keys.Select(p => p.TypeNo).Contains(1))
{
RulesApplied = string.Join(",", BR.Select(p => p.RuleName).ToArray());
}
}
}
return(Json(RulesApplied, JsonRequestBehavior.AllowGet));
}
public ActionResult CreateWizard([Bind(Include = "Id,ConcurrencyKey,TableColumn,SheetColumn,UniqueColumn,LastUpdate,LastUpdateUser,Name,MappingName,IsDefaultMapping")] ImportConfiguration importconfiguration, string UrlReferrer)
{
if (ModelState.IsValid)
{
importconfiguration.LastUpdate = DateTime.UtcNow;
importconfiguration.LastUpdateUser = User.Name;
db.ImportConfigurations.Add(importconfiguration);
db.SaveChanges();
if (!string.IsNullOrEmpty(UrlReferrer))
{
return(Redirect(UrlReferrer));
}
else
{
return(RedirectToAction("Index"));
}
}
return(View(importconfiguration));
}
private ImportConfiguration createImportConfiguration()
{
if (wizardViewModel.ConnectionPageViewModel.DatabaseConnector == null)
{
throw new Exception("Not connected to any database");
}
else if (wizardViewModel.MappingPageViewModel.TableMappings.Count < 1)
{
throw new Exception("There are no table mappings");
}
else
{
TableMapping[] tableMappings = wizardViewModel.MappingPageViewModel.TableMappingViewModels.Select(t => t.TableMapping).ToArray();
ImportConfiguration config = new ImportConfiguration(tableMappings, wizardViewModel.ConnectionPageViewModel.DatabaseConnector.ConnectionSetup,
wizardViewModel.ConnectionPageViewModel.SelectedDatabase.Name, errorHandling);
return(config);
}
}
public void TableMappingPartConstructorTest()
{
DBTable table = new DBTable("dbo", "TestTable");
DBColumn col1 = new DBColumn(table, "TestCol1", false, DBDatatype.integer);
DBColumn col2 = new DBColumn(table, "TestCol2", false, DBDatatype.nvarchar);
table.Columns = new List <DBColumn>()
{
col1, col2
};
ColumnMapping colMap1 = new LiteralColumnMapping("1", LiteralType.Integer, col1, ColumnUse.Exclude);
ColumnMapping colMap2 = new LiteralColumnMapping("2", LiteralType.String, col2, ColumnUse.Insert);
TableMapping tableMapping = new TableMapping(table, TableMappingImportType.Insert, new ColumnMapping[] { colMap1, colMap2 });
ImportConfiguration config = getTestImportConfig();
StatementTableMappingPart part = new StatementTableMappingPart(tableMapping, null);
}
public ImportConfiguration Execute(ImportType type, string path, int datasetId, Action <string> progressCallback)
{
this.progressCallbackAction = progressCallback;
this.config = new ImportConfiguration();
this.config.ImportType = type;
this.originalPath = path;
progressCallback("Preparing to load data...");
using (var sourceDataConnection = this.GetSourceConnection(path))
using (var targetSqlConnection = this.GetTargetConnection())
using (var workingTable = this.GetWorkingTable(targetSqlConnection))
using (var session = SessionFactoryProvider.SessionFactory.OpenStatelessSession(targetSqlConnection))
{
// prepare bulk loader
var bulkLoader = new SqlBulkCopy(targetSqlConnection);
bulkLoader.DestinationTableName = TargetTableName;
foreach (var cmd in this.GetImportCommands(datasetId))
{
int ct;
if (cmd.ExecuteAgainstTarget)
{
ct = session
.CreateSQLQuery(cmd.Command)
.ExecuteUpdate();
}
else
{
ct = this.GetImportBatch(cmd, bulkLoader, workingTable, sourceDataConnection, datasetId);
}
progressCallback(string.Format("{0} ({1} rows loaded)", cmd.Description, ct));
}
}
return(this.config);
}
// GET: /ImportConfiguration/Delete/5
public ActionResult Delete(int id)
{
if (!User.CanDelete("ImportConfiguration"))
{
return(RedirectToAction("Index", "Error"));
}
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
ImportConfiguration importconfiguration = db.ImportConfigurations.Find(id);
if (importconfiguration == null)
{
throw(new Exception("Deleted"));
}
if (ViewData["ImportConfigurationParentUrl"] == null && Request.UrlReferrer != null && !Request.UrlReferrer.AbsolutePath.EndsWith("/ImportConfiguration"))
{
ViewData["ImportConfigurationParentUrl"] = Request.UrlReferrer;
}
return(View(importconfiguration));
}
public void TableBodyPartUpdateTest()
{
DBTable table = new DBTable("dbo", "TestTable");
DBColumn col1 = new DBColumn(table, "TestCol1", true, DBDatatype.integer);
DBColumn col2 = new DBColumn(table, "TestCol2", false, DBDatatype.nvarchar);
DBColumn col3 = new DBColumn(table, "TestCol3", false, DBDatatype.integer);
table.Columns = new List <DBColumn>()
{
col1, col2, col3
};
TableMapping sourceTablemapping = new TableMapping(new DBTable("dbo", "TestTable2"), TableMappingImportType.Insert, null);
ColumnMapping colMap1 = new TableColumnMapping(sourceTablemapping, col1, col1, ColumnUse.Where);
ColumnMapping colMap2 = new LiteralColumnMapping("2", LiteralType.String, col2, ColumnUse.Where);
ColumnMapping colMap3 = new LiteralColumnMapping("3", LiteralType.String, col3, ColumnUse.Set);
TableMapping tableMapping = new TableMapping(table, TableMappingImportType.Update, new ColumnMapping[] { colMap1, colMap2, colMap3 });
ImportConfiguration config = getTestImportConfig();
SourceDataEntry[] entries = new SourceDataEntry[] { SourceDataEntry.CreateDataEntry("", DataType.String, "") };
SourceDataRow[] rows = new SourceDataRow[] { new SourceDataRow(entries, "0") };
SourceDataTable dt = new SourceDataTable(rows, new string[] { "" });
StatementTableMappingPart part = new StatementTableMappingPart(tableMapping, dt.GetDataRow(0));
string[] bodyParts = part.GetStatementBodyPart().Split(new string[] { "\n" }, StringSplitOptions.None).Where(s => s.Length > 0).ToArray();
Assert.AreEqual(4, bodyParts.Length);
Assert.AreEqual("UPDATE dbo.TestTable", bodyParts[0]);
Assert.AreEqual("SET TestCol3='3'", bodyParts[1]);
Assert.AreEqual("OUTPUT inserted.TestCol1, inserted.TestCol2, inserted.TestCol3 INTO @sqlimport_table_" +
tableMapping.TableMappingReference.Replace(".", "_") + "(TestCol1, TestCol2, TestCol3)", bodyParts[2]);
Assert.AreEqual("WHERE TestCol1 = (SELECT TOP 1 t.TestCol1 FROM @sqlimport_table_" +
sourceTablemapping.TableMappingReference.Replace(".", "_") + " t) and TestCol2 = '2'", bodyParts[3]);
}
// GET: /ImportConfiguration/Details/5
public ActionResult Details(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
ImportConfiguration importconfiguration = db.ImportConfigurations.Find(id);
if (importconfiguration == null)
{
return(HttpNotFound());
}
if (Request.AcceptTypes.Contains("text/html"))
{
return(View(importconfiguration));
}
else if (Request.AcceptTypes.Contains("application/json"))
{
var Result = getImportConfigurationItem(importconfiguration);
return(Json(Result, "application/json", System.Text.Encoding.UTF8, JsonRequestBehavior.AllowGet));
}
return(View(importconfiguration));
}
static int Main(string[] args)
{
Console.SetWindowSize(150, 25);
using (var xml = XElement.Load(_importConfig).CreateReader())
{
ImportConfiguration config = null;
try
{
config = new XmlSerializer(typeof(ImportConfiguration)).Deserialize(xml) as ImportConfiguration;
}
catch (Exception exception)
{
Logger.Log($"Error reading configuration '{_importConfig}'. Exception: {exception.Message}", LogLevel.Debug);
return(-1);
}
var cli = new ArgumentRouter(args, config);
}
Console.ReadKey();
return(0);
}
public JsonResult ImportFinalizeInsert(ImportConfiguration configuration)
{
var providerPair = FetchProviderPair(configuration.ProviderConfigName);
var selectedLocale = new Locale(configuration.Locale);
foreach (var insert in configuration.Data) {
providerPair.ValueManager.CreateValue(
new Qualifier.Unique(Part.Parse(insert.Part), selectedLocale, insert.Key),
insert.Value
);
}
return Json(new { ok = true });
}
public JsonResult ImportFinalizeUpdate(ImportConfiguration configuration)
{
var providerPair = FetchProviderPair(configuration.ProviderConfigName);
var selectedLocale = new Locale(configuration.Locale);
foreach (var update in configuration.Data) {
providerPair.ValueManager.UpdateCreateValue(new QualifiedValue(
new Qualifier.Unique(Part.Parse(update.Part), selectedLocale, update.Key),
new Value(ContentType.Unspecified, update.Value)
));
}
return Json(new { ok = true });
}
