public async Task <ActionResult> Import_Partial(ImportModel model)
{
model.Update(Module, this);
if (!ModelState.IsValid)
{
return(PartialView(model));
}
// Download the zip file
FileUpload upload = new FileUpload();
string tempName = await upload.StoreTempPackageFileAsync(model.RemoteFile);
// import it
List <string> errorList = new List <string>();
bool success = await Package.ImportAsync(tempName, errorList);
// delete the temp file just uploaded
await FileSystem.TempFileSystemProvider.DeleteFileAsync(tempName);
string msg = FormatMessage(success, errorList, model.RemoteFile);
if (success)
{
model.RemoteFile = null;
return(FormProcessed(model, msg));
}
else
{
// Anything else is a failure
return(FormProcessed(model, msg));
}
}
private void ImportAsync(ImportModel model)
{
ProcessManager.RunMainProcessAsync(mindmapStore, async() =>
{
List <ImportResult> results = null;
try
{
results = await model.Source.ImportAsync(model.Importer);
}
catch
{
await MessageDialogService.AlertLocalizedAsync("ImportFailed_Alert");
}
if (results?.Count > 0)
{
foreach (var result in results)
{
await mindmapStore.AddAsync(result.Name, result.Document);
}
await mindmapStore.OpenAsync(mindmapStore.AllFiles.FirstOrDefault());
}
}).Forget();
}
public async Task<IActionResult> Mapping(ImportModel model, DialogModel dm)
{
string file = _sessionService.GetValue("importfile");
if (file.IsEmpty() || (model.DataFile != null && !file.IsCaseInsensitiveEqual(model.DataFile.FileName)))
{
//model.DataFileName = model.DataFile.FileName;
model.DataFileName = model.EntityName + "_" + DateTime.Now.ToString("yyyyMMddhhmmsssss") + System.IO.Path.GetExtension(model.DataFile.FileName);// model.DataFile.FileName;
file = ImportDirectory + "/" + model.DataFileName;
await model.DataFile.SaveAs(file, _settingFinder, _webHelper).ConfigureAwait(false);
_sessionService.Set("importfile", model.DataFileName, 5);
}
else
{
model.DataFileName = file;
file = ImportDirectory + "/" + file;
}
var columns = ExcelHelper.GetColumns(file);
var attributes = _attributeFinder.FindByEntityId(model.EntityId);
var mapData = new Dictionary<string, Schema.Domain.Attribute>();
foreach (var c in columns)
{
var attr = attributes.Find(n => n.LocalizedName.IsCaseInsensitiveEqual(c));//匹配到系统字段
mapData.Add(c, attr);
}
model.MapData = mapData;
model.Attributes = attributes;
model.ImportMaps = _importMapService.Query(x => x.Where(f => f.TargetEntityName == model.EntityName));
ViewBag.dialogmodel = dm;
return View(model);
}
public async Task <IActionResult> Import(IFormFile file, ImportModel model)
{
try
{
using var stream = file.OpenReadStream();
await _importService.CreateImportPreview(stream, model);
return(View("ImportResult", model));
}
catch (NotFoundException exc)
{
Log.Error(exc, "Exception during Import");
TempDataHelper.SetTemporaryMessage(TempData, MessageState.Error, message: Resources.BankAccountNotFound);
return(RedirectToAction("Index"));
}
catch (ImportFileException exc)
{
Log.Error(exc, "Exception during Import");
TempDataHelper.SetTemporaryMessage(TempData, MessageState.Error, message: Resources.ErrorWhileProcessingImport);
return(RedirectToAction("Index"));
}
catch (Exception exc)
{
Log.Error(exc, "Exception during Import");
TempDataHelper.SetTemporaryMessage(TempData, MessageState.Error, message: Resources.Error);
return(RedirectToAction("Index"));
}
}
public async Task <IActionResult> SaveImport(ImportModel model)
{
try
{
var(skippedTransactions, savedTransactions) = await _importService.SaveImport(model);
var message = string.Format(CultureInfo.CurrentCulture, Resources.TransactionsAddedAndSkippedFormat, savedTransactions, skippedTransactions);
TempDataHelper.SetTemporaryMessage(tempData: TempData,
state: savedTransactions != 0 ? MessageState.Success : MessageState.Warning,
message: message);
return(RedirectToAction("Index", "AccountOverview", new { @bankAccountId = model.BankAccountId }));
}
catch (NotFoundException exc)
{
if (exc.ItemName == nameof(ImportModel))
{
TempDataHelper.SetTemporaryMessage(TempData, MessageState.Error, Resources.ImportTimeOut);
}
else
{
TempDataHelper.SetTemporaryMessage(TempData, MessageState.Error, Resources.BankAccountNotFound);
}
return(RedirectToAction("Index", "Home"));
}
}
/// <summary>
/// Import Constructor
/// </summary>
public Import()
{
InitializeComponent();
_data = new ImportModel();
gridMain.DataContext = _data;
}
public ActionResult PollOnImport(int dossierId)
{
string sessionID = dossierId + "_" + HttpContext.Session.SessionID;
List <int> values = ImportModel.PollOnImport(sessionID);
return(PartialView("_PollOnImport", values));
}
public IActionResult Starting(ImportModel model)
{
_sessionService.Remove("importfile");
var result = _dataImporter.Import(model.ImportFileId);
return(JOk(new { result.ImportFileId, result.SuccessCount, result.FailureCount }));
}
public ActionResult ContentImport(string id)
{
var model = new ImportModel();
try
{
LanguageCollection languages = LanguageManager.GetLanguages(_masterDb);
List <SelectListItem> list = new List <SelectListItem>();
foreach (Language item in (Collection <Language>)(object) languages)
{
SelectListItem val = new SelectListItem
{
Text = item.CultureInfo.DisplayName,
Value = item.CultureInfo.Name
};
list.Add(val);
}
if (list?.Any() ?? false)
{
model.AvailableLanguages = list;
}
}
catch (Exception ex)
{
Log.Error("ContentImport", ex, this);
}
return(View("~/Views/ContentAuthoring/ContentImport.cshtml", model));
}
public static async Task <ImportModel> ImportRemoteData(Competition competition, string serverAddress)
{
var importModel = new ImportModel();
//var folder = await Windows.ApplicationModel.Package.Current.InstalledLocation.GetFolderAsync("Assets");
//var file = await folder.GetFileAsync("matches.json");
var client = new HttpClient();
var uri = new Uri(serverAddress, UriKind.Absolute);
using (var downloadStream = await client.GetStreamAsync(uri))
//using (var fileData = await file.OpenReadAsync())
{
using (var stringreader = new StreamReader(downloadStream))
{
using (var jsonReader = new JsonTextReader(stringreader))
{
var jsonSerializer = new JsonSerializer();
importModel = jsonSerializer.Deserialize <ImportModel>(jsonReader);
}
}
}
return(importModel);
}
static void Main(string[] args)
{
var importModel = new ImportModel();
//var folder = await Windows.ApplicationModel.Package.Current.InstalledLocation.GetFolderAsync("Assets");
//var file = await folder.GetFileAsync("matches.json");
var client = new HttpClient();
var uri = new Uri("http://10.5.3.7/scouting/json/flat.php", UriKind.Absolute);
using (var downloadStream = client.GetStreamAsync(uri).Result)
//using (var fileData = await file.OpenReadAsync())
{
using (var stringreader = new StreamReader(downloadStream))
{
using (var jsonReader = new JsonTextReader(stringreader))
{
var jsonSerializer = new JsonSerializer();
importModel = jsonSerializer.Deserialize <ImportModel>(jsonReader);
}
}
}
using (var dbContext = new RawDataDbContext())
{
foreach (var team in importModel.Teams)
{
var matches = team.Value.Matches;
if (matches == null)
{
continue;
}
foreach (var match in matches)
{
Console.Write("{0} {1}", team.Key, match.Key);
var importantMatchData = new ImportantMatchData();
importantMatchData.MatchNumber = match.Key;
importantMatchData.AutonomousHighMade = match.Value.AutonomousHigh
+ match.Value.AutonomousHighHot;
importantMatchData.BallsDropped = match.Value.TeleOperatedBallsLost.GetValueOrDefault();
importantMatchData.Catches = match.Value.TeleOperatedCatch;
importantMatchData.HighGoals = match.Value.TeleOperatedHighGoal;
importantMatchData.HighGoalsAttempted = match.Value.TeleOperatedHighGoal
+ match.Value.TeleOperatedHighGoalMiss;
importantMatchData.TeamNumber = team.Key;
importantMatchData.Possessions = match.Value.TeleOperatedPossessionBack
+ match.Value.TeleOperatedPossessionFront
+ match.Value.TeleOperatedPossessionMiddle;
importantMatchData.TrussesAttempted = match.Value.TeleOperatedTruss
+ match.Value.TeleOperatedTrussFail;
importantMatchData.TrussesMade = match.Value.TeleOperatedTruss;
dbContext.Matches.Add(importantMatchData);
dbContext.SaveChanges();
}
}
}
}
public IEntity GetDbModel(ImportModel importModel)
{
if (!(importModel is TestImportModel im))
{
throw new ArgumentException();
}
if (im.Operation == "Подбор товара")
{
return(new DoubleAddressAction {
StartTime = im.StartTime,
Duration = TimeSpan.FromSeconds(im.Duration),
Operation = _operations.First(o => o.Name.Equals("Подбор товара")),
});
}
if (im.Operation == "Упаковка товара в места")
{
return(new DoubleAddressAction {
StartTime = im.StartTime,
Duration = TimeSpan.FromSeconds(im.Duration),
Operation = _operations.First(o => o.Name.Equals("Упаковка товара в места")),
DoubleAddressDetails = new List <DoubleAddressActionDetail> {
new DoubleAddressActionDetail {
ProductQuantity = im.Quantity
}
}
});
}
if (im.Operation == "Перемещение товара")
{
return(new DoubleAddressAction {
StartTime = im.StartTime,
Duration = TimeSpan.FromSeconds(im.Duration),
Operation = _operations.First(o => o.Name.Equals("Перемещение товара")),
});
}
if (im.Operation == "Погрузка машины")
{
return(new ShipmentAction {
StartTime = im.StartTime,
Duration = TimeSpan.FromSeconds(im.Duration),
Operation = _operations.First(o => o.Name.Equals("Погрузка машины")),
});
}
if (im.Operation == "Выгрузка машины")
{
return(new ShipmentAction {
StartTime = im.StartTime,
Duration = TimeSpan.FromSeconds(im.Duration),
Operation = _operations.First(o => o.Name.Equals("Выгрузка машины")),
});
}
return(null);
}
public async Task <IActionResult> StartImport(ImportModel model)
{
var bankAccounts = await _bankAccountService.GetActiveBankAccountsForCurrentUser();
model.AvailableAccounts = bankAccounts;
return(View("StartImport", model));
}
public ActionResult Import()
{
ImportModel model = new ImportModel {
};
model.Update(Module, this);
return(View(model));
}
protected virtual IEnumerable <ImportModel <T> > ImportDefault <T>(string[] csvHeader)
where T : new()
{
var result = new List <ImportModel <T> >();
var fileCount = GetRequestFileCount();
if (fileCount == 1)
{
var hpf = GetRequestFileData(0);
if (hpf.Length > 0)
{
var idIdx = Array.IndexOf(CsvHeader, "Id");
var text = Encoding.Default.GetString(hpf, 0, hpf.Length);
var lines = text.Split(Environment.NewLine);
for (int i = 1; i < lines.Length; i++)
{
var model = new ImportModel <T>();
var data = lines[i].Split(Separator);
if (idIdx >= 0 && CsvHeader.Length == data.Length)
{
if (Int32.TryParse(data[idIdx], out int id))
{
if (id < 0)
{
model.Action = ImportAction.Delete;
model.Id = Math.Abs(id);
}
else if (id > 0)
{
model.Action = ImportAction.Update;
model.Id = id;
model.Model = CreateModelFromCsv <T>(CsvHeader, data);
}
else
{
model.Action = ImportAction.Insert;
model.Id = id;
model.Model = CreateModelFromCsv <T>(CsvHeader, data);
}
}
else
{
data[idIdx] = "0";
model.Action = ImportAction.Insert;
model.Id = id;
model.Model = CreateModelFromCsv <T>(CsvHeader, data);
}
result.Add(model);
}
}
}
}
return(result);
}
public ActionResult Import(SupplierModels model)
{
try
{
if (model.ListCompanys == null || model.ListCompanys.Count == 0)
{
ModelState.AddModelError("ListCompanys", CurrentUser.GetLanguageTextFromKey("Please choose company."));
return(View(model));
}
if (model.ExcelUpload == null || model.ExcelUpload.ContentLength <= 0)
{
ModelState.AddModelError("ExcelUpload", CurrentUser.GetLanguageTextFromKey("Excel filename cannot be null"));
return(View(model));
}
ImportModel importModel = new ImportModel();
string msg = "";
int totalRowExcel;
if (model.ExcelUpload != null && model.ExcelUpload.ContentLength > 0)
{
string fileName = Path.GetFileName(model.ExcelUpload.FileName);
string filePath = string.Format("{0}/{1}", System.Web.HttpContext.Current.Server.MapPath("~/Uploads"), fileName);
//upload file to server
if (System.IO.File.Exists(filePath))
{
System.IO.File.Delete(filePath);
}
model.ExcelUpload.SaveAs(filePath);
StatusResponse response = _factory.Import(filePath, CurrentUser.UserName, out totalRowExcel, model.ListCompanys, ref importModel, ref msg);
if (!response.Status)
{
ModelState.AddModelError("", response.MsgError);
return(View(model));
}
}
if (msg.Equals(""))
{
return(View("ImportDetail", importModel));
}
else
{
_logger.Error("Supplier_Import: " + msg);
ModelState.AddModelError("ExcelUpload", msg);
return(View(model));
}
}
catch (Exception e)
{
_logger.Error("Supplier: " + e);
ModelState.AddModelError("ExcelUpload", CurrentUser.GetLanguageTextFromKey("Import file have error"));
return(View(model));
}
}
public ActionResult Import(ImportModel importModel)
{
// Verify that the user selected a file
var importSuccess = SimSoDepRepository.ImportExcel(importModel);
ViewBag.Result = importSuccess;
return(View());
}
public ActionResult Import(SandboxImportModel model)
{
try
{
if (model.ListStores == null)
{
ModelState.AddModelError("ListStores", "Please choose language.");
return(View(model));
}
if (model.ExcelUpload == null || model.ExcelUpload.ContentLength <= 0)
{
ModelState.AddModelError("ListStores", "Excel filename cannot be null");
return(View(model));
}
ImportModel importModel = new ImportModel();
string msg = "";
// read excel file
if (model.ExcelUpload != null && model.ExcelUpload.ContentLength > 0)
{
string fileName = Path.GetFileName(model.ExcelUpload.FileName);
string filePath = string.Format("{0}/{1}", System.Web.HttpContext.Current.Server.MapPath("~/Uploads"), fileName);
//upload file to server
if (System.IO.File.Exists(filePath))
{
System.IO.File.Delete(filePath);
}
model.ExcelUpload.SaveAs(filePath);
importModel = _LanguageFactory.Import(filePath, model.ListStores[0], "Admin", ref msg);
//delete file excel after insert to database
if (System.IO.File.Exists(filePath))
{
System.IO.File.Delete(filePath);
}
}
if (msg.Equals(""))
{
return(View("ImportDetail", importModel));
}
else
{
_logger.Error("Language_Import: " + msg);
ModelState.AddModelError("ListStores", msg);
return(View(model));
}
}
catch (Exception e)
{
_logger.Error("Language_Import: " + e);
ModelState.AddModelError("ListStores", "Import file have error.");
return(View(model));
}
}
/// <summary>
/// Import Constructor
/// </summary>
/// <param name="project">Reference to project.</param>
/// <param name="sourceDir">Source Directory to import from.</param>
/// <param name="destDir">Destination Directory to import to.</param>
public Import(Project project, string sourceDir, string destDir)
{
InitializeComponent();
_data = new ImportModel();
gridMain.DataContext = _data;
_project = project;
_sourceDir = sourceDir;
_destDir = destDir;
}
private static async Task <BankAccountEntity> VerifyBankAccount(ImportModel model, IUnitOfWork unitOfWork)
{
var bankAccount = await unitOfWork.BankAccountRepository.FindSingle(x => x.Id == model.BankAccountId);
if (bankAccount == null)
{
throw new NotFoundException(nameof(BankAccountEntity));
}
return(bankAccount);
}
public IHttpActionResult Import(ImportModel importModel)
{
var database = Sitecore.Configuration.Factory.GetDatabase("master");
var languageItem = database.GetItem(importModel.Language);
var uploadedFile = (MediaItem)database.GetItem(importModel.MediaItemId);
if (uploadedFile == null)
{
return new JsonResult<ImportResultModel>(null, new JsonSerializerSettings(), Encoding.UTF8, this);
}
var args = new ImportItemsArgs
{
Database = database,
FileExtension = uploadedFile.Extension.ToLower(),
FileStream = uploadedFile.GetMediaStream(),
RootItemId = new ID(importModel.ImportLocationId),
TargetLanguage = Sitecore.Globalization.Language.Parse(languageItem.Name),
Map = Map.Factory.BuildMapInfo(new ID(importModel.MappingId)),
ImportOptions = new ImportOptions
{
CsvDelimiter = new[] { importModel.CsvDelimiter },
ExistingItemHandling =
(ExistingItemHandling)
Enum.Parse(typeof(ExistingItemHandling), importModel.ExistingItemHandling),
InvalidLinkHandling =
(InvalidLinkHandling)
Enum.Parse(typeof(InvalidLinkHandling), importModel.InvalidLinkHandling),
MultipleValuesImportSeparator = importModel.MultipleValuesSeparator,
TreePathValuesImportSeparator = @"\",
FirstRowAsColumnNames = importModel.FirstRowAsColumnNames
}
};
ImportResultModel result;
try
{
Sitecore.Diagnostics.Log.Info(string.Format("EzImporter: mappingId:{0} mediaItemId:{1} firstRowAsColumnNames:{2}", importModel.MappingId, importModel.MediaItemId, args.ImportOptions.FirstRowAsColumnNames), this);
args.Timer.Start();
CorePipeline.Run("importItems", args);
args.Timer.Stop();
if (args.Aborted)
{
result = new ImportResultModel { HasError = true, Log = args.Statistics.ToString(), ErrorMessage = args.Message, ErrorDetail = args.ErrorDetail };
}
else
{
result = new ImportResultModel { Log = args.Statistics.ToString() + " Duration: " + args.Timer.Elapsed.ToString("c") };
}
}
catch (Exception ex)
{
result = new ImportResultModel { HasError = true, ErrorMessage = ex.Message, ErrorDetail = ex.ToString() };
}
return new JsonResult<ImportResultModel>(result, new JsonSerializerSettings(), Encoding.UTF8, this);
}
public ImportModel ImportData(FileStream dataStream, ImportParametersViewModel parameters)
{
var result = new ImportModel();
var xssfwb = new XSSFWorkbook(dataStream);
var sheet = xssfwb.GetSheetAt(0);
var headers = sheet.GetRow(0);
var errorWb = new XSSFWorkbook();
var errorSheet = errorWb.CreateSheet(ImportConstants.ErrorSheetName);
var errorHeadersRow = errorSheet.CreateRow(0);
for (int i = 0; i < headers.LastCellNum; i++)
{
errorHeadersRow.CreateCell(i).SetCellValue(headers.GetCell(i).ToString());
}
errorHeadersRow.CreateCell(headers.LastCellNum).SetCellValue(ImportConstants.ErrorHeader);
for (int i = 1; i <= sheet.LastRowNum; i++)
{
var currentRow = sheet.GetRow(i);
var parsedRow = ParseRow(currentRow, headers, parameters);
if (!parsedRow.ThereIsError)
{
result.Data.Add(parsedRow.RowData);
}
else
{
var errorRow = errorSheet.CreateRow(errorSheet.LastRowNum + 1);
for (int j = 0; j < errorHeadersRow.LastCellNum; j++)
{
var errorHeader = errorHeadersRow.GetCell(j).ToString();
var errorCellValue = parsedRow.RowData[errorHeader];
errorRow.CreateCell(j).SetCellValue(errorCellValue);
}
}
}
if (errorSheet.LastRowNum > -1)
{
var fileExtension = Path.GetExtension(dataStream.Name);
var fileName = dataStream.Name.Insert(dataStream.Name.IndexOf(fileExtension), ImportConstants.ErrorFile);
var errorFilePath = Path.Combine(CommonConstants.TempFolder, ImportConstants.ErrorFolder, fileName);
result.ErrorFilePath = errorFilePath;
result.ErrorsCount = errorSheet.LastRowNum;
using (var errorFile = new FileStream(errorFilePath, FileMode.Create, FileAccess.Write))
{
errorWb.Write(errorFile);
}
}
return(result);
}
public ActionResult SaveImport(List <AttendanceTrackingEntity> lstInserted)
{
var modelXml = new ImportModel();
modelXml.listAttendanceTracking = lstInserted;
var xmlFile = XMLHelper.SerializeXML <ImportModel>(modelXml);
var retVal = _iplAttendanceTracking.Insert(xmlFile);
return(Json(new
{
status = retVal
}));
}
public void DeleteObject(BagItem bagItem)
{
UIAPI.Instance.ShowModel(new SimpleModel()
{
Title = "Ìáʾ",
Message = $"È·ÈÏҪɾ³ý{bagItem.objectsModel.Name}Âð£¿",
ConfirmAction = () =>
{
ImportModel.DeleteModel(bagItem.objectsModel);
LoadObjects();
}
});
}
static async Task Main(string[] args)
{
if (args.Length != 2)
{
Console.WriteLine(Help);
return;
}
var model = new ImportModel();
model.Messages = new Dictionary <long, string>();
var context = BrowsingContext.New(Configuration.Default);
model.GroupId = long.Parse(args[0]);
var files = Directory.GetFiles(args[1]);
foreach (var file in files)
{
if (!file.EndsWith(".html"))
{
continue;
}
var f = File.ReadAllText(file);
var document = await context.OpenAsync(req => req.Content(f));
var historys = document.QuerySelectorAll("div.history");
var history = historys.FirstOrDefault();
var messages = history.QuerySelectorAll("div.message");
//var dict = new Dictionary<int, string>();
foreach (var message in messages)
{
try {
var id = long.Parse(message.Id.Substring(7));
var text = message.QuerySelectorAll("div.text").FirstOrDefault().Text();
if (text.Length > 4 && (text.Substring(0, 3).Equals("搜索 ") || text.Substring(0, 3).Equals("共找到")))
{
continue;
}
if (id % 10000 == 0)
{
Console.WriteLine($"ID: {id}\t Text: {text}");
}
model.Messages.Add(id, text.Trim());
//wr.Write(Encoding.UTF8.GetBytes($"{id.ToString()}\n{text}\n"));
//dict.Add(id, text);
} catch (System.ArgumentNullException) {
//Console.WriteLine("忽略");
}
}
File.WriteAllText($"{args[0]}.json", JsonConvert.SerializeObject(model));
}
}
public ActionResult Import(ImportModel model)
{
var file = Request.Files[0];
var fileName = file.FileName;
var ext = Path.GetExtension(fileName);
var virtualPath = string.Format("{0}/{1}/{2}/{3}{4}", "/Files", DateTime.Now.Year.ToString(), DateTime.Now.Month.ToString(), RandomIdGenerator.NewId(), ext);
var absolutePath = Server.MapPath("~/") + virtualPath.Replace("/", "\\");
var dir = Path.GetDirectoryName(absolutePath);
if (!Directory.Exists(dir))
{
Directory.CreateDirectory(dir);
}
file.SaveAs(absolutePath);
mediaService.Add(new UowMVC.Models.MediaViewModel
{
Name = model.File,
Size = file.ContentLength,
Type = (int)MediaTypeEnum.File,
Extension = ext,
RelavtivePath = virtualPath,
ResourceDomain = WebConfig.ResourceDomain
});
var dt = NPOIHelper.Import(absolutePath);
if (dt == null || dt.Rows.Count == 0)
{
return(RedirectToAction("Index", "Result", new { state = false, message = "导入失败，没有读取到内容", style = "dialog" }));
}
var count = 0;
foreach (DataRow row in dt.Rows)
{
var no = 0;
int.TryParse(row[0].ToString(), out no);
var name = row[1].ToString();
var description = row[2].ToString();
var department = new Department
{
No = no,
Name = name,
Description = description,
};
uow.Set <Department>().Add(department);
uow.Commit();
count++;
}
return(RedirectToAction("Index", "Result", new { state = true, message = "导入成功，共导入" + count + "条数据", style = "dialog" }));
}
public async Task <IActionResult> ImportFile(IFormFile importFile)
{
List <Personal> personals = new List <Personal>();
string newFileName = FileUpload(importFile);
string sWebRootFolder = _environment.WebRootPath;
string sFileName = Path.Combine("uploads", newFileName);
FileInfo file = new FileInfo(Path.Combine(sWebRootFolder, sFileName));
try
{
using (ExcelPackage package = new ExcelPackage(file))
{
ExcelWorksheet worksheet = package.Workbook.Worksheets[1];
int rowCount = worksheet.Dimension.Rows;
for (int row = 2; row <= rowCount; row++)
{
if (worksheet.Cells[row, 1] != null)
{
var personal = new Personal
{
SahisNo = CheckString(worksheet.Cells[row, 1].Value),
Adi = CheckString(worksheet.Cells[row, 2].Value),
Soyadi = CheckString(worksheet.Cells[row, 3].Value),
BabaAdi = CheckString(worksheet.Cells[row, 4].Value),
AnaAdi = CheckString(worksheet.Cells[row, 5].Value),
DogumTarihi = CheckString(worksheet.Cells[row, 6].Value),
AileNo = CheckString(worksheet.Cells[row, 16].Value)
};
personals.Add(personal);
}
}
}
}
catch (Exception ex)
{
throw ex.InnerException;
}
//await _personalService.Add(personals);
Parallel.For(0, personals.Count, i =>
{
var itemResult = AddPersonal(personals[i]);
});
ImportModel model = new ImportModel
{
Personals = personals
};
return(View(model));
}
public JsonResult Import([FromBody] ImportModel model)
{
try
{
var _geofence = KmlToGeofence(model.Kml);
return(Json(new { isSuccess = true, result = _geofence }));
}
catch (Exception ex)
{
return(Json(new { isSuccess = false, message = ex.Message }));
}
//return View();
}
public void ImportObject()
{
if (ImportModel.OpenFile())
{
ObjectsModel temp = GameManager.Instance.objectsModels.FirstOrDefault();
GameObject tempObject = CreateObject.CreateSingleObj(temp.ResourcePath);
SavePreviewImage(temp.ResourcePath);
temp.PreviewImage = temp.ResourcePath.Replace(".obj", ".png");
Destroy(tempObject);
ChangeButtonColor(ObjectButton);
LoadObjects();
}
}
private void LoadImportData()
{
ListImport = new List <ImportModel>();
var ListInput = DataProvider.Ins.Entities.InputTable;
foreach (var item in ListInput)
{
ImportModel import = new ImportModel();
import.input = item;
import.User = DataProvider.Ins.Entities.UserTable.Where(x => x.ID == item.ID_User).FirstOrDefault();
ListImport.Add(import);
}
}
public ActionResult Import(TableModels model)
{
try
{
if (model.ListStores == null)
{
ModelState.AddModelError("ListStores", _AttributeForLanguage.CurrentUser.GetLanguageTextFromKey("Please choose store"));
return(View(model));
}
if (model.ExcelUpload == null || model.ExcelUpload.ContentLength <= 0)
{
ModelState.AddModelError("ExcelUpload", _AttributeForLanguage.CurrentUser.GetLanguageTextFromKey("Excel filename cannot be null"));
return(View(model));
}
ImportModel importModel = new ImportModel();
string msg = "";
StatusResponse response = _factory.Import(model.ExcelUpload, model.ListStores, ref importModel, ref msg);
if (!response.Status)
{
ModelState.AddModelError("", response.MsgError);
return(View(model));
}
// Delete File Excel and File Zip Image
CommonHelper.DeleteFileFromServer(CommonHelper.GetFilePath(model.ExcelUpload));
//if (!ModelState.IsValid)
// return View(model);
if (msg.Equals(""))
{
return(View("ImportDetail", importModel));
}
else
{
_logger.Error("Table_Import: " + msg);
ModelState.AddModelError("ImageZipUpload", msg);
return(View(model));
}
}
catch (Exception e)
{
_logger.Error("Table_Import : " + e);
//return new HttpStatusCodeResult(400, e.Message);
ModelState.AddModelError("ExcelUpload", _AttributeForLanguage.CurrentUser.GetLanguageTextFromKey("Import file have error"));
return(View(model));
}
}
