/// <summary> /// Gets the field names from a workbook and stores them in a list. /// </summary> /// <param name="fieldNames">list where field names will be stored</param> /// <param name="workbook">workbook from which field names will be extracted</param> public static void GetFieldNames(ImportData data, XSSFWorkbook workbook) { ISheet sheet = workbook.GetSheetAt(0); bool reading = true; int rindex = sheet.FirstRowNum; while (reading) { IRow row = sheet.GetRow(rindex); if (row != null) { ICell cell = row.GetCell(0); if (cell != null) { string s = CellValueAsString(cell); if (s != "" && s[0] == '[') { for (int i = 0; i < row.LastCellNum; i++) { s = CellValueAsString(row.GetCell(i)).TrimEnd(']').TrimStart('['); ; data.fieldNames.Add(s); } // don't read more than one row of field names reading = false; } } } rindex++; if (rindex > sheet.LastRowNum) { reading = false; } } }
public void ReadXlsxTest() { ExcelReader reader = new ExcelReader(); ImportData data = new ImportData(); string testDataLocation = "/Assets/Vendor/DataHelpers/Editor/Tests/Fixtures/TestData.xlsx"; reader.ReadAsset(testDataLocation, ref data); Assert.AreEqual(2, data.vars.Count, "it should load 2 variables"); Assert.AreEqual("100", data.vars["foo1"]); Assert.AreEqual("200", data.vars["foo2"]); Assert.AreEqual(2, data.meta.Count, "it should load 2 meta values"); Assert.AreEqual("foo author", data.meta["author"]); Assert.AreEqual("foo description", data.meta["description"]); Assert.AreEqual(3, data.fieldNames.Count, "it should load 3 field names"); Assert.AreEqual("Foo", data.fieldNames[0]); Assert.AreEqual("Bar", data.fieldNames[1]); Assert.AreEqual("Baz", data.fieldNames[2]); Assert.AreEqual(2, data.rows.Count, "it should load 2 rows of data"); Assert.AreEqual("1", data.rows[0].fields["Foo"].value); Assert.AreEqual("2", data.rows[0].fields["Bar"].value); Assert.AreEqual("3", data.rows[0].fields["Baz"].value); Assert.AreEqual("4", data.rows[1].fields["Foo"].value); Assert.AreEqual("5", data.rows[1].fields["Bar"].value); Assert.AreEqual("6", data.rows[1].fields["Baz"].value); }
/// <summary> /// Read an excel file and extract the meta, variables, and parsable rows. /// </summary> /// <param name="assetPath"></param> public void ReadAsset(string assetPath, ref ImportData data) { Debug.Log("START IMPORT PROCESS FOR XLSX"); // get an absolute path to the asset string absolutePath = System.IO.Directory.GetCurrentDirectory() + "/" + assetPath; // open a file stream to the asset using (FileStream fs = new FileStream(absolutePath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite)) { // get workbook XSSFWorkbook wb = new XSSFWorkbook(fs); // get field names GetFieldNames(data, wb); // get key/value meta data GetKeyValData(ref data.meta, wb, "#"); // get key/value GetKeyValData(ref data.vars, wb, "$"); // get the parsable rows GetRows(data, wb); } }
public ImportData() { instance = this; containers = new List<ImportedDataContainer>(); foreach(string file in importNames){ ImportedTable _table = ImportedTable.LoadFromFile(file) ; if(_table != null){ containers.AddRange( getDataFromTable( _table) ); } else { Debug.LogWarning("Could not import data from "+file); } } Debug.Log("- DataContainers Configured:"+containers.Count ); }
public void Import() { Dictionary <string, int> result = new ImportData().AutoImportData(); MessageBox.Show(string.Format("处方数:{0},处方明细数:{1}", result["处方数"], result["处方明细数"]), "信息提示", MessageBoxButtons.OK, MessageBoxIcon.Information); //OpenFileDialog ofd = new OpenFileDialog() //{ // Filter = "XML文件|*.xml", // InitialDirectory = @"\\172.20.81.139\chufang" //}; //DialogResult dr = ofd.ShowDialog(); //if (dr == DialogResult.OK) //{ // //string info = ImportData(ofd.FileName); // //MessageBox.Show(info, "信息提示", MessageBoxButtons.OK, MessageBoxIcon.Information); // Dictionary<string, int> result = new ImportData().Import(ofd.FileName); // MessageBox.Show(string.Format("处方数:{0},处方明细数{1}", result["处方数"], result["处方明细数"]), "信息提示", MessageBoxButtons.OK, MessageBoxIcon.Information); //} }
/// <summary> /// Opens a JSON file that contains a Bullion account. /// File dialog will open to this projects directory where the account file can be located. /// </summary> /// <remarks> /// <para>If the data imported for a property equals zero, then the content will be "0".</para> /// <para>If there is a selected item in the resourceComboBox, then the selection will be reset.</para> /// <para>If there is a value in the amountTextBox, then the text will be cleared.</para> /// </remarks>> private void Import_Data_Click(object sender, RoutedEventArgs e) { ImportData idata = new ImportData(); account = idata.Import(account, cipher); DataValidation data = new DataValidation(); if (data.ValidateDouble(account.Savings)) { savingsAmountLabel.Content = account.Savings.ToString("N"); } else { savingsAmountLabel.Content = 0; } if (data.ValidateDouble(account.Cash)) { cashAmountLabel.Content = account.Cash.ToString("N"); } else { cashAmountLabel.Content = 0; } if (data.ValidateDouble(account.Crypto)) { cryptoAmountLabel.Content = account.Crypto.ToString("N"); } else { cryptoAmountLabel.Content = 0; } if (data.ValidateDouble(account.Savings + account.Cash)) { totalAmountLabel.Content = (account.Savings + account.Cash).ToString("N"); } else { totalAmountLabel.Content = 0; } DataContext = account; }
public ImportData Patch(ImportData request) { if (true != (request?.Id > 0)) { throw new HttpError(HttpStatusCode.NotFound, "Please specify a valid Id of the ImportData to patch."); } request.Select = request.Select ?? new List <string>(); ImportData ret = null; using (Execute) { Execute.Run(ssn => { ret = _AssignValues(request, DocConstantPermission.EDIT, ssn); }); } return(ret); }
public ImportData() { instance = this; containers = new List <ImportedDataContainer>(); foreach (string file in importNames) { ImportedTable _table = ImportedTable.LoadFromFile(file); if (_table != null) { containers.AddRange(getDataFromTable(_table)); } else { Debug.LogWarning("Could not import data from " + file); } } Debug.Log("- DataContainers Configured:" + containers.Count); }
public string Import(string clipUrl, string thumbUrl, string title, string description, int categoryId = 713, int privacy = 0) { try { var postUrl = $"https://api-v2.medal.tv/users/{UserId.ToString ( )}/content"; var contentType = "application/json"; var http = WebRequest.CreateHttp(postUrl); http.ContentType = contentType; http.Method = "POST"; http.AllowAutoRedirect = true; http.CachePolicy = new RequestCachePolicy(RequestCacheLevel.BypassCache); http.Referer = "no-referrer"; http.UserAgent = "Medal Overlay for Streamlabs Chatbot"; http.Headers.Add("X-Authentication", $"{UserId.ToString ( )},{AuthKey}"); var data = new ImportData { ContentUrl = clipUrl, CategoryId = categoryId, Privacy = privacy, ContentDescription = description, ContentTitle = title, ThumbnailUrl = thumbUrl }; var body = Newtonsoft.Json.JsonConvert.SerializeObject(data, Formatting.None); using (var reqs = http.GetRequestStream( )) { var unicodeEncoding = new UnicodeEncoding( ); var bytesData = unicodeEncoding.GetBytes(body); reqs.Write(bytesData, 0, bytesData.Length); } var resp = http.GetResponse( ); using (var resps = resp.GetResponseStream( )) { using (var sr = new StreamReader(resps)) { return(sr.ReadToEnd( )); } } } catch (Exception e) { return($"{{ \"error\": \"{e.Message.Replace ( "\r", "" ).Replace ( "\n", "\\n" )}\", \"stack\": \"{e.StackTrace.Replace ( "\r", "" ).Replace ( "\n", "\\n" )}\" }}"); } }
private bool execCreateTable(String inSqlStmt) { bool curReturnValue = true; int curDelimIdx, curDelimIdx2, curValueLen; ImportData curImportData = new ImportData(); String[] curTableName = new String[1]; try { curDelimIdx = inSqlStmt.ToUpper().IndexOf("TABLE "); if (curDelimIdx > 0) { curDelimIdx2 = inSqlStmt.IndexOf(" ", curDelimIdx + 6); if (curDelimIdx2 < 0) { curValueLen = inSqlStmt.Length - curDelimIdx - 6; } else { curValueLen = curDelimIdx2 - curDelimIdx - 6; } curTableName[0] = inSqlStmt.Substring(curDelimIdx + 6, curValueLen); String curFileRef = Application.StartupPath + "\\" + curTableName[0] + ".tmp"; if (execSchemaCmd(inSqlStmt)) { if (!(curTableName[0].EndsWith("Backup"))) { curImportData.importData((curFileRef)); deleteTempFile(curFileRef); } } } } catch (Exception ex) { MessageBox.Show("Error: Executing drop table command " + inSqlStmt + "\n\nException: " + ex.Message ); curReturnValue = false; } return(curReturnValue); }
public Task <ImportData> SaveAsync(ImportData data, CancellationToken token = default(CancellationToken)) { var query = @" INSERT INTO [dbo].[ImportData] ( [CompanyId] , [FileName] , [FileSize] , [CreateBy] , [CreateAt] ) OUTPUT inserted.* VALUES ( @CompanyId , @FileName , @FileSize , @CreateBy , GETDATE() /*@CreateAt*/ )"; return(dbHelper.ExecuteAsync <ImportData>(query, data, token)); }
private void buttonImport_Click(object sender, EventArgs e) { if (_worker != null && _worker.IsBusy) { return; } _waitCursor = new WaitCursor(); EnableDisable(false); progressBar1.Minimum = 0; progressBar1.Maximum = 100; progressBar1.Value = 0; _worker = new BackgroundWorker { WorkerReportsProgress = true, WorkerSupportsCancellation = true }; _worker.ProgressChanged += (o, args) => progressBar1.Value = args.ProgressPercentage; _worker.DoWork += backgroundWorker_DoWork; _worker.RunWorkerCompleted += backgroundWorker_Completed; var addresses = new List <string>(); foreach (ListViewItem item in listItems.Items) { addresses.Add(item.Text); } var data = new ImportData() { Addresses = addresses, DeleteRecipientsNotInImportFile = ucDeleteRecipientsNotInList.Checked }; _worker.RunWorkerAsync(data); }
private void btnSelectFile_Click(object sender, EventArgs e) { OpenFileDialog ofd = new OpenFileDialog(); ofd.Title = "导入Excel表格"; ofd.Filter = "2007Excel(*.xlsx)|*.xlsx|2003Excel(*.xls)|*.xls"; if (ofd.ShowDialog() == DialogResult.OK) { lblFilePath.Text = ofd.FileName; try { this.dgvScore.DataSource = ImportData.getScoreList(ofd.FileName); } catch (Exception ex) { MessageBox.Show(ex.Message, "发生错误,错误提示:"); } } // }
/// <summary>Process the import data line.</summary> /// <param name="dataLine">Data line to be processed.</param> /// <returns>Returns the imported data information.</returns> ImportData ProcessImportDataLine(string dataLine) { if (string.IsNullOrEmpty(dataLine)) { return(null); } string[] importData = dataLine.Split(','); // Validate the data length and starting value if ((importData.Length != 3) || (importData[0].ToUpper() == "FIRSTNAME")) { return(null); } // Build the resonse data var result = new ImportData { FirstName = importData[0], LastName = importData[1], Address = importData[2], }; return(result); }
public ImportFile Import(Guid importFileId) { ImportFile file = _importFileService.FindById(importFileId); ImportMap map = _importMapService.FindById(file.ImportMapId); var data = new List <dynamic>().DeserializeFromJson(file.Content); this.ImportCore(file, map, data, (rowIndex, d, rowError, errorType, recordId) => { var importDataEntity = new ImportData { Data = ((JArray)d).ToString(), ErrorMessage = rowError.ToString(), HasError = rowError.Length > 0, ImportFileId = file.ImportFileId, LineNumber = rowIndex, RecordId = recordId, ErrorType = errorType }; _importDataService.Create(importDataEntity); }); return(file); }
/// <summary> /// Get the parsable rows from a workbook /// </summary> /// <param name="rows">a reference to an object that will contain parsable rows</param> /// <param name="workbook">the workbook to extract rows from</param> private void GetRows(ImportData data, XSSFWorkbook workbook) { ISheet sheet = workbook.GetSheetAt(0); bool reading = true; int rowIndex = sheet.FirstRowNum; while (reading) { IRow row = sheet.GetRow(rowIndex); if (RowIsParsable(row)) { var validatorRow = new Row(); validatorRow.lineNumber = rowIndex; for (int i = 0; i < data.fieldNames.Count; ++i) { var fieldName = data.fieldNames[i]; var field = new Field() { value = CellValueAsString(row.GetCell(i)) }; validatorRow.fields.Add(fieldName, field); } data.rows.Add(validatorRow); } rowIndex++; if (rowIndex > sheet.LastRowNum) { reading = false; } } }
private void btnStart_Click(object sender, EventArgs e) { if (thread == null || thread.ThreadState == ThreadState.Stopped) { lblStatus.Text = "Chuẩn bị nhập dữ liệu..."; Memory.Instance.SetMemory("UserAbort", false); EnableControl(false); txtErrorOutput.Clear(); progressBar1.Value = 0; if (txtDB.Text.Trim().EndsWith("xls")) { import = new ImportData(txtDB.Text, "Table1"); } else { import = new ImportData(txtDB.Text, "", ""); } import.OnStart += new EventHandler(import_OnStart); import.OnExecuting += new EventHandler(import_OnImporting); import.OnError += new CancelEventHandler(import_OnError); import.OnFinished += new EventHandler(import_OnFinished); ThreadStart threadStart = new ThreadStart(import.Execute); thread = new Thread(threadStart); thread.Start(); } else if (thread.ThreadState == ThreadState.Suspended) { thread.Resume(); btnStart.Text = "Tạm &dừng"; } else if (thread.ThreadState == ThreadState.Running) { thread.Suspend(); btnStart.Text = "Tiếp &tục"; } }
internal DataSet ReadXmlToDataSet(string file, ref ImportData importData) { DataSet dataSet = new DataSet(); if (File.Exists(file)) { try { int num = (int)dataSet.ReadXml(file); } catch { importData.Errors.ErrorCode = ErrorCode.DataMissing; importData.Errors.ErrorInfo = "Writing changes data to dataset failed"; return((DataSet)null); } } else { importData.Errors.ErrorCode = ErrorCode.DataMissing; importData.Errors.ErrorInfo = "Changes data missing"; } return(dataSet); }
private void worker_DoWork(object sender, DoWorkEventArgs e) { try { string strConnectionString = "data source=" + tePath.Text; AddMsg(new KeyValuePair <ImportData.MsgState, string>(ImportData.MsgState.Info, "Получение данных для дальнейшей обработки из импортируемой базы...")); m_dictRefs = null; m_listChecks = null; KeyValuePair <ImportData.MsgState, string> Msg = ImportData.LoadData(strConnectionString, ref m_listImportData, ref m_listChecks, ref m_dictRefs); AddMsg(Msg); if (Msg.Key == 0) { return; } AddMsg(new KeyValuePair <ImportData.MsgState, string>(ImportData.MsgState.Info, "Получение данных для дальнейшей обработки из текущей базы...")); m_dictRefs = new Dictionary <string, Dictionary <KeyValuePair <long, string>, long> >(); m_listChecks = new List <ImportData.CheckInfo>(); Msg = ImportData.LoadData(global::DiarMain.Properties.Settings.Default.diarConnectionString, ref m_listData, ref m_listChecks, ref m_dictRefs); AddMsg(Msg); if (Msg.Key == 0) { return; } AnalizeData(); AddMsg(new KeyValuePair <ImportData.MsgState, string>(ImportData.MsgState.Info, "Загрузка данных завершена")); } catch (Exception ex) { AddMsg(new KeyValuePair <ImportData.MsgState, string>(ImportData.MsgState.Error, ex.Message)); } }
public ImportData Put(ImportData request) { return(Patch(request)); }
public ImportData Post(ImportDataCopy request) { ImportData ret = null; using (Execute) { Execute.Run(ssn => { var entity = DocEntityImportData.Get(request?.Id); if (null == entity) { throw new HttpError(HttpStatusCode.NoContent, "The COPY request did not succeed."); } if (!DocPermissionFactory.HasPermission(entity, currentUser, DocConstantPermission.ADD)) { throw new HttpError(HttpStatusCode.Forbidden, "You do not have ADD permission for this route."); } var pCompletedOn = entity.CompletedOn; var pDataSets = entity.DataSets.ToList(); var pDocument = entity.Document; var pErrorData = entity.ErrorData; var pExtractUrl = entity.ExtractUrl; if (!DocTools.IsNullOrEmpty(pExtractUrl)) { pExtractUrl += " (Copy)"; } var pHighPriority = entity.HighPriority; var pImportFr = entity.ImportFr; var pImportLocation = entity.ImportLocation; var pImportNewName = entity.ImportNewName; var pImportTable = entity.ImportTable; var pImportText = entity.ImportText; var pImportType = entity.ImportType; var pIsLegacy = entity.IsLegacy; var pOrder = entity.Order; var pReferenceId = entity.ReferenceId; var pRequestedBy = entity.RequestedBy; var pRequestedOn = entity.RequestedOn; var pStartedOn = entity.StartedOn; var pStatus = entity.Status; var copy = new DocEntityImportData(ssn) { Hash = Guid.NewGuid() , CompletedOn = pCompletedOn , Document = pDocument , ErrorData = pErrorData , ExtractUrl = pExtractUrl , HighPriority = pHighPriority , ImportFr = pImportFr , ImportLocation = pImportLocation , ImportNewName = pImportNewName , ImportTable = pImportTable , ImportText = pImportText , ImportType = pImportType , IsLegacy = pIsLegacy , Order = pOrder , ReferenceId = pReferenceId , RequestedBy = pRequestedBy , RequestedOn = pRequestedOn , StartedOn = pStartedOn , Status = pStatus }; foreach (var item in pDataSets) { entity.DataSets.Add(item); } copy.SaveChanges(DocConstantPermission.ADD); ret = copy.ToDto(); }); } return(ret); }
private ImportData _AssignValues(ImportData request, DocConstantPermission permission, Session session) { if (permission != DocConstantPermission.ADD && (request == null || request.Id <= 0)) { throw new HttpError(HttpStatusCode.NotFound, $"No record"); } if (permission == DocConstantPermission.ADD && !DocPermissionFactory.HasPermissionTryAdd(currentUser, "ImportData")) { throw new HttpError(HttpStatusCode.Forbidden, "You do not have ADD permission for this route."); } request.Select = request.Select ?? new List <string>(); ImportData ret = null; request = _InitAssignValues <ImportData>(request, permission, session); //In case init assign handles create for us, return it if (permission == DocConstantPermission.ADD && request.Id > 0) { return(request); } var cacheKey = GetApiCacheKey <ImportData>(DocConstantModelName.IMPORTDATA, nameof(ImportData), request); //First, assign all the variables, do database lookups and conversions var pCompletedOn = request.CompletedOn; var pDataSets = GetVariable <Reference>(request, nameof(request.DataSets), request.DataSets?.ToList(), request.DataSetsIds?.ToList()); var pDocument = DocEntityDocument.Get(request.Document?.Id, true, Execute) ?? DocEntityDocument.Get(request.DocumentId, true, Execute); var pErrorData = request.ErrorData; var pExtractUrl = request.ExtractUrl; var pHighPriority = request.HighPriority; var pImportFr = request.ImportFr; DocEntityLookupTable pImportLocation = GetLookup(DocConstantLookupTable.STUDYIMPORTLOCATION, request.ImportLocation?.Name, request.ImportLocation?.Id); var pImportNewName = request.ImportNewName; var pImportTable = request.ImportTable; var pImportText = request.ImportText; DocEntityLookupTable pImportType = GetLookup(DocConstantLookupTable.STUDYIMPORTTYPE, request.ImportType?.Name, request.ImportType?.Id); var pIsLegacy = request.IsLegacy; var pOrder = request.Order; var pReferenceId = request.ReferenceId; var pRequestedBy = DocEntityUser.Get(request.RequestedBy?.Id, true, Execute) ?? DocEntityUser.Get(request.RequestedById, true, Execute); var pRequestedOn = request.RequestedOn; var pStartedOn = request.StartedOn; DocEntityLookupTable pStatus = GetLookup(DocConstantLookupTable.IMPORTSTATUS, request.Status?.Name, request.Status?.Id); var pArchived = true == request.Archived; var pLocked = request.Locked; var entity = InitEntity <DocEntityImportData, ImportData>(request, permission, session); if (AllowPatchValue <ImportData, bool>(request, DocConstantModelName.IMPORTDATA, pArchived, permission, nameof(request.Archived), pArchived != entity.Archived)) { entity.Archived = pArchived; } if (AllowPatchValue <ImportData, DateTime?>(request, DocConstantModelName.IMPORTDATA, pCompletedOn, permission, nameof(request.CompletedOn), pCompletedOn != entity.CompletedOn)) { entity.CompletedOn = pCompletedOn; } if (AllowPatchValue <ImportData, DocEntityDocument>(request, DocConstantModelName.IMPORTDATA, pDocument, permission, nameof(request.Document), pDocument != entity.Document)) { entity.Document = pDocument; } if (AllowPatchValue <ImportData, string>(request, DocConstantModelName.IMPORTDATA, pErrorData, permission, nameof(request.ErrorData), pErrorData != entity.ErrorData)) { entity.ErrorData = pErrorData; } if (AllowPatchValue <ImportData, string>(request, DocConstantModelName.IMPORTDATA, pExtractUrl, permission, nameof(request.ExtractUrl), pExtractUrl != entity.ExtractUrl)) { entity.ExtractUrl = pExtractUrl; } if (AllowPatchValue <ImportData, bool>(request, DocConstantModelName.IMPORTDATA, pHighPriority, permission, nameof(request.HighPriority), pHighPriority != entity.HighPriority)) { entity.HighPriority = pHighPriority; } if (AllowPatchValue <ImportData, bool>(request, DocConstantModelName.IMPORTDATA, pImportFr, permission, nameof(request.ImportFr), pImportFr != entity.ImportFr)) { entity.ImportFr = pImportFr; } if (AllowPatchValue <ImportData, DocEntityLookupTable>(request, DocConstantModelName.IMPORTDATA, pImportLocation, permission, nameof(request.ImportLocation), pImportLocation != entity.ImportLocation)) { entity.ImportLocation = pImportLocation; } if (AllowPatchValue <ImportData, bool>(request, DocConstantModelName.IMPORTDATA, pImportNewName, permission, nameof(request.ImportNewName), pImportNewName != entity.ImportNewName)) { entity.ImportNewName = pImportNewName; } if (AllowPatchValue <ImportData, bool>(request, DocConstantModelName.IMPORTDATA, pImportTable, permission, nameof(request.ImportTable), pImportTable != entity.ImportTable)) { entity.ImportTable = pImportTable; } if (AllowPatchValue <ImportData, bool>(request, DocConstantModelName.IMPORTDATA, pImportText, permission, nameof(request.ImportText), pImportText != entity.ImportText)) { entity.ImportText = pImportText; } if (AllowPatchValue <ImportData, DocEntityLookupTable>(request, DocConstantModelName.IMPORTDATA, pImportType, permission, nameof(request.ImportType), pImportType != entity.ImportType)) { entity.ImportType = pImportType; } if (AllowPatchValue <ImportData, bool>(request, DocConstantModelName.IMPORTDATA, pIsLegacy, permission, nameof(request.IsLegacy), pIsLegacy != entity.IsLegacy)) { entity.IsLegacy = pIsLegacy; } if (AllowPatchValue <ImportData, int?>(request, DocConstantModelName.IMPORTDATA, pOrder, permission, nameof(request.Order), pOrder != entity.Order)) { entity.Order = pOrder; } if (AllowPatchValue <ImportData, int?>(request, DocConstantModelName.IMPORTDATA, pReferenceId, permission, nameof(request.ReferenceId), pReferenceId != entity.ReferenceId)) { if (null != pReferenceId) { entity.ReferenceId = (int)pReferenceId; } } if (AllowPatchValue <ImportData, DocEntityUser>(request, DocConstantModelName.IMPORTDATA, pRequestedBy, permission, nameof(request.RequestedBy), pRequestedBy != entity.RequestedBy)) { entity.RequestedBy = pRequestedBy; } if (AllowPatchValue <ImportData, DateTime?>(request, DocConstantModelName.IMPORTDATA, pRequestedOn, permission, nameof(request.RequestedOn), pRequestedOn != entity.RequestedOn)) { entity.RequestedOn = pRequestedOn; } if (AllowPatchValue <ImportData, DateTime?>(request, DocConstantModelName.IMPORTDATA, pStartedOn, permission, nameof(request.StartedOn), pStartedOn != entity.StartedOn)) { entity.StartedOn = pStartedOn; } if (AllowPatchValue <ImportData, DocEntityLookupTable>(request, DocConstantModelName.IMPORTDATA, pStatus, permission, nameof(request.Status), pStatus != entity.Status)) { entity.Status = pStatus; } if (request.Locked && AllowPatchValue <ImportData, bool>(request, DocConstantModelName.IMPORTDATA, pArchived, permission, nameof(request.Locked), pLocked != entity.Locked)) { entity.Archived = pArchived; } entity.SaveChanges(permission); var idsToInvalidate = new List <int>(); idsToInvalidate.AddRange(PatchCollection <ImportData, DocEntityImportData, Reference, DocEntityDataSet>(request, entity, pDataSets, permission, nameof(request.DataSets))); if (idsToInvalidate.Any()) { idsToInvalidate.Add(entity.Id); DocCacheClient.RemoveByEntityIds(idsToInvalidate); DocCacheClient.RemoveSearch(DocConstantModelName.IMPORTDATA); } entity.SaveChanges(permission); DocPermissionFactory.SetSelect <ImportData>(currentUser, nameof(ImportData), request.Select); ret = entity.ToDto(); var cacheExpires = DocResources.Metadata.GetCacheExpiration(DocConstantModelName.IMPORTDATA); DocCacheClient.Set(key: cacheKey, value: ret, entityId: request.Id, entityType: DocConstantModelName.IMPORTDATA, cacheExpires); return(ret); }
public object Get(ImportData request) => GetEntityWithCache <ImportData>(DocConstantModelName.IMPORTDATA, request, GetImportData);
public void GenerateImports() { _imports.Clear(); Dictionary<uint, ImportData> data = new Dictionary<uint, ImportData>(); foreach (ModuleSectionNode s in _sections) { foreach (ImportData e in data.Values) { e._first = true; e._lastOffset = 0; } uint i = 0; uint offset = 0; List<RELLink> cmds; foreach (Relocation loc in s._relocations) { if (loc.Command != null) { RelCommand cmd = loc.Command; ImportData d; uint id = cmd._moduleID; if (_imports.ContainsKey(id)) { cmds = _imports[id]; d = data[id]; } else { _imports.Add(id, cmds = new List<RELLink>()); data.Add(id, d = new ImportData() { _first = true, _lastOffset = 0 }); } if (d._first) { cmds.Add(new RELLink() { _type = RELLinkType.Section, _section = (byte)s.Index }); d._first = false; } offset = i * 4 + (cmd.IsHalf ? 2u : 0); uint diff = offset - d._lastOffset; while (offset - d._lastOffset > 0xFFFF) { d._lastOffset += 0xFFFF; cmds.Add(new RELLink() { _type = RELLinkType.IncrementOffset, _section = 0, _value = 0, _prevOffset = 0xFFFF }); } byte targetSection = (byte)cmd._targetSectionId; RELLinkType type = (RELLinkType)cmd._command; uint val = cmd._addend; cmds.Add(new RELLink() { _type = type, _section = targetSection, _value = val, _prevOffset = (ushort)diff }); d._lastOffset = offset; } i++; } } foreach (List<RELLink> cmds in _imports.Values) cmds.Add(new RELLink() { _type = RELLinkType.End }); }
private void Engine(object sender, EventArgs e) { this.Invoke(new MethodInvoker(delegate { StatustxtBox.Text = "Reading N and C files... (Task 0/6)"; })); ImportData import = new ImportData(backgroundWorker1); List <PSM> MMOutput = new List <PSM>(); List <TheoreticalProtein> database = new List <TheoreticalProtein>(); bool passedFileIO = true; { MMOutput = import.ImportPSMs(nFileName, cFileName, out string error_message); if (error_message.Length > 0) { MessageBox.Show(error_message); } this.Invoke(new MethodInvoker(delegate { StatustxtBox.Text = "Reading database... (Task 1/6)"; })); ClearProgress(); database = import.ImportDatabase(databaseFileName, out string error_message2); if (error_message2.Length > 0) { MessageBox.Show(error_message2); } } if (passedFileIO) { this.Invoke(new MethodInvoker(delegate { StatustxtBox.Text = "Splicing peptides... (Task 2/6)"; })); ClearProgress(); SpliceFragments sf = new SpliceFragments(backgroundWorker1); List <PSM> candidates = sf.ExperimentalTheoreticalMatching(MMOutput, out string error_message); if (error_message.Length > 0) { MessageBox.Show(error_message); } ClearProgress(); AlternativeSequences altSeq = new AlternativeSequences(backgroundWorker1); this.Invoke(new MethodInvoker(delegate { StatustxtBox.Text = "Finding ambiquity... (Task 3/6)"; })); ClearProgress(); altSeq.FindAmbiguity(candidates, database, out string error_message2); if (error_message2.Length > 0) { MessageBox.Show(error_message2); } FalsePositives.generateDecoys = false; this.Invoke(new MethodInvoker(delegate { StatustxtBox.Text = "Recording variants... (Task 4/6)"; })); ClearProgress(); FalsePositives rfp = new FalsePositives(backgroundWorker1); rfp.FindCommonFalsePositives(candidates, database, out string error_message3); if (error_message3.Length > 0) { MessageBox.Show(error_message3); } this.Invoke(new MethodInvoker(delegate { StatustxtBox.Text = "Exporting results... (Task 5/6)"; })); ClearProgress(); ExportData ed = new ExportData(backgroundWorker1); string e3 = ed.ExportAll(candidates, databaseFileName); if (e3.Length > 0) { MessageBox.Show(e3); } this.Invoke(new MethodInvoker(delegate { StatustxtBox.Text = "Complete! (6/6)"; })); MessageBox.Show("Complete!"); } }
public void GenerateImports() { _imports.Clear(); Dictionary <uint, ImportData> data = new Dictionary <uint, ImportData>(); foreach (ModuleSectionNode s in _sections) { foreach (ImportData e in data.Values) { e._first = true; e._lastOffset = 0; } uint i = 0; uint offset = 0; List <RELLink> cmds; foreach (Relocation loc in s._relocations) { if (loc.Command != null) { RelCommand cmd = loc.Command; ImportData d; uint id = cmd._moduleID; if (_imports.ContainsKey(id)) { cmds = _imports[id]; d = data[id]; } else { _imports.Add(id, cmds = new List <RELLink>()); data.Add(id, d = new ImportData() { _first = true, _lastOffset = 0 }); } if (d._first) { cmds.Add(new RELLink() { _type = RELLinkType.Section, _section = (byte)s.Index }); d._first = false; } offset = i * 4 + (cmd.IsHalf ? 2u : 0); uint diff = offset - d._lastOffset; while (offset - d._lastOffset > 0xFFFF) { d._lastOffset += 0xFFFF; cmds.Add(new RELLink() { _type = RELLinkType.IncrementOffset, _section = 0, _value = 0, _prevOffset = 0xFFFF }); } byte targetSection = (byte)cmd._targetSectionId; RELLinkType type = (RELLinkType)cmd._command; uint val = cmd._addend; cmds.Add(new RELLink() { _type = type, _section = targetSection, _value = val, _prevOffset = (ushort)diff }); d._lastOffset = offset; } i++; } } foreach (List <RELLink> cmds in _imports.Values) { cmds.Add(new RELLink() { _type = RELLinkType.End }); } }
public JsonResult Content(ImportData data) { return(TryImportContent(data)); }
public bool Update(ImportData entity) { var flag = _importDataRepository.Update(entity); return(flag); }
public bool Create(ImportData entity) { bool flag = _importDataRepository.Create(entity); return(flag); }
public void GenerateImports() { _imports.Clear(); Dictionary <uint, ImportData> tempImports = new Dictionary <uint, ImportData>(); foreach (ModuleSectionNode s in _sections) { foreach (ImportData e in tempImports.Values) { e._newSection = true; e._lastOffset = 0; } uint offset = 0; List <RELLink> links; //Iterate through each command in the section var commands = s._manager.GetCommands(); foreach (var r in commands) { RelCommand command = r.Value; int index = r.Key; ImportData impData; uint moduleID = command._moduleID; //Check if an import has been created for the target module. if (_imports.ContainsKey(moduleID)) { //An import already exists, so we'll add to it. links = _imports[moduleID]; impData = tempImports[moduleID]; } else { //An import does not exist, so it must be made. _imports.Add(moduleID, links = new List <RELLink>()); //Create new temporary import data tempImports.Add(moduleID, impData = new ImportData() { _newSection = true, _lastOffset = 0 }); } //This is true when a new section is being evaluated. if (impData._newSection) { links.Add(new RELLink() { _type = RELLinkType.Section, _section = (byte)s.Index }); impData._newSection = false; } //Get the offset of the command within the section. offset = (uint)index * 4 + (command.IsHalf ? 2u : 0); //Get the offset to this address relative to the last written link offset. uint diff = offset - impData._lastOffset; //If the difference is greater than ushort allows, //add increment links until the difference works while (diff > 0xFFFF) { impData._lastOffset += 0xFFFF; diff = offset - impData._lastOffset; links.Add(new RELLink() { _type = RELLinkType.IncrementOffset, _section = 0, _value = 0, _prevOffset = 0xFFFF }); } //Gather the link information byte targetSection = (byte)command._targetSectionId; RELLinkType type = (RELLinkType)command._command; uint val = command._addend; //Write command link links.Add(new RELLink() { _type = type, _section = targetSection, _value = val, _prevOffset = (ushort)diff }); //Don't bother adding the difference, //just set the exact offset as the last offset impData._lastOffset = offset; } } foreach (List <RELLink> cmds in _imports.Values) { cmds.Add(new RELLink() { _type = RELLinkType.End }); } }
void m_Worker_DoWork(object sender, System.ComponentModel.DoWorkEventArgs e) { ImportData data = (ImportData)e.Argument; String tagsDbFile = String.Empty; using (ZipInputStream stream = new ZipInputStream(new System.IO.BufferedStream(FileHelpers.GetFileContentStream(data.ImportFile)))) { ZipEntry entry; byte[] buffer = new byte[4096]; long writtenSize = 0; int lastPercent = -1; String lastFile = String.Empty; while ((entry = stream.GetNextEntry()) != null) { bool isTagsDBFile; String fileName = GetFileName(entry, out isTagsDBFile); if (fileName == String.Empty) { fileName = data.TargetFile; } else if (isTagsDBFile) { tagsDbFile = fileName; } else if (!data.Overwrite && FileHelpers.FileExists(fileName)) { continue; } String directoryName = FileHelpers.GetDirectory(fileName); if (directoryName.Length > 0) { FileHelpers.CreateDirectory(directoryName); } using (var fileStream = FileHelpers.CreateFileOutputStream(fileName)) { StreamUtils.Copy(stream, fileStream, buffer, new ProgressHandler((object o, ProgressEventArgs e2) => { long currentSize = writtenSize + e2.Processed; int currentPercent = (int)(((double)currentSize / (double)data.OverallSize) * 100.0); if (currentPercent != lastPercent || e2.Name != lastFile) { lastPercent = currentPercent; lastFile = e2.Name; m_Worker.ReportProgress(currentPercent, lastFile); e2.ContinueRunning = !m_Worker.CancellationPending; } }), TimeSpan.FromMilliseconds(50), entry, fileName, entry.Size); } writtenSize += entry.Size; if (m_Worker.CancellationPending) { e.Cancel = true; break; } } } if (!String.IsNullOrEmpty(tagsDbFile)) { String logFileName = System.IO.Path.Combine(System.IO.Path.GetTempPath(), "arestagsdbimport.log"); using (System.IO.StreamWriter writer = new System.IO.StreamWriter(logFileName)) { Ares.Tags.TagsModule.GetTagsDB().FilesInterface.ImportDatabase(tagsDbFile, writer); } } }
public override void AddNewImport (string name, MSBuildImport beforeImport = null) { var data = new ImportData { Target = name }; if (beforeImport != null) { var other = (ImportData)beforeImport; int i = imports.IndexOf (other); if (i != -1) { imports.Insert (i, data); return; } } imports.Add (data); }
/// <summary>取込処理</summary> public async Task <AccountTransferImportResult> ReadAsync(AccountTransferImportSource source, CancellationToken token = default(CancellationToken)) { var encoding = Encoding.GetEncoding(source.EncodingCodePage); var csv = encoding.GetString(source.Data); var companyTask = companyGetByIdQueryProcessor.GetByIdsAsync(new[] { source.CompanyId }, token); var currencyTask = currencyQueryProcessor.GetAsync(new CurrencySearch { CompanyId = source.CompanyId, Codes = new[] { DefaultCurrencyCode }, }, token); var agencyTask = paymentAgencyGetByIdsQueryProcessor.GetByIdsAsync(new[] { source.PaymentAgencyId }, token); await Task.WhenAll(companyTask, currencyTask, agencyTask); var company = companyTask.Result.First(); var currency = currencyTask.Result.First(); var agency = agencyTask.Result.First(); var helper = new Helper { GetBillingsAsync = async(companyId, paymentAgencyId, dueAt) => (await billingQueryProcessor.GetAccountTransferMatchingTargetListAsync(paymentAgencyId, dueAt, currency.Id)).ToList(), GetCustomersAsync = async(ids) => (await customerQueryProcessor.GetAsync(new CustomerSearch { Ids = ids, }, token)).ToDictionary(x => x.Id), }; var reader = helper.CreateReader((AccountTransferFileFormatId)agency.FileFormatId); reader.CompanyId = company.Id; reader.AggregateBillings = company.TransferAggregate == 1; reader.PaymentAgencyId = agency.Id; reader.TransferYear = source.TransferYear; reader.Encoding = encoding; reader.FileName = source.FileName; reader.IsAsync = true; reader.IsPlainText = true; var sources = await reader.ReadAsync(csv); var data = new ImportData { CompanyId = source.CompanyId, FileName = source.FileName, FileSize = encoding.GetByteCount(csv), CreateBy = source.LoginUserId, }; data.Details = sources.Select(x => new ImportDataDetail { ObjectType = 0, RecordItem = serializer.PackSingleObject(x), }).ToArray(); var dataSaved = await importDataProcessor.SaveAsync(data, token); var result = new AccountTransferImportResult { ImportData = dataSaved, ProcessResult = new ProcessResult { Result = true }, }; for (var i = 0; i < sources.Count; i++) { result.ReadCount++; if (sources[i].TransferResultCode == 0) { result.ValidCount++; result.ValidAmount += sources[i].TransferAmount; } else { result.InvalidCount++; result.InvalidAmount += sources[i].TransferAmount; } } result.InvalidSources = sources.Where(x => x.TransferResultCode != 0 || !(x.Billings?.Any() ?? false)).ToList(); result.Logs = sources.SelectMany(x => x.GetInvalidLogs()).ToList(); return(result); }
private void buttonImport_Click(object sender, EventArgs e) { if (_worker != null && _worker.IsBusy) { return; } _waitCursor = new WaitCursor(); EnableDisable(false); progressBar1.Minimum = 0; progressBar1.Maximum = 100; progressBar1.Value = 0; _worker = new BackgroundWorker { WorkerReportsProgress = true, WorkerSupportsCancellation = true }; _worker.ProgressChanged += (o, args) => progressBar1.Value = args.ProgressPercentage; _worker.DoWork += backgroundWorker_DoWork; _worker.RunWorkerCompleted += backgroundWorker_Completed; var addresses = new List<string>(); foreach (ListViewItem item in listItems.Items) { addresses.Add(item.Text); } var data = new ImportData() { Addresses = addresses, DeleteRecipientsNotInImportFile = ucDeleteRecipientsNotInList.Checked }; _worker.RunWorkerAsync(data); }
private void DoImport(IProgressMonitor monitor, String importFileName, String targetFileName, bool silent, IMessageBoxProvider messageBoxProvider, System.Action <Exception, bool> dataLoaded) { m_Monitor = monitor; m_DataLoadedFunc = dataLoaded; try { long overallSize = 0; bool overWrite = true; bool hasAskedForOverwrite = silent; bool hasInnerFile = false; using (ZipFile file = CreateZipFile(importFileName)) { for (int i = 0; i < file.Count; ++i) { ZipEntry entry = file[i]; if (entry.IsDirectory) { continue; } bool isTagsDbFile; String fileName = GetFileName(entry, out isTagsDbFile); if (fileName == String.Empty) { if (hasInnerFile) { throw new ArgumentException(StringResources.InvalidImportFile); } else { hasInnerFile = true; overallSize += entry.Size; } } else if (isTagsDbFile) { overallSize += entry.Size; } else if (FileHelpers.FileExists(fileName)) { if (!hasAskedForOverwrite) { switch (messageBoxProvider.ShowYesNoCancelBox(StringResources.ImportOverwrite)) { case MessageBoxResult.Yes: overWrite = true; hasAskedForOverwrite = true; break; case MessageBoxResult.No: overWrite = false; hasAskedForOverwrite = true; break; default: return; } } if (overWrite) { overallSize += entry.Size; } } else { overallSize += entry.Size; } } if (!hasInnerFile) { throw new ArgumentException(StringResources.InvalidImportFile); } } ImportData data = new ImportData(); data.Overwrite = overWrite; data.ImportFile = importFileName; data.TargetFile = targetFileName; data.OverallSize = overallSize; m_Worker = new System.ComponentModel.BackgroundWorker(); m_Worker.WorkerReportsProgress = true; m_Worker.WorkerSupportsCancellation = true; m_Worker.DoWork += new System.ComponentModel.DoWorkEventHandler(m_Worker_DoWork); m_Worker.ProgressChanged += new System.ComponentModel.ProgressChangedEventHandler(m_Worker_ProgressChanged); m_Worker.RunWorkerCompleted += new System.ComponentModel.RunWorkerCompletedEventHandler(m_Worker_RunWorkerCompleted); m_Monitor.SetProgress(0, String.Empty); m_Worker.RunWorkerAsync(data); } catch (Exception ex) { if (dataLoaded != null) { dataLoaded(ex, false); } } }
public void GetData(ITable table) { var wizrd = new ImportData(table); wizrd.ShowDialog(); }