public List<ImportResult> ProcessPath(string path, ImportMode importMode = ImportMode.Auto, Series series = null, DownloadClientItem downloadClientItem = null)
{
if (_diskProvider.FolderExists(path))
{
var directoryInfo = new DirectoryInfo(path);
if (series == null)
{
return ProcessFolder(directoryInfo, importMode, downloadClientItem);
}
return ProcessFolder(directoryInfo, importMode, series, downloadClientItem);
}
if (_diskProvider.FileExists(path))
{
var fileInfo = new FileInfo(path);
if (series == null)
{
return ProcessFile(fileInfo, importMode, downloadClientItem);
}
return ProcessFile(fileInfo, importMode, series, downloadClientItem);
}
_logger.Error("Import failed, path does not exist or is not accessible by Sonarr: {0}", path);
return new List<ImportResult>();
}
public ImportActivity(
ImportMode mode,
SqlConnection connection,
BatchParams batchParams,
string targetTable,
char csvDelimiterChar,
string numberFormatInfo,
IEnumerable<CsvColumnInfo> csvMetadata)
{
if (connection == null)
throw new ArgumentNullException("connection");
if (string.IsNullOrEmpty(targetTable))
throw new ArgumentException("Target table name cannot be empty", "targetTable");
if (csvMetadata == null)
throw new ArgumentNullException("csvMetadata");
_mode = mode;
_csvMetadata = csvMetadata;
_csvDelimiterChar = csvDelimiterChar;
_numberFormatInfo = numberFormatInfo;
_loader = DataLoaderBase.CreateLoader(
mode,
connection,
batchParams,
targetTable,
_csvMetadata
.Where(sci => !sci.ExcludeFromMapping && (mode != ImportMode.BulkDelete || sci.DeletionKey))
.Select(sci => sci.Name));
}
/// <summary>
/// ctor which takes a Device object along with import mode
/// </summary>
/// <param name="device"></param>
/// <param name="importmode"></param>
public ExportImportDevice(Device device, ImportMode importmode)
{
this.Id = device.Id;
this.ETag = device.ETag;
this.ImportMode = importmode;
this.Status = device.Status;
this.StatusReason = device.StatusReason;
this.Authentication = device.Authentication;
}
public static DataLoaderBase CreateLoader(ImportMode mode, SqlConnection connection,
BatchParams batchParams, string targetTable, IEnumerable<string> columns)
{
switch (mode)
{
case ImportMode.BulkInsert:
return new BulkDataLoader(connection, batchParams, targetTable, columns, false);
case ImportMode.BulkInsertWithSkipped:
return new BulkDataLoader(connection, batchParams, targetTable, columns, true);
case ImportMode.BulkDelete:
return new DeleteDataLoader(connection, batchParams, targetTable, columns);
case ImportMode.Smart:
return new SmartDataLoader(connection, batchParams, targetTable, columns);
default:
throw new InvalidOperationException("Unknown ImportMode - '" + mode.ToString() + "'");
}
}
static IEnumerable <ExportImportDevice> GenerateExportImportDeviceListForBulkOperations(IEnumerable <Device> devices, ImportMode importMode)
{
if (devices == null)
{
throw new ArgumentNullException(nameof(devices));
}
if (!devices.Any())
{
throw new ArgumentException(nameof(devices));
}
var exportImportDeviceList = new List <ExportImportDevice>(devices.Count());
foreach (Device device in devices)
{
ValidateDeviceId(device);
switch (importMode)
{
case ImportMode.Create:
if (!string.IsNullOrWhiteSpace(device.ETag))
{
throw new ArgumentException(ApiResources.ETagSetWhileRegisteringDevice);
}
break;
case ImportMode.Update:
// No preconditions
break;
case ImportMode.UpdateIfMatchETag:
if (string.IsNullOrWhiteSpace(device.ETag))
{
throw new ArgumentException(ApiResources.ETagNotSetWhileUpdatingDevice);
}
break;
case ImportMode.Delete:
// No preconditions
break;
case ImportMode.DeleteIfMatchETag:
if (string.IsNullOrWhiteSpace(device.ETag))
{
throw new ArgumentException(ApiResources.ETagNotSetWhileDeletingDevice);
}
break;
default:
throw new ArgumentException(IotHubApiResources.GetString(ApiResources.InvalidImportMode, importMode));
}
var exportImportDevice = new ExportImportDevice(device, importMode);
exportImportDeviceList.Add(exportImportDevice);
}
return(exportImportDeviceList);
}
/// <summary>
/// Returns true if the mode is Compute or ImportOrCompute.
/// </summary>
private static bool ShouldCompute(ImportMode mode)
{
return(mode == ImportMode.Compute || mode == ImportMode.ImportOrCompute);
}
private void GetDuplicates(ImportProductPrice[] importProductPrices, ValidationContext <ImportProductPrice[]> context, ImportMode importMode)
{
var duplicates = importProductPrices.GroupBy(importProductPrice => new { importProductPrice.Sku, importProductPrice.Price.MinQuantity })
.SelectMany(group => importMode == ImportMode.CreateOnly ? group.Skip(1) : group.Take(group.Count() - 1))
.ToArray();
context.RootContextData[Duplicates] = duplicates;
}
private List<ImportResult> ProcessFolder(DirectoryInfo directoryInfo, ImportMode importMode, Series series, DownloadClientItem downloadClientItem)
{
if (_seriesService.SeriesPathExists(directoryInfo.FullName))
{
_logger.Warn("Unable to process folder that is mapped to an existing show");
return new List<ImportResult>();
}
var cleanedUpName = GetCleanedUpFolderName(directoryInfo.Name);
var folderInfo = Parser.Parser.ParseTitle(directoryInfo.Name);
if (folderInfo != null)
{
_logger.Debug("{0} folder quality: {1}", cleanedUpName, folderInfo.Quality);
}
var videoFiles = _diskScanService.GetVideoFiles(directoryInfo.FullName);
if (downloadClientItem == null)
{
foreach (var videoFile in videoFiles)
{
if (_diskProvider.IsFileLocked(videoFile))
{
return new List<ImportResult>
{
FileIsLockedResult(videoFile)
};
}
}
}
var decisions = _importDecisionMaker.GetImportDecisions(videoFiles.ToList(), series, folderInfo, true);
var importResults = _importApprovedEpisodes.Import(decisions, true, downloadClientItem, importMode);
if ((downloadClientItem == null || !downloadClientItem.IsReadOnly) &&
importResults.Any(i => i.Result == ImportResultType.Imported) &&
ShouldDeleteFolder(directoryInfo, series))
{
_logger.Debug("Deleting folder after importing valid files");
_diskProvider.DeleteFolder(directoryInfo.FullName, true);
}
return importResults;
}
private LoadCounters ProcessImportTask( ImportEntity impEntity, ImportMode impMode,
FileInfo dataFile, string logname, ref int rowcount, ref int skiprowcount, ref int errorcode )
{
using( var stream = ReadDataFile( dataFile ) )
{
var report = ImportFacade.ImportData( impEntity.GetFormatName(), impMode, stream, dataFile.Name );
if( Configuration.LogDetails && ( report.HasValidationErrors || report.HasErrors ) )
{
Encoding encoding = Encoding.GetEncoding( Configuration.LogEncoding );
using( var log = new StreamWriter( logname, false, encoding ) )
{
log.WriteLine( "found={0}", report.TotalCount );
if( report.HasValidationErrors )
{
log.WriteLine( "*** Parse and validation errors ***" );
foreach( var error in report.ValidationErrors )
{
log.WriteLine( "source record: " + error.RawRecord );
foreach( var detail in error.Details )
{
detail.WriteToLog( log );
}
}
}
if( report.HasErrors )
{
foreach( var error in report.Errors )
LogException( error, log );
}
}
}
rowcount = impMode == ImportMode.BulkDelete ? report.Counters.Deleted : report.Counters.Added;
skiprowcount = report.Counters.Skipped;
int totalrows = rowcount + skiprowcount;
errorcode = totalrows == report.TotalCount ? 0 : totalrows == 0 ? 2920 : 2910;
return report.Counters;
}
}
void ImportPosts(Id entryCollectionId, Id pagesCollectionId, Id mediaCollectionId, ImportMode mode, BlogMLBlog blog)
{
foreach (BlogMLPost post in blog.Posts)
{
LogProgress("Loading post with ID={0}", post.ID);
try
{
AtomEntry entry = new AtomEntry();
entry.Title = new AtomTitle() { Text = post.Title };
if (post.HasExcerpt) entry.Summary = new AtomSummary() { Text = post.Excerpt.UncodedText };
entry.Content = new AtomContent() { Type = "html", Text = post.Content.Text };
entry.Control = new AppControl();
entry.Control.Approved = post.Approved;
//categories
var ecats = new List<AtomCategory>();
foreach (BlogMLCategoryReference cat in post.Categories)
{
var ec = blog.Categories.Where(c => c.ID == cat.Ref).SingleOrDefault();
if (ec == null) throw new Exception("Invalid category reference in BlogML file.");
ecats.Add(new AtomCategory() { Term = ec.Title });
}
entry.Categories = ecats;
//authors
var eauths = new List<AtomPerson>();
for (int i = 0; i < post.Authors.Count; i++)
{
var user = UserRepository.GetUser(post.Authors[i].Ref);
if (user == null) throw new Exception("Invalid author reference in BlogML file.");
eauths.Add(user.ToAtomAuthor());
}
entry.Authors = eauths;
entry.Published = post.DateCreated;
entry.Updated = post.DateModified;
////fix links http://localhost:1333 to new address
//string xmlstr = entry.Xml.ToString();
//xmlstr = xmlstr.Replace("http://localhost:1333/", appSvc.Base.ToString());
//entry.Xml = XElement.Parse(xmlstr);
//TODO: add old link
//entry.Links =
//post to blog when normal, otherwise pages collection
if (post.PostType == BlogML.BlogPostTypes.Normal)
entry = AtomPubService.CreateEntry(entryCollectionId, entry, post.PostName);
else if (pagesCollectionId != null)
entry = AtomPubService.CreateEntry(pagesCollectionId, entry, post.PostName);
else
{
LogProgress("Skipping {0} posts as there is no pages collection selected", post.PostType.ToString());
continue;
}
LogProgress("Post added as new entry in collection with ID={0}", entry.Id);
if (mediaCollectionId != null)
{
foreach (BlogMLAttachment attachment in post.Attachments)
{
try
{
string name = null;
if (!string.IsNullOrEmpty(attachment.Path)) name = Path.GetFileNameWithoutExtension(attachment.Path);
if (name == null && !string.IsNullOrEmpty(attachment.Url)) name = attachment.Url.IndexOf('/') > 0 ?
attachment.Url.Substring(attachment.Url.LastIndexOf('/')) : attachment.Url;
if (name == null) name = "Attachment";
Stream stream = null;
if (attachment.Embedded)
{
LogProgress("Processing embedded attachment '{0}'", name);
stream = new MemoryStream(attachment.Data);
}
else if (!string.IsNullOrEmpty(attachment.Path) && File.Exists(attachment.Path))
{
LogProgress("Processing local attachment '{0}'", name);
//first try to get locally
stream = File.OpenRead(attachment.Path);
}
else
{
LogProgress("Processing remote attachment '{0}'", name);
//next try to download
stream = new WebClient().OpenRead(attachment.Url);
}
var media = AtomPubService.CreateMedia(mediaCollectionId, stream, name, attachment.MimeType);
LogProgress("New media created from attachment with Id={0}", media.Id);
//update entry with new media url
entry.Content.Text = entry.Content.Text.Replace(attachment.Url, media.Content.Src.ToString());
}
catch (Exception ex)
{
LogService.Error(ex);
LogProgress(System.Web.HttpUtility.HtmlEncode(ex.Message));
}
}
}
foreach (BlogMLComment comment in post.Comments)
{
try
{
LogProgress("Processing comment for post with ID={0}", comment.ID);
AtomEntry acmt = new AtomEntry();
acmt.Control = new AppControl();
acmt.Title = new AtomTitle() { Text = string.IsNullOrEmpty(comment.Title) ? "Comment" : comment.Title };
acmt.Content = new AtomContent() { Type = "html", Text = comment.Content.Text };
acmt.Published = comment.DateCreated;
acmt.Updated = comment.DateModified;
acmt.Control.Approved = comment.Approved;
//TODO: detect if user and set ID
acmt.Authors = Enumerable.Repeat(new AtomPerson(Atom.AtomNs + "author")
{
Email = comment.UserEMail,
Name = comment.UserName,
Uri = !string.IsNullOrEmpty(comment.UserUrl) ? new Uri(comment.UserUrl) : null
}, 1);
acmt = AnnotateService.Annotate(entry.Id, acmt, comment.ID);
LogProgress("Comment added as new annotation on entry with ID={0}", acmt.Id);
}
catch (Exception ex)
{
LogService.Error(ex);
LogProgress(System.Web.HttpUtility.HtmlEncode(ex.Message));
}
}
foreach (BlogMLTrackback trackback in post.Trackbacks)
{
try
{
LogProgress("Processing trackback for post with ID={0}", trackback.ID);
AtomEntry atb = new AtomEntry();
atb.AnnotationType = "trackback";
atb.Title = new AtomTitle() { Text = trackback.Title };
atb.Control = new AppControl();
atb.Control.Approved = trackback.Approved;
atb.Published = trackback.DateCreated;
atb.Updated = trackback.DateModified;
atb.Content = new AtomContent() { Src = new Uri(trackback.Url), Type = "text/html" };
atb.Authors = new List<AtomPerson>() { new AtomAuthor()
{
Name = "Trackback",// string.Empty,
Uri = new Uri(trackback.Url)
} };
AnnotateService.Annotate(entry.Id, atb, trackback.ID);
LogProgress("Trackback added as new annotation on entry with ID={0}", atb.Id);
}
catch (Exception ex)
{
LogService.Error(ex);
LogProgress(System.Web.HttpUtility.HtmlEncode(ex.Message));
}
}
}
catch (Exception ex)
{
LogService.Error(ex);
LogProgress(System.Web.HttpUtility.HtmlEncode(ex.Message));
}
}
}
/// <summary>
/// 导入数据到关系数据库
/// </summary>
/// <typeparam name="T">实体类类型</typeparam>
/// <param name="mode">导入模式</param>
/// <param name="isNew">导入模式为更新模式的时候，进行实体类数据新旧比较的自定义方法，第一个参数为源实体，第二个参数为数据库的目标实体，返回源是否比目标新</param>
/// <returns>导入的数据数量</returns>
public ImportResult Import <T>(ImportMode mode, Func <T, T, bool> isNew) where T : EntityBase, new()
{
Type entityType = typeof(T);
string importTableName = EntityFieldsCache.Item(entityType).TableName;
ImportResult result = new ImportResult();
result.ImportTable = importTableName;
result.IsCancel = true;
//导出批次管理
List <ExportBatchInfo> batchList = MemDB.Get <ExportBatchInfo>();
ExportBatchInfo currBatch = batchList.FirstOrDefault(p => p.ExportTableName == importTableName);
if (currBatch == null)
{
result.Flag = ImportResultFlag.NoBatchInfo;
return(result);//没有导入批次信息，不能导入
}
//只有比数据库的导入批次数据新，才可以导入
OQL q = OQL.From(currBatch)
.Select()
.Where(currBatch.ExportTableName)
.END;
ExportBatchInfo dbBatch = this.CurrDbContext.QueryObject <ExportBatchInfo>(q);
if (dbBatch == null)
{
currBatch.SetDefaultChanges();
this.CurrDbContext.Add <ExportBatchInfo>(currBatch);
result.BatchNumber = currBatch.BatchNumber;
}
else
{
result.BatchNumber = currBatch.BatchNumber;
if (currBatch.BatchNumber <= dbBatch.BatchNumber)
{
result.Flag = ImportResultFlag.IsOldData;
return(result);//没有新数据需要导入
}
currBatch.ID = dbBatch.ID;
}
//导入数据
int count = 0;//
List <T> list = this.MemDB.Get <T>();
if (list.Count > 0)
{
ImportEntityEventArgs args = new ImportEntityEventArgs(list, entityType, importTableName, currBatch.BatchNumber);
if (BeforeImport != null)
{
BeforeImport(this, args);
if (args.Cancel)
{
result.Flag = ImportResultFlag.UserCanceled;
return(result);
}
}
if (mode == ImportMode.Append)
{
list.ForEach(item => {
item.SetDefaultChanges();
});
count = this.CurrDbContext.AddList(list);
}
else if (mode == ImportMode.TruncateAndInsert)
{
string sql = "TRUNCATE TABLE [" + importTableName + "]";
this.CurrDbContext.CurrentDataBase.ExecuteNonQuery(sql);
list.ForEach(item =>
{
item.SetDefaultChanges();
});
count = this.CurrDbContext.AddList(list);
}
else if (mode == ImportMode.Update)
{
if (isNew == null)
{
throw new ArgumentNullException("当 ImportMode 为Update 模式的时候，参数 isNew 不能为空。");
}
foreach (T item in list)
{
T dbEntity = (T)item.Clone();
EntityQuery eq = new EntityQuery(this.CurrDbContext.CurrentDataBase);
if (eq.FillEntity(dbEntity))
{
if (isNew(item, dbEntity))
{
item.SetDefaultChanges();//设置了更改状态，才可以更新到数据库
count += eq.Update(item);
}
}
}
}
else if (mode == ImportMode.Merge)
{
foreach (T item in list)
{
T dbEntity = (T)item.Clone();
EntityQuery eq = new EntityQuery(this.CurrDbContext.CurrentDataBase);
if (eq.FillEntity(dbEntity))
{
int changedCount = dbEntity.MapFrom(item, true);
if (changedCount > 0)
{
count += eq.Update(dbEntity);
}
}
else
{
//没有Fill成功实体，说明数据库没有此数据，则添加数据到数据库
item.SetDefaultChanges();
count += eq.Insert(item);
}
}
}
else
{
//自定义的处理方式，请在 BeforeImport 事件自行处理
}
if (AfterImport != null)
{
args.Cancel = false;
AfterImport(this, args);
}
}//end if
//更新导入批次信息
currBatch.BatchNumber = result.BatchNumber;
currBatch.LastExportDate = DateTime.Now;
this.CurrDbContext.Update <ExportBatchInfo>(currBatch);
result.IsCancel = false;
result.Flag = ImportResultFlag.Succeed;
result.ImportCount = count;
return(result);
}
public void DrawAssetImportParams(Rect r2, ImportAssetsWindow importAssetsWindow)
{
this.updateWindow = importAssetsWindow;
//string gameObjectName = parameter.gameObjectName;
//if (gameObjectName == null)
// gameObjectName = parameter.gameObjectName = this.hierarchy.GetGameObjectName(parameter.gameObjectInstanceID);
float w = r2.width;
r2.height = Constants.SingleLineHeight;
//Rect r2 = GUILayoutUtility.GetRect(22F, Constants.SingleLineHeight);
bool canRemember = this.localAsset == null &&
this.isSupported == true;
if (Event.current.type == EventType.MouseDown)
{
if (canRemember == true)
{
r2.width -= AssetImportParameters.RememberLabelWidth + AssetImportParameters.RememberSpacing + AssetImportParameters.LocationButtonWidth;
}
else
{
r2.width -= AssetImportParameters.LocationButtonWidth;
}
//if (r2.Contains(Event.current.mousePosition) == true)
//{
// this.hierarchy.PingObject(this.gameObjectInstanceID);
// Event.current.Use();
//}
if (canRemember == true)
{
r2.width += AssetImportParameters.RememberLabelWidth + AssetImportParameters.RememberSpacing + AssetImportParameters.LocationButtonWidth;
}
else
{
r2.width += AssetImportParameters.LocationButtonWidth;
}
}
GUI.Box(r2, string.Empty, GeneralStyles.Toolbar);
//if (Event.current.type == EventType.Repaint)
//{
// Rect r3 = r2;
// r3.width = 1F;
// r3.height = r3.height * 4F + 6F;
// //EditorGUI.DrawRect(r3, Color.cyan);
//}
r2.width = ImportAssetsWindow.GameObjectIconWidth;
GUI.DrawTexture(r2, AssetPreview.GetMiniTypeThumbnail(this.type), ScaleMode.ScaleToFit);
r2.x += r2.width;
string name = this.name ?? (this.name = this.hierarchy.GetResourceName(this.type, this.instanceID));
if (name == null)
{
GUI.Label(r2, GeneralStyles.StatusWheel);
r2.x += r2.width;
r2.width = w - r2.x;
GUI.Label(r2, this.type.Name);
importAssetsWindow.Repaint();
}
else
{
r2.width = w - r2.x;
GUI.Label(r2, this.type.Name + " : " + this.name);
}
r2.x = r2.width + ImportAssetsWindow.GameObjectIconWidth - AssetImportParameters.RememberLabelWidth - AssetImportParameters.RememberSpacing - AssetImportParameters.LocationButtonWidth;
r2.width = AssetImportParameters.RememberLabelWidth;
if (canRemember == true)
{
this.remember = GUI.Toggle(r2, this.remember, "Remember", GeneralStyles.ToolbarToggle);
}
r2.x += r2.width + AssetImportParameters.RememberSpacing;
r2.width = AssetImportParameters.LocationButtonWidth;
if (GUI.Button(r2, "Locations (" + this.originPath.Count + ")", GeneralStyles.ToolbarButton) == true)
{
PopupWindow.Show(r2, new AssetLocationsWindow(this.hierarchy, this.originPath));
//importAssets2.importingAssetsParams.Remove(this);
}
r2.y += r2.height + 2F;
r2.x = 5F;
r2.width = w - r2.x;
using (LabelWidthRestorer.Get(120F))
{
int pathsCount = this.originPath.Count;
//if (pathsCount == 1)
// EditorGUI.LabelField(r2, "Component Path", this.originPath[0]);
//else if (pathsCount > 1)
//{
// EditorGUI.LabelField(r2, "Component Path", string.Empty);
// r2.xMin += EditorGUIUtility.labelWidth;
// if (GUI.Button(r2, "Many (" + pathsCount + ")", GeneralStyles.ToolbarDropDown) == true)
// {
// }
// r2.xMin -= EditorGUIUtility.labelWidth;
//}
r2.y += /*r2.height + */ 2F;
if (this.localAsset != null)
{
EditorGUI.ObjectField(r2, "Asset", this.localAsset, this.type, false);
}
else if (this.isSupported == false)
{
r2.height = 24F;
r2.xMin += 5F;
r2.xMax -= 5F;
EditorGUI.HelpBox(r2, "Not supported.", MessageType.Warning);
}
else
{
bool hasError = this.importMode == ImportMode.None;
//EditorGUILayout.BeginHorizontal();
{
using (LabelWidthRestorer.Get(100F))
{
if (pathsCount > 0)
{
EditorGUI.BeginDisabledGroup(this.parametersConfirmed == true);
{
//r2.width = 182F/* - EditorGUI.indentLevel * 15F*/;
this.importMode = (ImportMode)EditorGUI.EnumPopup(r2, "Import Mode", this.importMode);
r2.y += r2.height;
}
EditorGUI.EndDisabledGroup();
}
//EditorGUILayout.BeginVertical();
{
EditorGUI.BeginDisabledGroup(this.parametersConfirmed == true);
{
if (this.importMode == ImportMode.Auto)
{
if (this.name == null)
{
this.name = this.hierarchy.GetResourceName(this.type, this.instanceID);
}
if (this.autoPath == null && this.name != null)
{
IObjectImporter importer = RemoteUtility.GetImportAssetTypeSupported(this.type);
if (importer != null)
{
string path = this.prefabPath;
string filename = string.Join("_", this.name.Split(Path.GetInvalidFileNameChars())) + importer.GetExtension();
if (string.IsNullOrEmpty(this.hierarchy.specificSharedSubFolder) == false)
{
path = this.hierarchy.specificSharedSubFolder;
}
//if (this.hierarchy.rawCopyAssetsToSubFolder == true)
// path += "/" + .gameObjectName;
//else if (this.hierarchy.prefixAsset == true)
// filename = string.Join("_", (parameter.gameObjectName).Split(Path.GetInvalidFileNameChars())) + '_' + filename;
this.autoPath = path + "/" + filename;
}
}
if (/*parameter.gameObjectName != null && */ this.name != null)
{
if (this.autoPath == null)
{
r2.height = 24F;
hasError = true;
EditorGUI.HelpBox(r2, "Asset type is not supported, will not be imported.", MessageType.Warning);
r2.y += r2.height;
}
else
{
EditorGUI.BeginChangeCheck();
this.autoPath = NGEditorGUILayout.SaveFileField(r2, "Output Path", this.autoPath);
if (EditorGUI.EndChangeCheck() == true)
{
Uri pathUri;
bool isValidUri = Uri.TryCreate(this.autoPath, UriKind.Relative, out pathUri);
bool v = isValidUri && pathUri != null /* && pathUri.IsLoopback*/;
//FileInfo fi = null;
//try
//{
// fi = new FileInfo(parameter.autoPath);
//}
//catch (System.ArgumentException) { }
//catch (PathTooLongException) { }
//catch (System.NotSupportedException) { }
if (v == false)
{
//if (ReferenceEquals(fi, null))
this.autoPathError = "Path is invalid.";
}
// file name is not valid
else
{
this.autoPathError = null;
}
// file name is valid... May check for existence by calling fi.Exists.
}
r2.y += r2.height;
if (string.IsNullOrEmpty(this.autoPathError) == false)
{
r2.height = 24F;
EditorGUI.HelpBox(r2, this.autoPathError, MessageType.Error);
r2.y += r2.height;
}
}
}
else
{
Utility.content.text = "Waiting for server...";
EditorGUI.LabelField(r2, Utility.content, GeneralStyles.StatusWheel);
r2.y += r2.height;
importAssetsWindow.Repaint();
}
}
else if (this.importMode == ImportMode.UseGUID)
{
EditorGUI.BeginChangeCheck();
Object o = EditorGUI.ObjectField(r2, "Asset", this.guidAsset, this.type, false);
if (EditorGUI.EndChangeCheck() == true)
{
this.guidAsset = o;
this.guid = AssetDatabase.AssetPathToGUID(AssetDatabase.GetAssetPath(o));
}
r2.y += r2.height;
EditorGUI.LabelField(r2, "GUID", this.guid ?? "None");
r2.y += r2.height;
if (string.IsNullOrEmpty(this.guid) == true)
{
hasError = true;
}
}
else if (this.importMode == ImportMode.RawCopy)
{
EditorGUI.BeginChangeCheck();
string path = NGEditorGUILayout.SaveFileField(r2, "Output Path", this.outputPath);
if (EditorGUI.EndChangeCheck() == true)
{
if (path.StartsWith(Application.dataPath) == true)
{
this.outputPath = path.Substring(Application.dataPath.Length - "Assets".Length);
}
else if (path.StartsWith("Assets") == true)
{
this.outputPath = path;
}
}
r2.y += r2.height;
if (string.IsNullOrEmpty(path) == false &&
path.StartsWith(Application.dataPath) == false &&
path.StartsWith("Assets") == false)
{
hasError = true;
r2.height = 24F;
EditorGUI.HelpBox(r2, "Path must be in Assets folder.", MessageType.Warning);
r2.y += r2.height;
}
}
}
EditorGUI.EndDisabledGroup();
r2.y += 2F;
r2.height = Constants.SingleLineHeight;
if (this.parametersConfirmed == true)
{
if (this.importErrorMessage != null)
{
r2.xMin += 5F;
r2.height = 32F;
EditorGUI.HelpBox(r2, "Import failed : " + this.importErrorMessage, MessageType.Error);
}
else if (this.copyAsset != null && (this.importMode == ImportMode.RawCopy || this.importMode == ImportMode.Auto))
{
EditorGUI.ObjectField(r2, "Created Asset", this.copyAsset, this.type, false);
}
else if (this.totalBytes > 0)
{
r2.xMin += 5F;
if (this.bytesReceived == this.totalBytes)
{
EditorGUI.ProgressBar(r2, 1F, "Creating asset...");
}
else
{
float rate = (float)this.bytesReceived / (float)this.totalBytes;
string cacheFileSize;
if (this.totalBytes >= 1024 * 1024)
{
cacheFileSize = ((float)(this.bytesReceived / (1024F * 1024F))).ToString("N1") + " / " + ((float)(this.totalBytes / (1024F * 1024F))).ToString("N1") + " MiB";
}
else if (this.totalBytes >= 1024)
{
cacheFileSize = ((float)(this.bytesReceived / 1024F)).ToString("N1") + " / " + ((float)(this.totalBytes / 1024F)).ToString("N1") + " KiB";
}
else
{
cacheFileSize = this.bytesReceived + " / " + this.totalBytes + " B";
}
EditorGUI.ProgressBar(r2, rate, cacheFileSize + " (" + (rate * 100F).ToString("0.0") + "%)");
importAssetsWindow.Repaint();
}
}
}
else
{
EditorGUI.BeginDisabledGroup(hasError);
{
r2.width = 100F;
r2.x = w - r2.width - 10F;
if (GUI.Button(r2, "Confirm") == true)
{
this.Confirm();
importAssetsWindow.Repaint();
}
}
EditorGUI.EndDisabledGroup();
}
}
}
if (Conf.DebugMode != Conf.DebugState.None && this.importErrorMessage != null && GUI.Button(r2, "Retry Import") == true)
{
this.ResetImport();
}
}
}
}
}
public static bool OwnerMustBeSet(EntityReference sourceOwnerId, EntityReference ownerInCrm, ImportMode setOwnerMode)
{
if (sourceOwnerId != null && Constants.UpdateModes.Contains(setOwnerMode))
{
bool ownerIsEqualToCurrentOwner = ownerInCrm != null && sourceOwnerId.Id == ownerInCrm.Id;
if (!ownerIsEqualToCurrentOwner || (setOwnerMode != ImportMode.UpdateChangedValuesOnly && setOwnerMode != ImportMode.AllChangedValuesOnly))
{
return(true);
}
}
return(false);
}
/// <summary>
/// Gets the hash code
/// </summary>
/// <returns>Hash code</returns>
public override int GetHashCode()
{
unchecked // Overflow is fine, just wrap
{
var hashCode = 41;
// Suitable nullity checks etc, of course :)
if (Name != null)
{
hashCode = hashCode * 59 + Name.GetHashCode();
}
if (Type != null)
{
hashCode = hashCode * 59 + Type.GetHashCode();
}
if (ImportMode != null)
{
hashCode = hashCode * 59 + ImportMode.GetHashCode();
}
if (AclHandling != null)
{
hashCode = hashCode * 59 + AclHandling.GetHashCode();
}
if (PackageRoots != null)
{
hashCode = hashCode * 59 + PackageRoots.GetHashCode();
}
if (PackageFilters != null)
{
hashCode = hashCode * 59 + PackageFilters.GetHashCode();
}
if (PropertyFilters != null)
{
hashCode = hashCode * 59 + PropertyFilters.GetHashCode();
}
if (TempFsFolder != null)
{
hashCode = hashCode * 59 + TempFsFolder.GetHashCode();
}
if (UseBinaryReferences != null)
{
hashCode = hashCode * 59 + UseBinaryReferences.GetHashCode();
}
if (AutoSaveThreshold != null)
{
hashCode = hashCode * 59 + AutoSaveThreshold.GetHashCode();
}
if (CleanupDelay != null)
{
hashCode = hashCode * 59 + CleanupDelay.GetHashCode();
}
if (FileThreshold != null)
{
hashCode = hashCode * 59 + FileThreshold.GetHashCode();
}
if (MEGA_BYTES != null)
{
hashCode = hashCode * 59 + MEGA_BYTES.GetHashCode();
}
if (UseOffHeapMemory != null)
{
hashCode = hashCode * 59 + UseOffHeapMemory.GetHashCode();
}
if (DigestAlgorithm != null)
{
hashCode = hashCode * 59 + DigestAlgorithm.GetHashCode();
}
if (MonitoringQueueSize != null)
{
hashCode = hashCode * 59 + MonitoringQueueSize.GetHashCode();
}
if (PathsMapping != null)
{
hashCode = hashCode * 59 + PathsMapping.GetHashCode();
}
if (StrictImport != null)
{
hashCode = hashCode * 59 + StrictImport.GetHashCode();
}
return(hashCode);
}
}
protected List <dynamic> CreateCommandsInOrder(
ImportMode importMode,
int id,
DateTime from,
DateTime until)
{
var importSubaddressCommands = new List <ImportSubaddressFromCrab>();
List <ImportSubaddressFromCrab> importSubaddressHistCommands;
List <ImportSubaddressStatusFromCrab> importSubaddressStatusCommands;
List <ImportSubaddressStatusFromCrab> importSubaddressStatusHistCommands;
List <ImportSubaddressPositionFromCrab> importSubaddressPositionCommands;
List <ImportSubaddressPositionFromCrab> importSubaddressPositionHistCommands;
var importHouseNumberSubaddressCommands = new List <ImportHouseNumberSubaddressFromCrab>();
List <ImportHouseNumberSubaddressFromCrab> importHouseNumberSubaddressCommandsHist;
var importSubaddressMailCantonCommands = new List <ImportSubaddressMailCantonFromCrab>();
List <ImportSubaddressMailCantonFromCrab> importSubaddressMailCantonCommandsHist;
using (var context = _crabEntitiesFactory())
{
var importSubaddressFromCrab = AdresSubadresQueries.GetTblSubadresBySubadresId(id, context);
if (importSubaddressFromCrab != null)
{
importSubaddressCommands = new List <ImportSubaddressFromCrab> {
CrabSubaddressMapper.Map(importSubaddressFromCrab)
}
}
;
importSubaddressHistCommands = CrabSubaddressMapper.Map(AdresSubadresQueries.GetTblSubadresHistBySubadresId(id, context)).ToList();
importSubaddressStatusCommands = CrabSubaddressStatusMapper.Map(AdresSubadresQueries.GetTblSubadresstatussesBySubadresId(id, context)).ToList();
importSubaddressStatusHistCommands = CrabSubaddressStatusMapper.Map(AdresSubadresQueries.GetTblSubadresstatussesHistBySubadresId(id, context)).ToList();
importSubaddressPositionCommands = CrabSubaddressPositionMapper.Map(AdresSubadresQueries.GetTblAdrespositiesBySubadresId(id, context)).ToList();
importSubaddressPositionHistCommands = CrabSubaddressPositionMapper.Map(AdresSubadresQueries.GetTblAdrespositiesHistBySubadresId(id, context)).ToList();
var allHouseNumbers = importSubaddressHistCommands.Select(x => (int)x.HouseNumberId).ToList();
if (importSubaddressFromCrab != null)
{
allHouseNumbers.Add((int)importSubaddressCommands.First().HouseNumberId);
}
allHouseNumbers = allHouseNumbers.Distinct().ToList();
foreach (var houseNumber in allHouseNumbers)
{
var tblHuisNummerByHuisnummerId = AdresHuisnummerQueries.GetTblHuisNummerByHuisnummerId(houseNumber, context);
if (tblHuisNummerByHuisnummerId != null)
{
var importHouseNumberSubadresFromCrab = CrabSubaddressHouseNumberMapper.Map(tblHuisNummerByHuisnummerId, id);
if (importHouseNumberSubadresFromCrab != null)
{
importHouseNumberSubaddressCommands.Add(importHouseNumberSubadresFromCrab);
}
}
importSubaddressMailCantonCommands.AddRange(
CrabSubaddressMailCantonMapper.GetCommandsFor(AdresHuisnummerQueries.GetTblHuisnummerPostkantonsByHuisnummerId(houseNumber, context), id));
}
importHouseNumberSubaddressCommandsHist =
CrabSubaddressHouseNumberMapper.Map(AdresHuisnummerQueries.GetTblHuisNummerHistByHuisnummerIds(allHouseNumbers, context), id).ToList();
importSubaddressMailCantonCommandsHist =
CrabSubaddressMailCantonMapper.GetCommandsFor(AdresHuisnummerQueries.GetTblHuisnummerPostKantonHistsByHuisnummerIds(allHouseNumbers, context),
id).ToList();
}
var allSubaddressCommands = importSubaddressHistCommands.Select(x =>
Tuple.Create <dynamic, int, int, string>(x, 2, 0, $"Subadres {x.SubaddressId}"))
.Concat(importSubaddressCommands.Select(x =>
Tuple.Create <dynamic, int, int, string>(x, 2, 1, $"Subadres {x.SubaddressId}")))
.Concat(importSubaddressStatusHistCommands.Select(x =>
Tuple.Create <dynamic, int, int, string>(x, 3, 0, $"Subadres {x.SubaddressId}")))
.Concat(importSubaddressStatusCommands.Select(x =>
Tuple.Create <dynamic, int, int, string>(x, 3, 1, $"Subadres {x.SubaddressId}")))
.Concat(importSubaddressPositionHistCommands.Select(x =>
Tuple.Create <dynamic, int, int, string>(x, 3, 2, $"Subadres {x.SubaddressId}")))
.Concat(importSubaddressPositionCommands.Select(x =>
Tuple.Create <dynamic, int, int, string>(x, 3, 3, $"Subadres {x.SubaddressId}")))
.Concat(importHouseNumberSubaddressCommandsHist.Select(x =>
Tuple.Create <dynamic, int, int, string>(x, 0, 0, $"Subadres {x.SubaddressId}")))
.Concat(importHouseNumberSubaddressCommands.Select(x =>
Tuple.Create <dynamic, int, int, string>(x, 0, 1, $"Subadres {x.SubaddressId}")))
.Concat(importSubaddressMailCantonCommandsHist.Select(x =>
Tuple.Create <dynamic, int, int, string>(x, 1, 0, $"Subadres {x.SubaddressId}")))
.Concat(importSubaddressMailCantonCommands.Select(x =>
Tuple.Create <dynamic, int, int, string>(x, 1, 1, $"Subadres {x.SubaddressId}")))
.ToList();
var addressCommands = allSubaddressCommands
.Where(x => x.Item1.Timestamp > from.ToCrabInstant() && x.Item1.Timestamp <= until.ToCrabInstant());
if (importMode == ImportMode.Update) //if an update changes the subaddress' house number, make sure the commands for that house number are also sent
{
var houseNumbersForUpdate = importSubaddressCommands
.Concat(importSubaddressHistCommands)
.Where(x => x.Timestamp > from.ToCrabInstant() && x.Timestamp <= until.ToCrabInstant())
.Select(x => x.HouseNumberId).ToList();
if (houseNumbersForUpdate.Any())
{
var houseNumbersBeforeUpdate = importSubaddressCommands
.Concat(importSubaddressHistCommands)
.Where(x => x.Timestamp <= from.ToCrabInstant())
.Select(x => x.HouseNumberId).ToList();
var newHouseNumbers = houseNumbersForUpdate.Except(houseNumbersBeforeUpdate);
foreach (var newHouseNumber in newHouseNumbers)
{
addressCommands = addressCommands.Concat(allSubaddressCommands.Except(addressCommands).Where(x =>
//(x.Item1 is ImportSubaddressFromCrab importSubaddressFromCrab && importSubaddressFromCrab.HouseNumberId == newHouseNumber) ||
(x.Item1 is ImportSubaddressMailCantonFromCrab importSubaddressMailCantonFromCrab && importSubaddressMailCantonFromCrab.HouseNumberId == newHouseNumber) ||
(x.Item1 is ImportHouseNumberSubaddressFromCrab importHouseNumberSubaddressFromCrab && importHouseNumberSubaddressFromCrab.HouseNumberId == newHouseNumber)));
}
}
}
addressCommands = addressCommands.OrderBy(x => x.Item1.Timestamp)
.ThenBy(x => x.Item2)
.ThenBy(x => x.Item3);
var commands = new List <dynamic>();
ImportHouseNumberSubaddressFromCrab initialImportHouseNumberSubaddressFromCrab = null;
if (importMode == ImportMode.Init)
{
initialImportHouseNumberSubaddressFromCrab = importHouseNumberSubaddressCommands
.Concat(importHouseNumberSubaddressCommandsHist)
.OrderBy(x => (Instant)x.Timestamp)
.First(x => x.HouseNumberId == addressCommands.First <ImportSubaddressFromCrab>().HouseNumberId);
commands.Add(initialImportHouseNumberSubaddressFromCrab);
}
foreach (var adresCommand in addressCommands)
{
if (importMode == ImportMode.Update || !adresCommand.Item1.Equals(initialImportHouseNumberSubaddressFromCrab))
{
commands.Add(adresCommand.Item1);
}
}
return(commands);
}
/// <summary>
/// Returns true if OrgApacheSlingDistributionSerializationImplVltVaultDistributionProperties instances are equal
/// </summary>
/// <param name="other">Instance of OrgApacheSlingDistributionSerializationImplVltVaultDistributionProperties to be compared</param>
/// <returns>Boolean</returns>
public bool Equals(OrgApacheSlingDistributionSerializationImplVltVaultDistributionProperties other)
{
if (other is null)
{
return(false);
}
if (ReferenceEquals(this, other))
{
return(true);
}
return
((
Name == other.Name ||
Name != null &&
Name.Equals(other.Name)
) &&
(
Type == other.Type ||
Type != null &&
Type.Equals(other.Type)
) &&
(
ImportMode == other.ImportMode ||
ImportMode != null &&
ImportMode.Equals(other.ImportMode)
) &&
(
AclHandling == other.AclHandling ||
AclHandling != null &&
AclHandling.Equals(other.AclHandling)
) &&
(
PackageRoots == other.PackageRoots ||
PackageRoots != null &&
PackageRoots.Equals(other.PackageRoots)
) &&
(
PackageFilters == other.PackageFilters ||
PackageFilters != null &&
PackageFilters.Equals(other.PackageFilters)
) &&
(
PropertyFilters == other.PropertyFilters ||
PropertyFilters != null &&
PropertyFilters.Equals(other.PropertyFilters)
) &&
(
TempFsFolder == other.TempFsFolder ||
TempFsFolder != null &&
TempFsFolder.Equals(other.TempFsFolder)
) &&
(
UseBinaryReferences == other.UseBinaryReferences ||
UseBinaryReferences != null &&
UseBinaryReferences.Equals(other.UseBinaryReferences)
) &&
(
AutoSaveThreshold == other.AutoSaveThreshold ||
AutoSaveThreshold != null &&
AutoSaveThreshold.Equals(other.AutoSaveThreshold)
) &&
(
CleanupDelay == other.CleanupDelay ||
CleanupDelay != null &&
CleanupDelay.Equals(other.CleanupDelay)
) &&
(
FileThreshold == other.FileThreshold ||
FileThreshold != null &&
FileThreshold.Equals(other.FileThreshold)
) &&
(
MEGA_BYTES == other.MEGA_BYTES ||
MEGA_BYTES != null &&
MEGA_BYTES.Equals(other.MEGA_BYTES)
) &&
(
UseOffHeapMemory == other.UseOffHeapMemory ||
UseOffHeapMemory != null &&
UseOffHeapMemory.Equals(other.UseOffHeapMemory)
) &&
(
DigestAlgorithm == other.DigestAlgorithm ||
DigestAlgorithm != null &&
DigestAlgorithm.Equals(other.DigestAlgorithm)
) &&
(
MonitoringQueueSize == other.MonitoringQueueSize ||
MonitoringQueueSize != null &&
MonitoringQueueSize.Equals(other.MonitoringQueueSize)
) &&
(
PathsMapping == other.PathsMapping ||
PathsMapping != null &&
PathsMapping.Equals(other.PathsMapping)
) &&
(
StrictImport == other.StrictImport ||
StrictImport != null &&
StrictImport.Equals(other.StrictImport)
));
}
public ImporterBase( ImportSettings settings, ImportMode mode )
{
if( settings == null )
throw new ArgumentNullException( "settings" );
_Connection = new SqlConnection( ConfigurationManager.ConnectionStrings[ settings.ConnectionStringName ].ConnectionString );
_Connection.Open();
_Activity = new ImportActivity(
mode,
_Connection,
settings.BatchParams,
settings.TargetTable,
settings.CsvDelimiterChar,
settings.NumberFormatInfo,
settings.CsvMetadata );
_Activity.ValidateRecord += OnValidateRecord;
_Activity.Complete += ( s, e ) => _CurrentReport.Counters = e.Counters;
_Activity.DbError += ( s, e ) => _CurrentReport.AddError( e.ErrorInfo );
}
/// <summary>
/// Initialiezs a new instance of the DictionaryWrapper class
/// </summary>
/// <param name="wrapped">the wrapped dictionary</param>
public ExcelDataDictionaryWrapper(IDictionary <string, ExcelDataRecord> wrapped, ImportMode mode)
{
if (mode == ImportMode.TextPlusActualTypes)
{
throw new ArgumentException("Unsupported for DictionaryWrapper", nameof(mode));
}
this.wrapped = wrapped;
}
public StandardImporter(ImportSettings settings, ImportMode mode)
: base(settings, mode)
{
}
public static bool StatusMustBeSet(OptionSetValue sourceStatuscode, OptionSetValue statuscodeInCrm, ImportMode setStateMode)
{
if (sourceStatuscode != null && Constants.UpdateModes.Contains(setStateMode))
{
bool statuscodeIsEqualToCurrentStatuscode = statuscodeInCrm != null && sourceStatuscode.Value == statuscodeInCrm.Value;
if (!statuscodeIsEqualToCurrentStatuscode || (setStateMode != ImportMode.UpdateChangedValuesOnly && setStateMode != ImportMode.AllChangedValuesOnly))
{
return(true);
}
}
return(false);
}
public static Promise <RunResult> ImportAsync(string gameDataPath, CommandInput input, ImportMode mode)
{
return(ImportAsync(gameDataPath, new string[0], input, mode));
}
public void SetBusinessKeyAndImportTypeForRecord(int record, string businessKey, ImportMode importMode)
{
this.databaseInterface.ExecuteNonQuery(
"Update tblRecordLog set CombinedBusinessKey = '" + SafeString(businessKey) + "', " +
"ImportMode=" + (int)importMode + " " +
"Where pkRecordLogId = " + record);
}
public void PushImportMode(ImportMode mode)
{
this.importModes.AddFirst(mode);
}
public static ImportReport ImportData(string format, ImportMode mode, Stream stream, string filename)
{
if (string.IsNullOrEmpty(format))
throw new ArgumentException("csv data format is not specified", "format");
if (stream == null)
throw new ArgumentNullException("stream");
if (string.IsNullOrEmpty(filename))
throw new ArgumentException("csv data filename is not specified", "filename");
var settings = GetSettings(format);
ImporterBase importer = null;
switch (format)
{
case _prices:
if( mode == ImportMode.BulkInsert ||
mode == ImportMode.BulkInsertWithSkipped )
{
importer = new PricesImporter( settings, mode );
}
break;
case _priceFactors:
if (mode == ImportMode.BulkInsert ||
mode == ImportMode.BulkInsertWithSkipped)
{
importer = new PriceFactorsImporter(settings, mode);
}
break;
case _crosses:
case _crossesBrands:
case _crossesGroups:
case _crossesLinks:
if( mode == ImportMode.BulkInsert ||
mode == ImportMode.BulkInsertWithSkipped ||
mode == ImportMode.BulkDelete)
{
importer = new StandardImporter(settings, mode);
}
break;
}
if (importer == null)
{
throw new InvalidOperationException(
string.Format("{0} {1} importer not supported", format, mode));
}
try
{
return importer.ImportData(stream, filename);
}
catch (Exception ex)
{
return new ImportReport() { LoadResult = -1, Counters = new LoadCounters() { Aborted = -1 } };
//TODO: Вернуть объект ImportReport с флагом, чтобы не удалять файл с данными и файл отмашки.
}
finally
{
importer.Dispose();
}
}
private List<ImportResult> ProcessFolder(DirectoryInfo directoryInfo, ImportMode importMode, DownloadClientItem downloadClientItem)
{
var cleanedUpName = GetCleanedUpFolderName(directoryInfo.Name);
var series = _parsingService.GetSeries(cleanedUpName);
if (series == null)
{
_logger.Debug("Unknown Series {0}", cleanedUpName);
return new List<ImportResult>
{
UnknownSeriesResult("Unknown Series")
};
}
return ProcessFolder(directoryInfo, importMode, series, downloadClientItem);
}
public override void Execute()
{
try
{
Dictionary <string, SyncEntity> completedImports = ReadCompletedImports();
var allFiles = ReadFiles(FilesFilter);
Program.Console($"Found {allFiles.Length} files to import");
foreach (var f in allFiles.OrderBy(f => f.Name))
{
if (completedImports.ContainsKey(f.Name))
{
Program.Console($"Skipping {f.Name}, already imported on {completedImports[f.Name].Imported.ToString("u")}");
continue;
}
var fileNameSplit = f.Name.Split('.');
if (fileNameSplit.Length != 4)
{
throw new InvalidOperationException($"File {f.Name} do not have 4 components: [Order].[Collection].[Operation].json");
}
string collectionName = fileNameSplit[1];
ImportMode importMode = Enum.Parse <ImportMode>(fileNameSplit[2], true);
Program.Console($"Importing {f.Name} to collection {collectionName}, mode {importMode}");
SyncEntity importResult = new SyncEntity();
importResult.FileName = f.Name;
try
{
switch (importMode)
{
case ImportMode.Drop:
dropCollection(collectionName);
break;
case ImportMode.Delete:
deleteFromCollection(collectionName, f);
break;
case ImportMode.Insert:
case ImportMode.Upsert:
case ImportMode.Merge:
var resultCode = Program.Exec(IMPORT_COMMAND, $"{ConnectionString.ToCommandLine()}{AuthenticationDatabaseToCommandLine()} --collection {collectionName} --type json --mode {importMode.ToString().ToLower()} --stopOnError --file {f.Name}");
if (resultCode != 0)
{
throw new InvalidOperationException($"mongoimport result code {resultCode}, interrupting");
}
break;
case ImportMode.Eval:
var evalResultCode = Program.Exec(MONGO_COMMAND, $"{Connection} {f.Name}");
if (evalResultCode != 0)
{
throw new InvalidOperationException($"mongo result code {evalResultCode}, interrupting");
}
break;
case ImportMode.CreateIndex:
var text = File.ReadAllText(f.FullName);
Program.Console("Index params:");
Program.Console(text);
var command = string.Format(CREATE_INDEX, collectionName, text);
var fileName = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString() + ".js");
File.WriteAllText(fileName, command);
try
{
var createIndexResultCode = Program.Exec(MONGO_COMMAND, $"{Connection} {fileName}");
switch (createIndexResultCode)
{
// no error
case 0:
break;
case 11000:
throw new InvalidOperationException($"CreateIndex failed with error 'duplicate key error', interrupting");
default:
// all error codes with explanation
// https://github.com/mongodb/mongo/blob/master/src/mongo/base/error_codes.err
throw new InvalidOperationException($"CreateIndex result code {createIndexResultCode}, interrupting");
}
}
finally
{
File.Delete(fileName);
}
break;
default: throw new InvalidOperationException($"Import mode {importMode} not implemented yet");
}
importResult.Success = true;
}
finally
{
SyncCollection.InsertOne(importResult);
}
}
Program.Console($"Import completed successfully");
}
catch (Exception ex)
{
Program.Console($"Error during import: {ex.Message}");
Environment.Exit(1);
}
}
public void Import(string file, ImportMode mode)
{
string foundFile = file;
if(!File.Exists(foundFile))
{
foreach (string path in this.importPaths)
{
foundFile = Path.Combine(path, file);
if (File.Exists(foundFile))
break;
}
if (!File.Exists(foundFile))
throw new CompileException(string.Format("Unable to find import \"{0}\" in import paths", file));
}
string fullPath = Path.GetFullPath(foundFile);
if (importedFiles.Contains(fullPath))
return;
string fileDir = Path.GetDirectoryName(fullPath);
this.AddImportPath(fileDir);
PushImportMode(mode);
this.FileStack.Push(fullPath);
if (mode == ImportMode.Library)
this.importedLibraries.Add(file);
try
{
Nodes.ICompileNode root = LanguageUtilities.ParseFile(fullPath);
this.Compile(root);
}
catch(Exception e)
{
throw new CompileException("Encountered exception while including " + fullPath, e);
}
this.FileStack.Pop();
PopImportMode();
this.RemoveImportPath(fileDir);
}
public static Hash128 GetSubSceneArtifactHash(Hash128 sceneGUID, Hash128 buildConfigurationGUID, ImportMode importMode)
{
var guid = SceneWithBuildConfigurationGUIDs.EnsureExistsFor(sceneGUID, buildConfigurationGUID, out var mustRequestRefresh);
if (mustRequestRefresh)
{
UnityEditor.AssetDatabase.Refresh();
}
if (!s_HashToString.TryGetValue(guid, out var guidString))
{
guidString = s_HashToString[guid] = guid.ToString();
}
return(AssetDatabaseCompatibility.GetArtifactHash(guidString, SubSceneImporterType, importMode));
}
private List <ImportResult> ProcessFolder(IDirectoryInfo directoryInfo, ImportMode importMode, Artist artist, DownloadClientItem downloadClientItem)
{
if (_artistService.ArtistPathExists(directoryInfo.FullName))
{
_logger.Warn("Unable to process folder that is mapped to an existing artist");
return(new List <ImportResult>());
}
var cleanedUpName = GetCleanedUpFolderName(directoryInfo.Name);
var folderInfo = Parser.Parser.ParseAlbumTitle(directoryInfo.Name);
var trackInfo = new ParsedTrackInfo {
};
if (folderInfo != null)
{
_logger.Debug("{0} folder quality: {1}", cleanedUpName, folderInfo.Quality);
trackInfo = new ParsedTrackInfo
{
AlbumTitle = folderInfo.AlbumTitle,
ArtistTitle = folderInfo.ArtistName,
Quality = folderInfo.Quality,
ReleaseGroup = folderInfo.ReleaseGroup,
ReleaseHash = folderInfo.ReleaseHash,
};
}
else
{
trackInfo = null;
}
var audioFiles = _diskScanService.FilterFiles(directoryInfo.FullName, _diskScanService.GetAudioFiles(directoryInfo.FullName));
if (downloadClientItem == null)
{
foreach (var audioFile in audioFiles)
{
if (_diskProvider.IsFileLocked(audioFile.FullName))
{
return(new List <ImportResult>
{
FileIsLockedResult(audioFile.FullName)
});
}
}
}
var decisions = _importDecisionMaker.GetImportDecisions(audioFiles, artist, trackInfo);
var importResults = _importApprovedTracks.Import(decisions, true, downloadClientItem, importMode);
if (importMode == ImportMode.Auto)
{
importMode = (downloadClientItem == null || downloadClientItem.CanMoveFiles) ? ImportMode.Move : ImportMode.Copy;
}
if (importMode == ImportMode.Move &&
importResults.Any(i => i.Result == ImportResultType.Imported) &&
ShouldDeleteFolder(directoryInfo, artist))
{
_logger.Debug("Deleting folder after importing valid files");
_diskProvider.DeleteFolder(directoryInfo.FullName, true);
}
return(importResults);
}
public List<ImportResult> Import(List<ImportDecision> decisions, bool newDownload, DownloadClientItem downloadClientItem = null, ImportMode importMode = ImportMode.Auto)
{
var qualifiedImports = decisions.Where(c => c.Approved)
.GroupBy(c => c.LocalEpisode.Series.Id, (i, s) => s
.OrderByDescending(c => c.LocalEpisode.Quality, new QualityModelComparer(s.First().LocalEpisode.Series.Profile))
.ThenByDescending(c => c.LocalEpisode.Size))
.SelectMany(c => c)
.ToList();
var importResults = new List<ImportResult>();
foreach (var importDecision in qualifiedImports.OrderBy(e => e.LocalEpisode.Episodes.Select(episode => episode.EpisodeNumber).MinOrDefault())
.ThenByDescending(e => e.LocalEpisode.Size))
{
var localEpisode = importDecision.LocalEpisode;
var oldFiles = new List<EpisodeFile>();
try
{
//check if already imported
if (importResults.SelectMany(r => r.ImportDecision.LocalEpisode.Episodes)
.Select(e => e.Id)
.Intersect(localEpisode.Episodes.Select(e => e.Id))
.Any())
{
importResults.Add(new ImportResult(importDecision, "Episode has already been imported"));
continue;
}
var episodeFile = new EpisodeFile();
episodeFile.DateAdded = DateTime.UtcNow;
episodeFile.SeriesId = localEpisode.Series.Id;
episodeFile.Path = localEpisode.Path.CleanFilePath();
episodeFile.Size = _diskProvider.GetFileSize(localEpisode.Path);
episodeFile.Quality = localEpisode.Quality;
episodeFile.MediaInfo = localEpisode.MediaInfo;
episodeFile.SeasonNumber = localEpisode.SeasonNumber;
episodeFile.Episodes = localEpisode.Episodes;
episodeFile.ReleaseGroup = localEpisode.ParsedEpisodeInfo.ReleaseGroup;
bool copyOnly;
switch (importMode)
{
default:
case ImportMode.Auto:
copyOnly = downloadClientItem != null && downloadClientItem.IsReadOnly;
break;
case ImportMode.Move:
copyOnly = false;
break;
case ImportMode.Copy:
copyOnly = true;
break;
}
if (newDownload)
{
episodeFile.SceneName = GetSceneName(downloadClientItem, localEpisode);
var moveResult = _episodeFileUpgrader.UpgradeEpisodeFile(episodeFile, localEpisode, copyOnly);
oldFiles = moveResult.OldFiles;
}
else
{
episodeFile.RelativePath = localEpisode.Series.Path.GetRelativePath(episodeFile.Path);
}
_mediaFileService.Add(episodeFile);
importResults.Add(new ImportResult(importDecision));
if (newDownload)
{
_extraService.ImportExtraFiles(localEpisode, episodeFile, copyOnly);
}
if (downloadClientItem != null)
{
_eventAggregator.PublishEvent(new EpisodeImportedEvent(localEpisode, episodeFile, newDownload, downloadClientItem.DownloadClient, downloadClientItem.DownloadId, downloadClientItem.IsReadOnly));
}
else
{
_eventAggregator.PublishEvent(new EpisodeImportedEvent(localEpisode, episodeFile, newDownload));
}
if (newDownload)
{
_eventAggregator.PublishEvent(new EpisodeDownloadedEvent(localEpisode, episodeFile, oldFiles));
}
}
catch (Exception e)
{
_logger.Warn(e, "Couldn't import episode " + localEpisode);
importResults.Add(new ImportResult(importDecision, "Failed to import episode"));
}
}
//Adding all the rejected decisions
importResults.AddRange(decisions.Where(c => !c.Approved)
.Select(d => new ImportResult(d, d.Rejections.Select(r => r.Reason).ToArray())));
return importResults;
}
public ImportProductPricesAreNotDuplicatesValidator(ImportMode importMode)
{
_importMode = importMode;
AttachValidators();
}
/// <summary>
/// Gets the API URL to post to
/// </summary>
/// <param name="importMode">The impost Mode option</param>
/// <returns>The API URL as string</returns>
public static string GetAPIPostURL(ImportMode importMode)
{
return(string.Format("{0}?Login={1}&EncryptedPassword={2}&Import={3}", VOLUSION_BASE_API, VOLUSION_USER, VOLUSION_PASSWORD, GetEnumDescription(importMode)));
}
public List <ImportResult> Import(List <ImportDecision <LocalBook> > decisions, bool replaceExisting, DownloadClientItem downloadClientItem = null, ImportMode importMode = ImportMode.Auto)
{
var importResults = new List <ImportResult>();
var allImportedTrackFiles = new List <BookFile>();
var allOldTrackFiles = new List <BookFile>();
var addedAuthors = new List <Author>();
var bookDecisions = decisions.Where(e => e.Item.Book != null && e.Approved)
.GroupBy(e => e.Item.Book.ForeignBookId).ToList();
var iDecision = 1;
foreach (var bookDecision in bookDecisions)
{
_logger.ProgressInfo($"Importing book {iDecision++}/{bookDecisions.Count} {bookDecision.First().Item.Book}");
var decisionList = bookDecision.ToList();
var author = EnsureAuthorAdded(decisionList, addedAuthors);
if (author == null)
{
// failed to add the author, carry on with next book
continue;
}
var book = EnsureBookAdded(decisionList);
if (book == null)
{
// failed to add the book, carry on with next one
continue;
}
var edition = EnsureEditionAdded(decisionList);
if (edition == null)
{
// failed to add the edition, carry on with next one
continue;
}
// if (replaceExisting)
// {
// RemoveExistingTrackFiles(author, book);
// }
// set the correct release to be monitored before importing the new files
var newRelease = bookDecision.First().Item.Edition;
_logger.Debug("Updating release to {0}", newRelease);
book.Editions = _editionService.SetMonitored(newRelease);
// Publish book edited event.
// Deliberatly don't put in the old book since we don't want to trigger an AuthorScan.
_eventAggregator.PublishEvent(new BookEditedEvent(book, book));
}
var qualifiedImports = decisions.Where(c => c.Approved)
.GroupBy(c => c.Item.Author.Id, (i, s) => s
.OrderByDescending(c => c.Item.Quality, new QualityModelComparer(s.First().Item.Author.QualityProfile))
.ThenByDescending(c => c.Item.Size))
.SelectMany(c => c)
.ToList();
_logger.ProgressInfo($"Importing {qualifiedImports.Count} files");
_logger.Debug($"Importing {qualifiedImports.Count} files. replaceExisting: {replaceExisting}");
var filesToAdd = new List <BookFile>(qualifiedImports.Count);
var trackImportedEvents = new List <TrackImportedEvent>(qualifiedImports.Count);
foreach (var importDecision in qualifiedImports.OrderByDescending(e => e.Item.Size))
{
var localTrack = importDecision.Item;
var oldFiles = new List <BookFile>();
try
{
//check if already imported
if (importResults.Select(r => r.ImportDecision.Item.Book.Id).Contains(localTrack.Book.Id))
{
importResults.Add(new ImportResult(importDecision, "Book has already been imported"));
continue;
}
localTrack.Book.Author = localTrack.Author;
var bookFile = new BookFile
{
Path = localTrack.Path.CleanFilePath(),
CalibreId = localTrack.CalibreId,
Size = localTrack.Size,
Modified = localTrack.Modified,
DateAdded = DateTime.UtcNow,
ReleaseGroup = localTrack.ReleaseGroup,
Quality = localTrack.Quality,
MediaInfo = localTrack.FileTrackInfo.MediaInfo,
EditionId = localTrack.Edition.Id,
Author = localTrack.Author,
Edition = localTrack.Edition
};
bool copyOnly;
switch (importMode)
{
default:
case ImportMode.Auto:
copyOnly = downloadClientItem != null && !downloadClientItem.CanMoveFiles;
break;
case ImportMode.Move:
copyOnly = false;
break;
case ImportMode.Copy:
copyOnly = true;
break;
}
if (!localTrack.ExistingFile)
{
bookFile.SceneName = GetSceneReleaseName(downloadClientItem);
var moveResult = _bookFileUpgrader.UpgradeBookFile(bookFile, localTrack, copyOnly);
oldFiles = moveResult.OldFiles;
}
else
{
// Delete existing files from the DB mapped to this path
var previousFile = _mediaFileService.GetFileWithPath(bookFile.Path);
if (previousFile != null)
{
_mediaFileService.Delete(previousFile, DeleteMediaFileReason.ManualOverride);
}
_audioTagService.WriteTags(bookFile, false);
_eBookTagService.WriteTags(bookFile, false);
}
filesToAdd.Add(bookFile);
importResults.Add(new ImportResult(importDecision));
if (!localTrack.ExistingFile)
{
_extraService.ImportTrack(localTrack, bookFile, copyOnly);
}
allImportedTrackFiles.Add(bookFile);
allOldTrackFiles.AddRange(oldFiles);
// create all the import events here, but we can't publish until the trackfiles have been
// inserted and ids created
trackImportedEvents.Add(new TrackImportedEvent(localTrack, bookFile, oldFiles, !localTrack.ExistingFile, downloadClientItem));
}
catch (RootFolderNotFoundException e)
{
_logger.Warn(e, "Couldn't import book " + localTrack);
_eventAggregator.PublishEvent(new TrackImportFailedEvent(e, localTrack, !localTrack.ExistingFile, downloadClientItem));
importResults.Add(new ImportResult(importDecision, "Failed to import book, Root folder missing."));
}
catch (DestinationAlreadyExistsException e)
{
_logger.Warn(e, "Couldn't import book " + localTrack);
importResults.Add(new ImportResult(importDecision, "Failed to import book, Destination already exists."));
}
catch (UnauthorizedAccessException e)
{
_logger.Warn(e, "Couldn't import book " + localTrack);
_eventAggregator.PublishEvent(new TrackImportFailedEvent(e, localTrack, !localTrack.ExistingFile, downloadClientItem));
importResults.Add(new ImportResult(importDecision, "Failed to import book, Permissions error"));
}
catch (Exception)
{
throw;
}
}
var watch = new System.Diagnostics.Stopwatch();
watch.Start();
_mediaFileService.AddMany(filesToAdd);
_logger.Debug($"Inserted new trackfiles in {watch.ElapsedMilliseconds}ms");
// now that trackfiles have been inserted and ids generated, publish the import events
foreach (var trackImportedEvent in trackImportedEvents)
{
_eventAggregator.PublishEvent(trackImportedEvent);
}
var bookImports = importResults.Where(e => e.ImportDecision.Item.Book != null)
.GroupBy(e => e.ImportDecision.Item.Book.Id).ToList();
foreach (var bookImport in bookImports)
{
var book = bookImport.First().ImportDecision.Item.Book;
var author = bookImport.First().ImportDecision.Item.Author;
if (bookImport.Where(e => e.Errors.Count == 0).ToList().Count > 0 && author != null && book != null)
{
_eventAggregator.PublishEvent(new BookImportedEvent(
author,
book,
allImportedTrackFiles.Where(s => s.EditionId == book.Id).ToList(),
allOldTrackFiles.Where(s => s.EditionId == book.Id).ToList(),
replaceExisting,
downloadClientItem));
}
}
//Adding all the rejected decisions
importResults.AddRange(decisions.Where(c => !c.Approved)
.Select(d => new ImportResult(d, d.Rejections.Select(r => r.Reason).ToArray())));
// Refresh any authors we added
if (addedAuthors.Any())
{
_commandQueueManager.Push(new BulkRefreshAuthorCommand(addedAuthors.Select(x => x.Id).ToList(), true));
}
return(importResults);
}
public List <ImportResult> Import(List <ImportDecision <LocalTrack> > decisions, bool replaceExisting, DownloadClientItem downloadClientItem = null, ImportMode importMode = ImportMode.Auto)
{
var qualifiedImports = decisions.Where(c => c.Approved)
.GroupBy(c => c.Item.Artist.Id, (i, s) => s
.OrderByDescending(c => c.Item.Quality, new QualityModelComparer(s.First().Item.Artist.QualityProfile))
.ThenByDescending(c => c.Item.Size))
.SelectMany(c => c)
.ToList();
_logger.Debug($"Importing {qualifiedImports.Count} files. replaceExisting: {replaceExisting}");
var importResults = new List <ImportResult>();
var allImportedTrackFiles = new List <TrackFile>();
var allOldTrackFiles = new List <TrackFile>();
var albumDecisions = decisions.Where(e => e.Item.Album != null && e.Approved)
.GroupBy(e => e.Item.Album.Id).ToList();
foreach (var albumDecision in albumDecisions)
{
var album = albumDecision.First().Item.Album;
var newRelease = albumDecision.First().Item.Release;
if (replaceExisting)
{
var artist = albumDecision.First().Item.Artist;
var rootFolder = _diskProvider.GetParentFolder(artist.Path);
var previousFiles = _mediaFileService.GetFilesByAlbum(album.Id);
_logger.Debug($"Deleting {previousFiles.Count} existing files for {album}");
foreach (var previousFile in previousFiles)
{
var subfolder = rootFolder.GetRelativePath(_diskProvider.GetParentFolder(previousFile.Path));
if (_diskProvider.FileExists(previousFile.Path))
{
_logger.Debug("Removing existing track file: {0}", previousFile);
_recycleBinProvider.DeleteFile(previousFile.Path, subfolder);
}
_mediaFileService.Delete(previousFile, DeleteMediaFileReason.Upgrade);
}
}
// set the correct release to be monitored before importing the new files
_logger.Debug("Updating release to {0} [{1} tracks]", newRelease, newRelease.TrackCount);
album.AlbumReleases = _releaseService.SetMonitored(newRelease);
// Publish album edited event.
// Deliberatly don't put in the old album since we don't want to trigger an ArtistScan.
_eventAggregator.PublishEvent(new AlbumEditedEvent(album, album));
}
var filesToAdd = new List <TrackFile>(qualifiedImports.Count);
var albumReleasesDict = new Dictionary <int, List <AlbumRelease> >(albumDecisions.Count);
var trackImportedEvents = new List <TrackImportedEvent>(qualifiedImports.Count);
foreach (var importDecision in qualifiedImports.OrderBy(e => e.Item.Tracks.Select(track => track.AbsoluteTrackNumber).MinOrDefault())
.ThenByDescending(e => e.Item.Size))
{
var localTrack = importDecision.Item;
var oldFiles = new List <TrackFile>();
try
{
//check if already imported
if (importResults.SelectMany(r => r.ImportDecision.Item.Tracks)
.Select(e => e.Id)
.Intersect(localTrack.Tracks.Select(e => e.Id))
.Any())
{
importResults.Add(new ImportResult(importDecision, "Track has already been imported"));
continue;
}
// cache album releases and set artist to speed up firing the TrackImported events
// (otherwise they'll be retrieved from the DB for each track)
if (!albumReleasesDict.ContainsKey(localTrack.Album.Id))
{
albumReleasesDict.Add(localTrack.Album.Id, localTrack.Album.AlbumReleases.Value);
}
if (!localTrack.Album.AlbumReleases.IsLoaded)
{
localTrack.Album.AlbumReleases = albumReleasesDict[localTrack.Album.Id];
}
localTrack.Album.Artist = localTrack.Artist;
foreach (var track in localTrack.Tracks)
{
track.Artist = localTrack.Artist;
track.AlbumRelease = localTrack.Release;
track.Album = localTrack.Album;
}
var trackFile = new TrackFile {
Path = localTrack.Path.CleanFilePath(),
Size = localTrack.Size,
Modified = localTrack.Modified,
DateAdded = DateTime.UtcNow,
ReleaseGroup = localTrack.ReleaseGroup,
Quality = localTrack.Quality,
MediaInfo = localTrack.FileTrackInfo.MediaInfo,
AlbumId = localTrack.Album.Id,
Artist = localTrack.Artist,
Album = localTrack.Album,
Tracks = localTrack.Tracks
};
bool copyOnly;
switch (importMode)
{
default:
case ImportMode.Auto:
copyOnly = downloadClientItem != null && !downloadClientItem.CanMoveFiles;
break;
case ImportMode.Move:
copyOnly = false;
break;
case ImportMode.Copy:
copyOnly = true;
break;
}
if (!localTrack.ExistingFile)
{
trackFile.SceneName = GetSceneReleaseName(downloadClientItem, localTrack);
var moveResult = _trackFileUpgrader.UpgradeTrackFile(trackFile, localTrack, copyOnly);
oldFiles = moveResult.OldFiles;
}
else
{
// Delete existing files from the DB mapped to this path
var previousFile = _mediaFileService.GetFileWithPath(trackFile.Path);
if (previousFile != null)
{
_mediaFileService.Delete(previousFile, DeleteMediaFileReason.ManualOverride);
}
_audioTagService.WriteTags(trackFile, false);
}
filesToAdd.Add(trackFile);
importResults.Add(new ImportResult(importDecision));
if (!localTrack.ExistingFile)
{
_extraService.ImportTrack(localTrack, trackFile, copyOnly);
}
allImportedTrackFiles.Add(trackFile);
allOldTrackFiles.AddRange(oldFiles);
// create all the import events here, but we can't publish until the trackfiles have been
// inserted and ids created
trackImportedEvents.Add(new TrackImportedEvent(localTrack, trackFile, oldFiles, !localTrack.ExistingFile, downloadClientItem));
}
catch (RootFolderNotFoundException e)
{
_logger.Warn(e, "Couldn't import track " + localTrack);
_eventAggregator.PublishEvent(new TrackImportFailedEvent(e, localTrack, !localTrack.ExistingFile, downloadClientItem));
importResults.Add(new ImportResult(importDecision, "Failed to import track, Root folder missing."));
}
catch (DestinationAlreadyExistsException e)
{
_logger.Warn(e, "Couldn't import track " + localTrack);
importResults.Add(new ImportResult(importDecision, "Failed to import track, Destination already exists."));
}
catch (UnauthorizedAccessException e)
{
_logger.Warn(e, "Couldn't import track " + localTrack);
_eventAggregator.PublishEvent(new TrackImportFailedEvent(e, localTrack, !localTrack.ExistingFile, downloadClientItem));
importResults.Add(new ImportResult(importDecision, "Failed to import track, Permissions error"));
}
catch (Exception e)
{
_logger.Warn(e, "Couldn't import track " + localTrack);
importResults.Add(new ImportResult(importDecision, "Failed to import track"));
}
}
var watch = new System.Diagnostics.Stopwatch();
watch.Start();
_mediaFileService.AddMany(filesToAdd);
_logger.Debug($"Inserted new trackfiles in {watch.ElapsedMilliseconds}ms");
filesToAdd.ForEach(f => f.Tracks.Value.ForEach(t => t.TrackFileId = f.Id));
_trackService.SetFileIds(filesToAdd.SelectMany(x => x.Tracks.Value).ToList());
_logger.Debug($"TrackFileIds updated, total {watch.ElapsedMilliseconds}ms");
// now that trackfiles have been inserted and ids generated, publish the import events
foreach (var trackImportedEvent in trackImportedEvents)
{
_eventAggregator.PublishEvent(trackImportedEvent);
}
var albumImports = importResults.Where(e => e.ImportDecision.Item.Album != null)
.GroupBy(e => e.ImportDecision.Item.Album.Id).ToList();
foreach (var albumImport in albumImports)
{
var release = albumImport.First().ImportDecision.Item.Release;
var album = albumImport.First().ImportDecision.Item.Album;
var artist = albumImport.First().ImportDecision.Item.Artist;
if (albumImport.Where(e => e.Errors.Count == 0).ToList().Count > 0 && artist != null && album != null)
{
_eventAggregator.PublishEvent(new AlbumImportedEvent(
artist,
album,
release,
allImportedTrackFiles.Where(s => s.AlbumId == album.Id).ToList(),
allOldTrackFiles.Where(s => s.AlbumId == album.Id).ToList(), replaceExisting,
downloadClientItem));
}
}
//Adding all the rejected decisions
importResults.AddRange(decisions.Where(c => !c.Approved)
.Select(d => new ImportResult(d, d.Rejections.Select(r => r.Reason).ToArray())));
return(importResults);
}
static IEnumerable <ExportImportDevice> GenerateExportImportDeviceListForTwinBulkOperations(IEnumerable <Twin> twins, ImportMode importMode)
{
if (twins == null)
{
throw new ArgumentNullException(nameof(twins));
}
if (!twins.Any())
{
throw new ArgumentException(nameof(twins));
}
var exportImportDeviceList = new List <ExportImportDevice>(twins.Count());
foreach (Twin twin in twins)
{
ValidateTwinId(twin);
switch (importMode)
{
case ImportMode.UpdateTwin:
// No preconditions
break;
case ImportMode.UpdateTwinIfMatchETag:
if (string.IsNullOrWhiteSpace(twin.ETag))
{
throw new ArgumentException(ApiResources.ETagNotSetWhileUpdatingTwin);
}
break;
default:
throw new ArgumentException(IotHubApiResources.GetString(ApiResources.InvalidImportMode, importMode));
}
var exportImportDevice = new ExportImportDevice();
exportImportDevice.Id = twin.DeviceId;
exportImportDevice.ImportMode = importMode;
exportImportDevice.TwinETag = importMode == ImportMode.UpdateTwinIfMatchETag ? twin.ETag : null;
exportImportDevice.Tags = twin.Tags;
exportImportDevice.Properties = new ExportImportDevice.PropertyContainer();
exportImportDevice.Properties.DesiredProperties = twin.Properties?.Desired;
exportImportDeviceList.Add(exportImportDevice);
}
return(exportImportDeviceList);
}
internal static Hash128 CalculateTargetHash(GUID guid, BuildTarget target, ImportMode importMode)
{
return(LiveLinkBuildImporter.GetHash(guid.ToString(), target, importMode));
}
private static Hash128 ProduceArtifact(GUID guid, Type importerType, ImportMode mode)
{
return(ProduceArtifact(guid, importerType, mode, out _));
}
private List <ImportResult> ProcessFolder(IDirectoryInfo directoryInfo, ImportMode importMode, Author author, DownloadClientItem downloadClientItem)
{
if (_authorService.AuthorPathExists(directoryInfo.FullName))
{
_logger.Warn("Unable to process folder that is mapped to an existing author");
return(new List <ImportResult>());
}
var cleanedUpName = GetCleanedUpFolderName(directoryInfo.Name);
var folderInfo = Parser.Parser.ParseBookTitle(directoryInfo.Name);
var trackInfo = new ParsedTrackInfo {
};
if (folderInfo != null)
{
_logger.Debug("{0} folder quality: {1}", cleanedUpName, folderInfo.Quality);
trackInfo = new ParsedTrackInfo
{
AlbumTitle = folderInfo.BookTitle,
ArtistTitle = folderInfo.AuthorName,
Quality = folderInfo.Quality,
ReleaseGroup = folderInfo.ReleaseGroup,
ReleaseHash = folderInfo.ReleaseHash,
};
}
else
{
trackInfo = null;
}
var audioFiles = _diskScanService.FilterFiles(directoryInfo.FullName, _diskScanService.GetBookFiles(directoryInfo.FullName));
if (downloadClientItem == null)
{
foreach (var audioFile in audioFiles)
{
if (_diskProvider.IsFileLocked(audioFile.FullName))
{
return(new List <ImportResult>
{
FileIsLockedResult(audioFile.FullName)
});
}
}
}
var idOverrides = new IdentificationOverrides
{
Author = author
};
var idInfo = new ImportDecisionMakerInfo
{
DownloadClientItem = downloadClientItem,
ParsedTrackInfo = trackInfo
};
var idConfig = new ImportDecisionMakerConfig
{
Filter = FilterFilesType.None,
NewDownload = true,
SingleRelease = false,
IncludeExisting = false,
AddNewAuthors = false
};
var decisions = _importDecisionMaker.GetImportDecisions(audioFiles, idOverrides, idInfo, idConfig);
var importResults = _importApprovedTracks.Import(decisions, true, downloadClientItem, importMode);
if (importMode == ImportMode.Auto)
{
importMode = (downloadClientItem == null || downloadClientItem.CanMoveFiles) ? ImportMode.Move : ImportMode.Copy;
}
if (importMode == ImportMode.Move &&
importResults.Any(i => i.Result == ImportResultType.Imported) &&
ShouldDeleteFolder(directoryInfo, author))
{
_logger.Debug("Deleting folder after importing valid files");
_diskProvider.DeleteFolder(directoryInfo.FullName, true);
}
return(importResults);
}
public static Promise <RunResult> ImportAsync(string gameDataPath, string[] entities, CommandInput input, ImportMode mode)
{
if (gameDataPath == null)
{
throw new ArgumentNullException("gameDataPath");
}
if (entities == null)
{
throw new ArgumentNullException("entities");
}
if (input == null)
{
throw new ArgumentNullException("input");
}
if (Enum.IsDefined(typeof(ImportMode), mode) == false)
{
throw new ArgumentException("Unknown import mode.", "mode");
}
if (File.Exists(gameDataPath) == false)
{
throw new IOException(string.Format("GameData file '{0}' doesn't exists.", gameDataPath));
}
var runTask = RunInternal
(
RunOptions.FlattenArguments(
"DATA", "IMPORT", gameDataPath,
"--entities", entities,
"--mode", mode,
"--input", input.Source,
"--inputFormat", input.Format,
"--inputFormattingOptions", input.FormattingOptions
)
);
input.StickWith(runTask);
return(runTask);
}
public void Import(Id entryCollectionId, Id pagesCollectionId, Id mediaCollectionId, ImportMode mode, BlogMLBlog blog)
{
progress = new Progress();
LogProgress("Import started, mode={0}", mode);
LogProgress("Blog found with title of '{0}'", blog.Title);
try
{
AppService appSvc = AppServiceRepository.GetService();
if (mode == ImportMode.New)
{
var ws = appSvc.GetWorkspace();
//clean out old collections
CleanOutCollection(ws.GetCollection("blog").Id, appSvc);
CleanOutCollection(ws.GetCollection("pages").Id, appSvc);
CleanOutCollection(ws.GetCollection("media").Id, appSvc);
ws.Title = new AtomTitle() { Text = entryCollectionId.Owner };
//change old id's to new id's
ChangeCollectionId(appSvc, ws.GetCollection("blog").Id, entryCollectionId);
ChangeCollectionId(appSvc, ws.GetCollection("pages").Id, pagesCollectionId);
ChangeCollectionId(appSvc, ws.GetCollection("media").Id, mediaCollectionId);
}
else if (mode == ImportMode.Overwrite)
{
CleanOutCollection(entryCollectionId, appSvc);
CleanOutCollection(pagesCollectionId, appSvc);
CleanOutCollection(mediaCollectionId, appSvc);
}
TurnOffTrackbacks(entryCollectionId, appSvc);
TurnOffTrackbacks(pagesCollectionId, appSvc);
TurnOffTrackbacks(mediaCollectionId, appSvc);
var coll = appSvc.GetCollection(entryCollectionId);
if (mode != ImportMode.Merge)
{
coll.Title = new AtomTitle() { Text = blog.Title };
//this is workspace subtitle, not collection
appSvc.GetWorkspace().Subtitle = new AtomSubtitle() { Text = blog.SubTitle };
}
var users = ImportUsers(blog, appSvc);
if (users.FirstOrDefault() != null && mode == ImportMode.New)
{
//user is likely not authenticated when new, so auth them
System.Threading.Thread.CurrentPrincipal = new GenericPrincipal(users[0], null);
}
ImportCategories(blog, coll);
AtomPubService.UpdateService(appSvc);
ImportPosts(entryCollectionId, pagesCollectionId, mediaCollectionId, mode, blog);
//make sure there is an About and Blogroll pages
if (mode == ImportMode.New && pagesCollectionId != null)
{
var entries = AtomPubService.GetEntries(new EntryCriteria()
{
EntryId = pagesCollectionId.AddPath("About"),
Approved = true
}, 0, 1);
if (entries.Count() == 0)
{
AtomPubService.CreateEntry(pagesCollectionId, new AtomEntry()
{
Title = new AtomTitle() { Text = "About Me" },
Content = new AtomContent() { Text = "This is a temporary placeholder until I can update this entry." },
}, "About");
}
entries = AtomPubService.GetEntries(new EntryCriteria()
{
EntryId = pagesCollectionId.AddPath("Blogroll"),
Approved = true
}, 0, 1);
if (entries.Count() == 0)
{
AtomPubService.CreateEntry(pagesCollectionId, new AtomEntry()
{
Title = new AtomTitle() { Text = "Blog Roll" },
Content = new AtomContent() { Type = "html", Text = "<ul><li><a href='http://atomsite.net'>AtomSite.net</a></li></ul>" },
}, "Blogroll");
}
}
ResetTrackbacks(entryCollectionId, appSvc);
ResetTrackbacks(pagesCollectionId, appSvc);
ResetTrackbacks(mediaCollectionId, appSvc);
LogProgress("Finished!", 100);
}
catch (Exception ex)
{
LogService.Error(ex);
LogProgress(System.Web.HttpUtility.HtmlEncode(ex.Message), 100);
}
}
public List <ImportResult> Import(List <ImportDecision> decisions, bool newDownload, DownloadClientItem downloadClientItem = null, ImportMode importMode = ImportMode.Auto)
{
_logger.Debug("Decisions: {0}", decisions.Count);
var qualifiedImports = decisions.Where(c => c.Approved)
.GroupBy(c => c.LocalMovie.Movie.Id, (i, s) => s
.OrderByDescending(c => c.LocalMovie.Quality, new QualityModelComparer(s.First().LocalMovie.Movie.Profile))
.ThenByDescending(c => c.LocalMovie.Size))
.SelectMany(c => c)
.ToList();
var importResults = new List <ImportResult>();
foreach (var importDecision in qualifiedImports.OrderBy(e => e.LocalMovie.Size)
.ThenByDescending(e => e.LocalMovie.Size))
{
var localMovie = importDecision.LocalMovie;
var oldFiles = new List <MovieFile>();
try
{
//check if already imported
if (importResults.Select(r => r.ImportDecision.LocalMovie.Movie)
.Select(m => m.Id).Contains(localMovie.Movie.Id))
{
importResults.Add(new ImportResult(importDecision, "Movie has already been imported"));
continue;
}
var movieFile = new MovieFile();
movieFile.DateAdded = DateTime.UtcNow;
movieFile.MovieId = localMovie.Movie.Id;
movieFile.Path = localMovie.Path.CleanFilePath();
movieFile.Size = _diskProvider.GetFileSize(localMovie.Path);
movieFile.Quality = localMovie.Quality;
movieFile.MediaInfo = localMovie.MediaInfo;
movieFile.Movie = localMovie.Movie;
movieFile.ReleaseGroup = localMovie.ParsedMovieInfo.ReleaseGroup;
movieFile.Edition = localMovie.ParsedMovieInfo.Edition;
bool copyOnly;
switch (importMode)
{
default:
case ImportMode.Auto:
copyOnly = downloadClientItem != null && downloadClientItem.IsReadOnly;
break;
case ImportMode.Move:
copyOnly = false;
break;
case ImportMode.Copy:
copyOnly = true;
break;
}
if (newDownload)
{
movieFile.SceneName = GetSceneName(downloadClientItem, localMovie);
var moveResult = _episodeFileUpgrader.UpgradeMovieFile(movieFile, localMovie, copyOnly); //TODO: Check if this works
oldFiles = moveResult.OldFiles;
}
else
{
movieFile.RelativePath = localMovie.Movie.Path.GetRelativePath(movieFile.Path);
}
_mediaFileService.Add(movieFile);
importResults.Add(new ImportResult(importDecision));
if (newDownload)
{
//_extraService.ImportExtraFiles(localMovie, episodeFile, copyOnly); TODO update for movie
}
if (downloadClientItem != null)
{
_eventAggregator.PublishEvent(new MovieImportedEvent(localMovie, movieFile, newDownload, downloadClientItem.DownloadClient, downloadClientItem.DownloadId, downloadClientItem.IsReadOnly));
}
else
{
_eventAggregator.PublishEvent(new MovieImportedEvent(localMovie, movieFile, newDownload));
}
if (newDownload)
{
_eventAggregator.PublishEvent(new MovieDownloadedEvent(localMovie, movieFile, oldFiles));
}
}
catch (Exception e)
{
_logger.Warn(e, "Couldn't import movie " + localMovie);
importResults.Add(new ImportResult(importDecision, "Failed to import movie"));
}
}
//Adding all the rejected decisions
importResults.AddRange(decisions.Where(c => !c.Approved)
.Select(d => new ImportResult(d, d.Rejections.Select(r => r.Reason).ToArray())));
return(importResults);
}
public List <ImportResult> Import(List <ImportDecision> decisions, bool newDownload, DownloadClientItem downloadClientItem = null, ImportMode importMode = ImportMode.Auto)
{
_logger.Debug("Decisions: {0}", decisions.Count);
//I added a null op for the rare case that the quality is null. TODO: find out why that would even happen in the first place.
var qualifiedImports = decisions.Where(c => c.Approved)
.GroupBy(c => c.LocalMovie.Movie.Id, (i, s) => s
.OrderByDescending(c => c.LocalMovie.Quality ?? new QualityModel {
Quality = Quality.Unknown
}, new QualityModelComparer(s.First().LocalMovie.Movie.Profile))
.ThenByDescending(c => c.LocalMovie.Size))
.SelectMany(c => c)
.ToList();
var importResults = new List <ImportResult>();
foreach (var importDecision in qualifiedImports.OrderByDescending(e => e.LocalMovie.Size))
{
var localMovie = importDecision.LocalMovie;
var oldFiles = new List <MovieFile>();
try
{
//check if already imported
if (importResults.Select(r => r.ImportDecision.LocalMovie.Movie)
.Select(m => m.Id).Contains(localMovie.Movie.Id))
{
importResults.Add(new ImportResult(importDecision, "Movie has already been imported"));
continue;
}
var movieFile = new MovieFile();
movieFile.DateAdded = DateTime.UtcNow;
movieFile.MovieId = localMovie.Movie.Id;
movieFile.Path = localMovie.Path.CleanFilePath();
movieFile.Size = _diskProvider.GetFileSize(localMovie.Path);
movieFile.Quality = localMovie.Quality;
movieFile.Languages = localMovie.Languages;
movieFile.MediaInfo = localMovie.MediaInfo;
movieFile.Movie = localMovie.Movie;
movieFile.ReleaseGroup = localMovie.ReleaseGroup;
movieFile.Edition = localMovie.Edition;
if (downloadClientItem?.DownloadId.IsNotNullOrWhiteSpace() == true)
{
var grabHistory = _historyService.FindByDownloadId(downloadClientItem.DownloadId)
.OrderByDescending(h => h.Date)
.FirstOrDefault(h => h.EventType == MovieHistoryEventType.Grabbed);
if (Enum.TryParse(grabHistory?.Data.GetValueOrDefault("indexerFlags"), true, out IndexerFlags flags))
{
movieFile.IndexerFlags = flags;
}
}
bool copyOnly;
switch (importMode)
{
default:
case ImportMode.Auto:
copyOnly = downloadClientItem != null && !downloadClientItem.CanMoveFiles;
break;
case ImportMode.Move:
copyOnly = false;
break;
case ImportMode.Copy:
copyOnly = true;
break;
}
if (newDownload)
{
movieFile.OriginalFilePath = GetOriginalFilePath(downloadClientItem, localMovie);
movieFile.SceneName = GetSceneName(downloadClientItem, localMovie);
var moveResult = _movieFileUpgrader.UpgradeMovieFile(movieFile, localMovie, copyOnly); //TODO: Check if this works
oldFiles = moveResult.OldFiles;
}
else
{
movieFile.RelativePath = localMovie.Movie.Path.GetRelativePath(movieFile.Path);
}
movieFile = _mediaFileService.Add(movieFile);
importResults.Add(new ImportResult(importDecision));
if (newDownload)
{
_extraService.ImportMovie(localMovie, movieFile, copyOnly);
}
if (downloadClientItem != null)
{
_eventAggregator.PublishEvent(new MovieImportedEvent(localMovie, movieFile, newDownload, downloadClientItem, downloadClientItem.DownloadId));
}
else
{
_eventAggregator.PublishEvent(new MovieImportedEvent(localMovie, movieFile, newDownload));
}
if (newDownload)
{
_eventAggregator.PublishEvent(new MovieDownloadedEvent(localMovie, movieFile, oldFiles, downloadClientItem));
}
}
catch (RootFolderNotFoundException e)
{
_logger.Warn(e, "Couldn't import movie " + localMovie);
_eventAggregator.PublishEvent(new MovieImportFailedEvent(e, localMovie, newDownload, downloadClientItem));
importResults.Add(new ImportResult(importDecision, "Failed to import movie, Root folder missing."));
}
catch (DestinationAlreadyExistsException e)
{
_logger.Warn(e, "Couldn't import movie " + localMovie);
importResults.Add(new ImportResult(importDecision, "Failed to import movie, Destination already exists."));
}
catch (Exception e)
{
_logger.Warn(e, "Couldn't import movie " + localMovie);
importResults.Add(new ImportResult(importDecision, "Failed to import movie"));
}
}
//Adding all the rejected decisions
importResults.AddRange(decisions.Where(c => !c.Approved)
.Select(d => new ImportResult(d, d.Rejections.Select(r => r.Reason).ToArray())));
return(importResults);
}
internal static void CalculateTargetDependencies(Entities.Hash128 artifactHash, BuildTarget target, out ResolvedAssetID[] dependencies, ImportMode syncMode)
{
List <Entities.Hash128> assets = new List <Entities.Hash128>(LiveLinkBuildImporter.GetDependenciesInternal(artifactHash));
List <ResolvedAssetID> resolvedDependencies = new List <ResolvedAssetID>();
HashSet <Entities.Hash128> visited = new HashSet <Entities.Hash128>();
for (int i = 0; i < assets.Count; i++)
{
if (!visited.Add(assets[i]))
{
continue;
}
var resolvedAsset = new ResolvedAssetID
{
GUID = assets[i],
TargetHash = CalculateTargetHash(assets[i], target, syncMode),
};
resolvedDependencies.Add(resolvedAsset);
if (resolvedAsset.TargetHash.IsValid)
{
assets.AddRange(LiveLinkBuildImporter.GetDependenciesInternal(resolvedAsset.TargetHash));
}
}
dependencies = resolvedDependencies.ToArray();
}
private List<ImportResult> ProcessFile(FileInfo fileInfo, ImportMode importMode, DownloadClientItem downloadClientItem)
{
var series = _parsingService.GetSeries(Path.GetFileNameWithoutExtension(fileInfo.Name));
if (series == null)
{
_logger.Debug("Unknown Series for file: {0}", fileInfo.Name);
return new List<ImportResult>
{
UnknownSeriesResult(string.Format("Unknown Series for file: {0}", fileInfo.Name), fileInfo.FullName)
};
}
return ProcessFile(fileInfo, importMode, series, downloadClientItem);
}
public List <ImportResult> Import(List <ImportDecision> decisions, bool newDownload, DownloadClientItem downloadClientItem = null, ImportMode importMode = ImportMode.Auto)
{
var qualifiedImports = decisions.Where(c => c.Approved)
.GroupBy(c => c.LocalEpisode.Series.Id, (i, s) => s
.OrderByDescending(c => c.LocalEpisode.Quality, new QualityModelComparer(s.First().LocalEpisode.Series.Profile))
.ThenByDescending(c => c.LocalEpisode.Size))
.SelectMany(c => c)
.ToList();
var importResults = new List <ImportResult>();
foreach (var importDecision in qualifiedImports.OrderBy(e => e.LocalEpisode.Episodes.Select(episode => episode.EpisodeNumber).MinOrDefault())
.ThenByDescending(e => e.LocalEpisode.Size))
{
var localEpisode = importDecision.LocalEpisode;
var oldFiles = new List <EpisodeFile>();
try
{
//check if already imported
if (importResults.SelectMany(r => r.ImportDecision.LocalEpisode.Episodes)
.Select(e => e.Id)
.Intersect(localEpisode.Episodes.Select(e => e.Id))
.Any())
{
importResults.Add(new ImportResult(importDecision, "Episode has already been imported"));
continue;
}
var episodeFile = new EpisodeFile();
episodeFile.DateAdded = DateTime.UtcNow;
episodeFile.SeriesId = localEpisode.Series.Id;
episodeFile.Path = localEpisode.Path.CleanFilePath();
episodeFile.Size = _diskProvider.GetFileSize(localEpisode.Path);
episodeFile.Quality = localEpisode.Quality;
episodeFile.MediaInfo = localEpisode.MediaInfo;
episodeFile.SeasonNumber = localEpisode.SeasonNumber;
episodeFile.Episodes = localEpisode.Episodes;
episodeFile.ReleaseGroup = localEpisode.ReleaseGroup;
bool copyOnly;
switch (importMode)
{
default:
case ImportMode.Auto:
copyOnly = downloadClientItem != null && !downloadClientItem.CanMoveFiles;
break;
case ImportMode.Move:
copyOnly = false;
break;
case ImportMode.Copy:
copyOnly = true;
break;
}
if (newDownload)
{
episodeFile.OriginalFilePath = GetOriginalFilePath(downloadClientItem, localEpisode);
episodeFile.SceneName = GetSceneName(downloadClientItem, localEpisode);
var moveResult = _episodeFileUpgrader.UpgradeEpisodeFile(episodeFile, localEpisode, copyOnly);
oldFiles = moveResult.OldFiles;
}
else
{
episodeFile.RelativePath = localEpisode.Series.Path.GetRelativePath(episodeFile.Path);
}
_mediaFileService.Add(episodeFile);
importResults.Add(new ImportResult(importDecision));
if (newDownload)
{
_extraService.ImportEpisode(localEpisode, episodeFile, copyOnly);
}
_eventAggregator.PublishEvent(new EpisodeImportedEvent(localEpisode, episodeFile, oldFiles, newDownload, downloadClientItem));
}
catch (RootFolderNotFoundException e)
{
_logger.Warn(e, "Couldn't import episode " + localEpisode);
_eventAggregator.PublishEvent(new EpisodeImportFailedEvent(e, localEpisode, newDownload, downloadClientItem));
importResults.Add(new ImportResult(importDecision, "Failed to import episode, Root folder missing."));
}
catch (DestinationAlreadyExistsException e)
{
_logger.Warn(e, "Couldn't import episode " + localEpisode);
importResults.Add(new ImportResult(importDecision, "Failed to import episode, Destination already exists."));
}
catch (Exception e)
{
_logger.Warn(e, "Couldn't import episode " + localEpisode);
importResults.Add(new ImportResult(importDecision, "Failed to import episode"));
}
}
//Adding all the rejected decisions
importResults.AddRange(decisions.Where(c => !c.Approved)
.Select(d => new ImportResult(d, d.Rejections.Select(r => r.Reason).ToArray())));
return(importResults);
}
private List<ImportResult> ProcessFile(FileInfo fileInfo, ImportMode importMode, Series series, DownloadClientItem downloadClientItem)
{
if (Path.GetFileNameWithoutExtension(fileInfo.Name).StartsWith("._"))
{
_logger.Debug("[{0}] starts with '._', skipping", fileInfo.FullName);
return new List<ImportResult>
{
new ImportResult(new ImportDecision(new LocalEpisode { Path = fileInfo.FullName }, new Rejection("Invalid video file, filename starts with '._'")), "Invalid video file, filename starts with '._'")
};
}
if (downloadClientItem == null)
{
if (_diskProvider.IsFileLocked(fileInfo.FullName))
{
return new List<ImportResult>
{
FileIsLockedResult(fileInfo.FullName)
};
}
}
var decisions = _importDecisionMaker.GetImportDecisions(new List<string>() { fileInfo.FullName }, series, null, true);
return _importApprovedEpisodes.Import(decisions, true, downloadClientItem, importMode);
}
public PricesImporter(ImportSettings settings, ImportMode mode)
: base(settings, mode)
{
_priceCleaner = new PricesCleaner(settings);
}
/// <summary>
/// Создает новую секцию по названию таблицы, режиму импорта, используя введенный список столбцов
/// </summary>
/// <param name="tableName">Название таблицы</param>
/// <param name="mode">Режим</param>
/// <param name="list">Список столбцов</param>
public ImportSection(string tableName, ImportMode mode, List <ImportColumn> list)
{
Section = new DataTable(tableName);
// Вносим в секцию столько столбцов, сколько задействовано при импорте
for (int j = 0; j <= list.Count; j++)
{
Section.Columns.Add(new DataColumn(j.ToString()));
}
var currentColumn = 0;
var i = 1;
// Если создаем и изменяем, увеличиваем количество строк в два раза
var countOfRows = mode != ImportMode.CreateChange ? list[0].Values.Length : list[0].Values.Length * 2;
// Пилим и вносим самую первую строку
DataRow row = Section.NewRow();
row[0] = tableName + ":FORMAT";
Section.Rows.Add(row);
// Вносим в секцию все строки, заполняем самый первый столбец согласно режиму
for (var j = 0; j < countOfRows; j++)
{
switch (mode)
{
case ImportMode.Create:
// Создаем новую строку по образцу, заполняем первый элемент, пихаем в секцию. И так будет с каждым...
row = Section.NewRow();
row[0] = tableName + ":CREATE";
Section.Rows.Add(row);
break;
case ImportMode.Change:
row = Section.NewRow();
row[0] = tableName + ":CHANGE";
Section.Rows.Add(row);
break;
case ImportMode.CreateChange:
var newRow1 = Section.NewRow();
newRow1[0] = tableName + ":CREATE";
var newRow2 = Section.NewRow();
newRow2[0] = tableName + ":CHANGE";
Section.Rows.Add(newRow1);
Section.Rows.Add(newRow2);
j++;
break;
case ImportMode.Delete:
row = Section.NewRow();
row[0] = tableName + ":DELETE";
Section.Rows.Add(row);
break;
}
}
currentColumn++;
foreach (ImportColumn col in list)
{
// Пилим все остальное
i = 0;
// Заполняем первую стркоу названиями столбцов
Section.Rows[i++][currentColumn] = col.Name;
// Если значение по умолчанию заполнено, заполняем ими столбец
if (!(col.DefaultValue is null))
{
for (i = 1; i <= countOfRows; i++)
{
Section.Rows[i][currentColumn] = col.DefaultValue;
}
}
