private void simpleButton2_Click(object sender, EventArgs e)
{
if (!CheckParams())
{
return;
}
if (MessageBox.Show(String.Format("Procedere all'aggiornamento della base dati: {0}?", comboBoxEdit1.Text), "Domanda", MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes)
{
string fileName = String.Format("{0}\\logImport{1}.txt", Environment.GetFolderPath(Environment.SpecialFolder.DesktopDirectory), comboBoxEdit1.Text);
abstractImporter exp = ImportFactory.GetImporter(comboBoxEdit1.Text, _connectioString, _fileDBname);
exp.Import(Convert.ToInt32(cboAnno.Text));
//notifico all'utente
string logTotal = exp.Log;
if (string.IsNullOrEmpty(logTotal))
{
MessageBox.Show("Importazione avvenuta con successo");
File.AppendAllText(fileName, "Importazione avvenuta con successo");
return;
}
MessageBox.Show("Importazione avvenuta con errori. Consultare il log");
File.AppendAllText(fileName, logTotal);
}
}
private List <ApiOperation> Import(int bankId, List <string> lines)
{
var ignored = Schematics.Where(t => t.Type.Id == 1);
var importFactory = ImportFactory.GetFactory(GetBanks(bankId).Name);
var importer = importFactory.CreateImporter();
var transactions = new List <Transaction>();
transactions.AddRange(importer.ReadTransactions(lines));
foreach (var ignoredItem in ignored)
{
if (ignoredItem.Context.DescriptionRegex == "")
{
ignoredItem.Context.DescriptionRegex = ".*";
}
if (ignoredItem.Context.TitleRegex == "")
{
ignoredItem.Context.TitleRegex = ".*";
}
transactions = transactions.Where(t => !Regex.Match(t.ContractorData, ignoredItem.Context.DescriptionRegex).Success || !Regex.Match(t.Title, ignoredItem.Context.TitleRegex).Success).ToList();
}
transactions.Reverse();
var mapper = new TransactionsToApiOperationsMapper();
mapper.setSchematics(Schematics.Where(t => t.Type.Id == 2));
var a = mapper.ConvertToEntitiesCollection(transactions, User, Importances, Frequencies, Tags, TransactionTypes, TransferTypes).ToList();
return(a);
}
public static List <Operation> Import()
{
var ignored = ConfigurationManager.IgnoredTransaction();
var importFactory = ImportFactory.GetFactory(ConfigurationManager.BankName());
var importer = importFactory.CreateImporter();
var transactions = new List <Transaction>();
var path = ConfigurationManager.PathToImportFiles();
foreach (string file in Directory.EnumerateFiles(path, "*.csv"))
{
transactions.AddRange(importer.ReadTransactions(file));
File.Move(file, file + ".taken");
foreach (var ignoredItem in ignored)
{
if (ignoredItem.DescriptionRegex == "")
{
ignoredItem.DescriptionRegex = ".*";
}
if (ignoredItem.TitleRegex == "")
{
ignoredItem.TitleRegex = ".*";
}
transactions = transactions.Where(t => !Regex.Match(t.ContractorData, ignoredItem.DescriptionRegex).Success || !Regex.Match(t.Title, ignoredItem.TitleRegex).Success).ToList();
transactions.Reverse();
}
}
return(new TransactionToOperationMapper().ConvertToEntitiesCollection(transactions, User, Importances, Frequencies, Tags, TransactionTypes, TransferTypes).ToList());
}
public async Task <IActionResult> Connect([Bind("ID, Credential, Issues")] Project project)
{
if (ModelState.IsValid)
{
importService = ImportFactory.GetImportFrom("jira");
//importService.Connect(new Credential()
//{
// Uri = "https://queryexport.atlassian.net",
// Username = "******",
// Password = "******"
//});
//if (project.ID == 0)
//{
// _context.Add(project);
// await _context.SaveChangesAsync();
//}
importService.Connect(new Credential()
{
Uri = project.Credential.Uri,
Username = project.Credential.Username,
Password = project.Credential.Password
});
var res = await importService.GetIssuesForProject();
project.Issues = res;
_context.Add(project);
await _context.SaveChangesAsync();
}
return(RedirectToAction("Index"));
}
public void TestEmptyFactory()
{
//var import = ImportFactory.GetImportFrom(string.Empty);
Exception ex = Assert.Throws <Exception>(() => ImportFactory.GetImportFrom(string.Empty));
Assert.Equal("Unknown file type: !", ex.Message);
}
protected void ProcessChannel(Channel channel)
{
//export data
CommonParser <CanonChannelMonitor> export = ImportFactory.GetParser(
(Canon.Data.Enums.ChannelTypeEnum)channel.InfoType,
channel.ChannelId,
channel.Url,
CanonConfigManager.UploadDataFolder,
channel.AdditionalCommand);
export.Logger = logger;
if (!export.ExportToDb())
{
return;
}
logger.Info(string.Format("Export to DB finished."));
try
{
CanonChannelMapping map = new CanonChannelMapping(channel.ChannelId);
map.CleanNotExistingProducts();
map.UpdateRelevances();
logger.Info(string.Format("Relevance points were updated."));
map.MarkRecommendeedRelevances();
logger.Info(string.Format("The best relevanced pairs were chosen."));
//Create new mapping rules for all channels
map.CreateNewMappingRules();
logger.Info(string.Format("New mapping rules has been created."));
//Update main monitor
map.UpdateMonitor();
logger.Info(string.Format("Main monitor has been updated."));
}
catch (Exception ex)
{
//into db log
int id = CanonProductsLog.AddImportLog(ChannelLogEnum.ChannelError,
channel.ChannelId, export.TryedRecords, export.SuccessRecords);
CanonProductsLog.AddImportErrorsLog(id, ChannelErrorEnum.ChannelMappingError, string.Empty);
logger.Fatal(ex);
}
//into db log
CanonProductsLog.AddImportLog(ChannelLogEnum.ImportOk,
channel.ChannelId, export.TryedRecords, export.SuccessRecords);
logger.Info(string.Format("Export finished: {0}, {1}, {2}",
channel.ChannelId, channel.ChannelName, channel.Url));
}
public void Test_Import()
{
var result = ImportFactory.CreateExcel2007Import(@"D:\Test_Data\Npoi_Demo.xlsx")
.GetResult <SimpleImprotModel>();
foreach (var item in result)
{
Output.WriteLine($"标识:{item.Id},名称:{item.Name},城市:{item.City}");
}
}
/// <summary>
/// Initializes a new instance of the <see cref="ImportProcessContext" /> class.
/// </summary>
/// <param name="definition">The definition.</param>
/// <param name="importData">The import data.</param>
/// <param name="userName">Name of the user.</param>
/// <param name="importFactory">The import service factory.</param>
public ImportProcessContext(ImportDefinition definition, ImportData importData, string userName, ImportFactory importFactory)
{
Definition = definition;
_serviceCache = new Dictionary <Type, object>();
ImportData = importData;
UserName = userName;
_importFactory = importFactory;
Errors = new List <Exception>();
_mappedFields = new Lazy <IReadOnlyList <ImportFieldMapping> >(GetMappedFields);
}
//todo: don't save the changes untill the save button clicked
public void Import(string fileName, ILogPrint log, IShowProgress showProgress)
{
var importer = ImportFactory.GetImporter(File.Type, fileName);
importer.IgnoreSaveData = true;
importer.Print = log;
importer.ShowProgress = showProgress;
importer.FileId = FileId;
importer.Context = Context;
importer.Import();
}
/// <summary>
/// Выбор файла
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void buttonSelect_Click(object sender, EventArgs e)
{
OpenFileDialog of = new OpenFileDialog();
of.InitialDirectory = Vars.Options.LastDirectory;
of.Multiselect = false;
if (of.ShowDialog() == DialogResult.OK)
{
fileName = of.FileName;
importer = ImportFactory.CreateImporter(fileName, importer);
labelPath.Text = Path.GetFileName(fileName);
new ToolTip().SetToolTip(labelPath, fileName);
Vars.Options.LastDirectory = Path.GetDirectoryName(fileName);
this.updateUI();
}
}
public ShoppingResult Compute()
{
TaxCalculator basicCalculator = BasicFactory.CreateFactory();
TaxCalculator importCalculator = ImportFactory.CreateFactory();
var totalBasicTax = 0.0m;
var totalImportTax = 0.0m;
shoppingResult.TotalWithoutTax = preparedCart.Sum(x => x.Price);
shoppingResult.ItemsBilled = preparedCart;
shoppingResult.TaxDetail = new List <TaxDetail>();
foreach (var item in preparedCart)
{
if (!item.IsExempted())
{
totalBasicTax += basicCalculator.GetTaxAmount(item);
TaxDetail.BasicTaxAmount = basicCalculator.GetTaxAmount(item);
}
else
{
TaxDetail.BasicTaxAmount = 0.0m;
}
if (item.IsImported)
{
totalImportTax += importCalculator.GetTaxAmount(item);
TaxDetail.ImportTaxAmount = importCalculator.GetTaxAmount(item);
}
shoppingResult.TaxDetail.Add(TaxDetail);
}
shoppingResult.TotalImportTax = totalImportTax;
shoppingResult.TotalSalesTax = totalBasicTax;
shoppingResult.TotalTax = totalImportTax + totalBasicTax;
shoppingResult.Total = shoppingResult.TotalWithoutTax + totalImportTax + totalBasicTax;
return(shoppingResult);
}
private void OnTemplateTypeChanged()
{
TemplateColumns.Clear();
PropertyNames.Clear();
var allProps = ImportFactory.GetEditableProperties(TemplateType);
foreach (var prop in allProps)
{
PropertyNames.Add(prop.Name);
}
var requiredProperties = ImportFactory.GetRequiredProperties(TemplateType);
foreach (var prop in requiredProperties)
{
TemplateColumns.Add(new TemplateColumn()
{
IsRequired = true,
IsMandatory = true,
PropertyName = prop.Name,
ColumnName = prop.Name
});
}
}
public void Start()
{
_importers = (from importerConfig in Config.Importers
select ImportFactory.Create(importerConfig)).ToList();
}
/// <summary>
/// Initializes a new instance of the <see cref="ImportProcessor" /> class.
/// </summary>
/// <param name="dataSession">The data session.</param>
/// <param name="importFactory">The service provider factory.</param>
public ImportProcessor(IDataSession dataSession, ImportFactory importFactory)
{
_dataSession = dataSession;
_importFactory = importFactory;
}
public static void Main(string[] args)
{
// initialize logger
Logger.InitializeLogger(LogManager.GetLogger(typeof(Program)));
Assembly assembly = Assembly.GetExecutingAssembly();
FileVersionInfo fileVersionInfo = FileVersionInfo.GetVersionInfo(assembly.Location);
Console.Title = $@"[N#] Parser";
if (DataAccessHelper.Initialize())
{
RegisterMappings();
}
var key = new ConsoleKeyInfo();
Logger.Log.Warn(Language.Instance.GetMessageFromKey("NEED_TREE"));
Console.BackgroundColor = ConsoleColor.Blue;
Console.WriteLine(@"Root");
Console.ResetColor();
Console.WriteLine($@"-----_code_{ConfigurationManager.AppSettings["Language"]}_Card.txt");
Console.WriteLine($@"-----_code_{ConfigurationManager.AppSettings["Language"]}_Item.txt");
Console.WriteLine($@"-----_code_{ConfigurationManager.AppSettings["Language"]}_MapIDData.txt");
Console.WriteLine($@"-----_code_{ConfigurationManager.AppSettings["Language"]}_monster.txt");
Console.WriteLine($@"-----_code_{ConfigurationManager.AppSettings["Language"]}_Skill.txt");
Console.WriteLine(@"-----packet.txt");
Console.WriteLine(@"-----Card.dat");
Console.WriteLine(@"-----Item.dat");
Console.WriteLine(@"-----MapIDData.dat");
Console.WriteLine(@"-----monster.dat");
Console.WriteLine(@"-----Skill.dat");
Console.WriteLine(@"-----quest.dat");
Console.WriteLine(@"-----qstprize.dat");
Console.BackgroundColor = ConsoleColor.Blue;
Console.WriteLine(@"-----map");
Console.ResetColor();
Console.WriteLine(@"----------0");
Console.WriteLine(@"----------1");
Console.WriteLine(@"----------...");
try
{
Logger.Log.Warn(Language.Instance.GetMessageFromKey("ENTER_PATH"));
string folder = string.Empty;
if (args.Length == 0)
{
folder = Console.ReadLine();
Console.WriteLine($@"{Language.Instance.GetMessageFromKey("PARSE_ALL")} [Y/n]");
key = Console.ReadKey(true);
}
else
{
folder = args.Aggregate(folder, (current, str) => current + str + " ");
}
var factory = new ImportFactory(folder);
factory.ImportPackets();
if (key.KeyChar != 'n')
{
factory.ImportMaps();
factory.LoadMaps();
factory.ImportCards();
factory.ImportRespawnMapType();
factory.ImportMapType();
factory.ImportMapTypeMap();
ImportFactory.ImportAccounts();
factory.ImportPortals();
factory.ImportScriptedInstances();
factory.ImportItems();
factory.ImportSkills();
factory.ImportNpcMonsters();
factory.ImportNpcMonsterData();
factory.ImportMapNpcs();
factory.ImportMonsters();
factory.ImportShops();
factory.ImportTeleporters();
factory.ImportShopItems();
factory.ImportShopSkills();
factory.ImportRecipe();
factory.ImportHardcodedItemRecipes();
factory.ImportQuests();
}
else
{
Console.WriteLine($@"{Language.Instance.GetMessageFromKey("PARSE_MAPS")} [Y/n]");
key = Console.ReadKey(true);
if (key.KeyChar != 'n')
{
factory.ImportMaps();
factory.LoadMaps();
}
Console.WriteLine($@"{Language.Instance.GetMessageFromKey("PARSE_MAPTYPES")} [Y/n]");
key = Console.ReadKey(true);
if (key.KeyChar != 'n')
{
factory.ImportMapType();
factory.ImportMapTypeMap();
}
Console.WriteLine($@"{Language.Instance.GetMessageFromKey("PARSE_ACCOUNTS")} [Y/n]");
key = Console.ReadKey(true);
if (key.KeyChar != 'n')
{
ImportFactory.ImportAccounts();
}
Console.WriteLine($@"{Language.Instance.GetMessageFromKey("PARSE_PORTALS")} [Y/n]");
key = Console.ReadKey(true);
if (key.KeyChar != 'n')
{
factory.ImportPortals();
}
Console.WriteLine($@"{Language.Instance.GetMessageFromKey("PARSE_TIMESPACES")} [Y/n]");
key = Console.ReadKey(true);
if (key.KeyChar != 'n')
{
factory.ImportScriptedInstances();
}
Console.WriteLine($@"{Language.Instance.GetMessageFromKey("PARSE_ITEMS")} [Y/n]");
key = Console.ReadKey(true);
if (key.KeyChar != 'n')
{
factory.ImportItems();
}
Console.WriteLine($@"{Language.Instance.GetMessageFromKey("PARSE_NPCMONSTERS")} [Y/n]");
key = Console.ReadKey(true);
if (key.KeyChar != 'n')
{
factory.ImportNpcMonsters();
}
Console.WriteLine($@"{Language.Instance.GetMessageFromKey("PARSE_NPCMONSTERDATA")} [Y/n]");
key = Console.ReadKey(true);
if (key.KeyChar != 'n')
{
factory.ImportNpcMonsterData();
}
Console.WriteLine($@"{Language.Instance.GetMessageFromKey("PARSE_CARDS")} [Y/n]");
key = Console.ReadKey(true);
if (key.KeyChar != 'n')
{
factory.ImportCards();
}
Console.WriteLine($@"{Language.Instance.GetMessageFromKey("PARSE_SKILLS")} [Y/n]");
key = Console.ReadKey(true);
if (key.KeyChar != 'n')
{
factory.ImportSkills();
}
Console.WriteLine($@"{Language.Instance.GetMessageFromKey("PARSE_MAPNPCS")} [Y/n]");
key = Console.ReadKey(true);
if (key.KeyChar != 'n')
{
factory.ImportMapNpcs();
}
Console.WriteLine($@"{Language.Instance.GetMessageFromKey("PARSE_MONSTERS")} [Y/n]");
key = Console.ReadKey(true);
if (key.KeyChar != 'n')
{
factory.ImportMonsters();
}
Console.WriteLine($@"{Language.Instance.GetMessageFromKey("PARSE_SHOPS")} [Y/n]");
key = Console.ReadKey(true);
if (key.KeyChar != 'n')
{
factory.ImportShops();
}
Console.WriteLine($@"{Language.Instance.GetMessageFromKey("PARSE_TELEPORTERS")} [Y/n]");
key = Console.ReadKey(true);
if (key.KeyChar != 'n')
{
factory.ImportTeleporters();
}
Console.WriteLine($@"{Language.Instance.GetMessageFromKey("PARSE_SHOPITEMS")} [Y/n]");
key = Console.ReadKey(true);
if (key.KeyChar != 'n')
{
factory.ImportShopItems();
}
Console.WriteLine($@"{Language.Instance.GetMessageFromKey("PARSE_SHOPSKILLS")} [Y/n]");
key = Console.ReadKey(true);
if (key.KeyChar != 'n')
{
factory.ImportShopSkills();
}
Console.WriteLine($@"{Language.Instance.GetMessageFromKey("PARSE_RECIPES")} [Y/n]");
key = Console.ReadKey(true);
if (key.KeyChar != 'n')
{
factory.ImportRecipe();
}
Console.WriteLine($@"{Language.Instance.GetMessageFromKey("PARSE_HARDCODED_RECIPES")} [Y/n]");
key = Console.ReadKey(true);
if (key.KeyChar != 'n')
{
factory.ImportHardcodedItemRecipes();
}
Console.WriteLine($@"{Language.Instance.GetMessageFromKey("PARSE_QUESTS")} [Y/n]");
key = Console.ReadKey(true);
if (key.KeyChar != 'n')
{
factory.ImportQuests();
}
}
Console.WriteLine($@"{Language.Instance.GetMessageFromKey("DONE")}");
Thread.Sleep(5000);
}
catch (FileNotFoundException)
{
Logger.Log.Error(Language.Instance.GetMessageFromKey("AT_LEAST_ONE_FILE_MISSING"));
Thread.Sleep(5000);
}
}
public void Launch(ConnectionPack input)
{
bool _stateful = false;
bool firstOP = false;
string cmd = input.Cmd;
List <string> urls = input.ListUrls;
List <string> downstreamUrls = input.ReplicaUrlsOutput;
// in order to make a custom import for the first operator
if (input.RoutingTypeToReadFromFile != null)
{
firstOP = true;
}
// split command by keywords
string pattern = @"INPUT OPS|REP FACT|ROUTING|ADDRESS|OPERATOR SPEC";
string[] tokens = Regex.Split(cmd, pattern, RegexOptions.IgnoreCase).Where(s => s != String.Empty).ToArray <string>();
// splitting by 5 keywords should generate 6 tokens
if (tokens.Length != 6)
{
System.Console.WriteLine("Something went wrong while splitting the command!!!");
}
// tokens[0] -> operator name
// tokens[1] -> input file or previous operator
// tokens[2] -> replication factor
// tokens[3] -> routing policy
// tokens[4] -> list of slave's URLs
// tokens[5] -> name of the transformation function (and possibly parameters)
/*** create import object ***/
AbstractFactory importFactory = new ImportFactory();
Import importObj = null;
// tokenize input
string importPattern = @",|\s";
string[] importTokens = Regex.Split(tokens[1], importPattern).Where(s => s != String.Empty).ToArray <string>();
// list to collect possible file paths
List <string> filePathsList = new List <string>();
for (int i = 0; i < importTokens.Length; i++)
{
if (importTokens[i].StartsWith("OP")) // input comes from operator
{
importObj = importFactory.GetImport(new string[] { "OpImport" }, null, 0, 0);
break; // assuming only one operator
}
if (importTokens[i].Contains(".")) // input comes from file
{
filePathsList.Add(importTokens[i]);
}
else
{
Console.WriteLine("Neither operator nor input file!!!");
}
}
/*** create routing object ***/
AbstractFactory routingFactory = new RoutingFactory();
Route routeObj;
// tokenize routing policy
string[] routingTokens;
string routingPattern = @"[)(\s]";
if (input.RoutingType != null)
{
routingTokens = Regex.Split(input.RoutingType, routingPattern).Where(s => s != String.Empty).ToArray <string>();
}
else
{
routingTokens = Regex.Split("Output", routingPattern).Where(s => s != String.Empty).ToArray <string>();
}
routeObj = routingFactory.GetRouting(routingTokens, downstreamUrls, input.Semantic.ToLower());
/*** create processing object ***/
AbstractFactory processingFactory = new ProcessingFactory();
Process processObj;
// tokenize processing function
string processingPattern = @",|\s";
string[] processingTokens = Regex.Split(tokens[5], processingPattern).Where(s => s != String.Empty).ToArray <string>();
// if it's a count operator or a uniq - it needs state - for exactly-once
_stateful = Stateful(processingTokens[0]);
processObj = processingFactory.GetProcessing(processingTokens);
string[] plainUrls = urls.ToArray().Where(s => s != String.Empty).ToArray <string>();
bool wasNull = importObj == null;
foreach (string url in plainUrls)
{
if (wasNull)
{
// tokenize routing policy for the first operator
string[] merge = firstOP ? FileImportRouting(input.RoutingTypeToReadFromFile) : FileImportRouting(input.RoutingType);
// supports both import in the beginning or in the middle
if (input.RoutingType != null)
{
importObj = importFactory.GetImport(merge, filePathsList.ToArray(),
plainUrls.ToList().IndexOf(url), plainUrls.Length);
}
else
{
importObj = importFactory.GetImport(new string[] { "FileImport", "primary" }, filePathsList.ToArray(), plainUrls.ToList().IndexOf(url), plainUrls.Length);
}
}
System.Diagnostics.Process.Start(@"Slave.exe", SerializeObject(importObj) + " " + SerializeObject(routeObj) + " " +
SerializeObject(processObj) + " " + SerializeObject(url) + " " + SerializeObject(input.PuppetMasterUrl) + " " +
SerializeObject(input.IsLogFull) + " " + SerializeObject(input.Semantic.ToLower()) + " " +
SerializeObject(getSiblings(plainUrls, url)) + " " + SerializeObject(_stateful));
}
}
public void TestFactory()
{
var jiraImport = ImportFactory.GetImportFrom("jira");
Assert.True(jiraImport.GetType() == typeof(JiraImport));
}
