// function should only be called inside a write lock
bool checkVariables(BaseMetadata metadata)
{
if (metadata == null)
{
return(false);
}
if (metadata.Tags.Count > 0)
{
HasTags = true;
}
else
{
HasTags = false;
}
if (metadata.Longitude != null && metadata.Latitude != null)
{
HasGeoTag = true;
}
else
{
HasGeoTag = false;
}
return(true);
}
/// <inheritdoc />
public IEnumerator <KeyValuePair <string, object> > GetRawEnumerator()
{
HashSet <string> keys = new HashSet <string>(StringComparer.OrdinalIgnoreCase);
if (Metadata != null)
{
foreach (KeyValuePair <string, object> item in Metadata.GetRawEnumerable())
{
if (keys.Add(item.Key))
{
yield return(item);
}
}
}
foreach (KeyValuePair <string, object> item in PropertyMetadata <TDocument> .For((TDocument)this).GetRawEnumerable())
{
if (keys.Add(item.Key))
{
yield return(item);
}
}
if (BaseMetadata != null)
{
foreach (KeyValuePair <string, object> item in BaseMetadata.GetRawEnumerable())
{
if (keys.Add(item.Key))
{
yield return(item);
}
}
}
}
/// <inheritdoc />
public bool TryGetRaw(string key, out object value)
{
value = default;
return((!IDocument.Properties.Contains(key) && Metadata?.TryGetRaw(key, out value) == true) ||
PropertyMetadata <TDocument> .For((TDocument)this).TryGetRaw(key, out value) ||
(BaseMetadata?.TryGetRaw(key, out value) ?? false));
}
public void Remove(Guid code)
{
using (var transaction = Connection.BeginTransaction())
{
try
{
var field = metadataFieldRepository.Get(code);
if (field.IsNull())
{
throw new ArgumentException("Nenhum campo encontrado com o código informado");
}
var metadata = BaseMetadata.CreateInstance(field, null);
var exists = metadataService.HasValueByJsonId(metadata);
if (exists)
{
throw new ArgumentException("Não é possível remover esse campo, pois já existem valores vinculados ao mesmo");
}
metadataFieldRepository.Delete(field);
}
catch
{
transaction.Rollback();
throw;
}
}
}
public void SaveValue(FieldType type, Guid referenceCode, IEnumerable <DTO.MetadataField> metadatas)
{
using (var transaction = Connection.BeginTransaction())
{
try
{
var _metadatas = metadatas.Select(field =>
{
var _field = new MetadataField(field);
var metadata = BaseMetadata.CreateInstance(_field, null, referenceCode);
metadata.Value = field.Value.AsString();
return(metadata);
}).ToList();
metadataService.SaveValue(_metadatas);
}
catch
{
transaction.Rollback();
throw;
}
}
}
/// <inheritdoc />
public bool TryGetRaw(string key, out object value)
{
value = default;
return((Metadata?.TryGetRaw(key, out value) ?? false) ||
PropertyMetadata <TDocument> .For((TDocument)this).TryGetRaw(key, out value) ||
(BaseMetadata?.TryGetRaw(key, out value) ?? false));
}
public virtual void writeMetadata(BaseMetadata media, CancellableOperationProgressBase progress = null)
{
Progress = progress;
XMPLib.MetaData.ErrorCallbackDelegate errorCallbackDelegate = new XMPLib.MetaData.ErrorCallbackDelegate(errorCallback);
// bug in xmplib, crashes on write when video is mpg and a progresscallback is active
XMPLib.MetaData.ProgressCallbackDelegate progressCallbackDelegate = media.MimeType.Equals("video/mpeg") ? null : new XMPLib.MetaData.ProgressCallbackDelegate(progressCallback);
XMPLib.MetaData xmpMetaDataWriter = new XMPLib.MetaData(errorCallbackDelegate, progressCallbackDelegate);
try
{
if (media.SupportsXMPMetadata)
{
xmpMetaDataWriter.open(media.Location, Consts.OpenOptions.XMPFiles_OpenForUpdate);
write(xmpMetaDataWriter, media);
}
else
{
throw new Exception("Format does not support XMP metadata");
}
}
finally
{
xmpMetaDataWriter.Dispose();
xmpMetaDataWriter = null;
}
}
public Constant Verify(int opPositin, BaseMetadata[] args)
{
if (args == null)
{
throw new ArgumentException("运算操作符参数为空");
}
if (args.Length != 2)
{
//抛异常
throw new IllegalExpressionException("操作符\"" + THIS_OPERATOR.Token + "\"参数个数不匹配"
, THIS_OPERATOR.Token
, opPositin
);
}
BaseMetadata first = args[1];
BaseMetadata second = args[0];
if (first == null || second == null)
{
throw new NullReferenceException("操作符\"" + THIS_OPERATOR.Token + "\"参数为空");
}
if (DataType.DATATYPE_DATE == first.GetDataType() &&
DataType.DATATYPE_DATE == second.GetDataType())
{
//日期类型比较
return(new Constant(DataType.DATATYPE_BOOLEAN, false));
}
else if (DataType.DATATYPE_STRING == first.GetDataType() &&
DataType.DATATYPE_STRING == second.GetDataType())
{
//字窜类型比较
return(new Constant(DataType.DATATYPE_BOOLEAN, false));
}
else if ((DataType.DATATYPE_DOUBLE == first.GetDataType() ||
DataType.DATATYPE_FLOAT == first.GetDataType() ||
DataType.DATATYPE_LONG == first.GetDataType() ||
DataType.DATATYPE_INT == first.GetDataType())
&&
(DataType.DATATYPE_DOUBLE == second.GetDataType() ||
DataType.DATATYPE_FLOAT == second.GetDataType() ||
DataType.DATATYPE_LONG == second.GetDataType() ||
DataType.DATATYPE_INT == second.GetDataType())
)
{
//数值类型比较
return(new Constant(DataType.DATATYPE_BOOLEAN, false));
}
else
{
//LT操作不支持其他类型，抛异常
throw new IllegalExpressionException("操作符\"" + THIS_OPERATOR.Token + "\"参数类型错误");
}
}
//执行函数校验
private ExpressionToken VerifyFunction(ExpressionToken funtionToken, Stack <ExpressionToken> verifyStack)
{
if (!(verifyStack.Count == 0))
{
bool doPop = true;
var args = new List <BaseMetadata>();
ExpressionToken parameter = null;
//弹出函数的参数，直到遇到"("时终止
while (doPop && !(verifyStack.Count == 0))
{
parameter = verifyStack.Pop();
if (ExpressionToken.ETokenType.ETOKEN_TYPE_CONSTANT == parameter.TokenType)
{
//常量
args.Add(parameter.Constant);
}
else if (ExpressionToken.ETokenType.ETOKEN_TYPE_VARIABLE == parameter.TokenType)
{
args.Add(parameter.Variable);
}
else if ("(".Equals(parameter.GetSplitor()))
{
doPop = false;
}
else
{
//没有找到应该存在的右括号
throw new IllegalExpressionException("表达式不合法，函数\"" + funtionToken.TokenText + "\"遇到非法参数" + parameter.ToString() + ";位置:" + parameter.StartPosition
, funtionToken.ToString()
, funtionToken.StartPosition);
}
}
if (doPop && (verifyStack.Count == 0))
{
//操作栈以空，没有找到函数的左括号（
throw new IllegalExpressionException("表达式不合法，函数\"" + funtionToken.TokenText + "\"缺少\"(\"；位置:" + (funtionToken.StartPosition + funtionToken.ToString().Length)
, funtionToken.ToString()
, funtionToken.StartPosition);
}
//校验函数
var arguments = new BaseMetadata[args.Count];
arguments = args.ToArray();
Constant result = FunctionExecution.Verify(funtionToken.TokenText, funtionToken.StartPosition, arguments);
return(ExpressionToken.CreateConstantToken(result));
}
else
{
//没有找到应该存在的右括号
throw new IllegalExpressionException("表达式不合法，函数\"" + funtionToken.TokenText + "\"不完整"
, funtionToken.ToString()
, funtionToken.StartPosition);
}
}
private static BaseMetadata readMetadataFromDatabase(string location, ReadOptions options, CancellationToken token, int timeoutSeconds)
{
BaseMetadata metadata = null;
using (MetadataDbCommands metadataCommands = new MetadataDbCommands())
{
metadata = metadataCommands.findMetadataByLocation(location);
if (metadata != null)
{
metadata.IsImported = true;
if (options.HasFlag(ReadOptions.LEAVE_STREAM_OPENED_AFTER_READ))
{
Stream data = FileUtils.waitForFileAccess(location, FileAccess.Read,
FILE_OPEN_ASYNC_TIMEOUT_MS, token);
metadata.Data = data;
}
// check if metadata stored in the database is outdated
FileInfo info = new FileInfo(location);
info.Refresh();
if (info.Exists == false)
{
metadata.MetadataReadError = new FileNotFoundException("File not found", location);
return(metadata);
}
if ((info.LastWriteTime - metadata.LastModifiedDate) > TimeSpan.FromSeconds(10))
{
// metadata is outdated so update in database
Logger.Log.Info("Updated: " + location + " - Database timestamp: " + metadata.LastModifiedDate.ToString() + " Disk timestamp: " + info.LastWriteTime.ToString());
int id = metadata.Id;
metadata = MetadataFileFactory.read(location, options, token, timeoutSeconds);
if (metadata != null)
{
metadata.IsImported = true;
metadata.Id = id;
write(metadata, WriteOptions.WRITE_TO_DATABASE, null);
}
}
if (info.Attributes.HasFlag(FileAttributes.ReadOnly))
{
metadata.IsReadOnly = true;
}
}
}
return(metadata);
}
public static MediaFileItem create(string location, BaseMetadata metadata = null)
{
rwLock.EnterWriteLock();
try
{
WeakReference <MediaFileItem> reference = null;
MediaFileItem item = null;
bool success = dictionary.TryGetValue(location, out reference);
if (success == true)
{
bool exists = reference.TryGetTarget(out item);
if (exists == false)
{
// item has been garbage collected, recreate
item = new MediaFileItem(location);
if (metadata != null)
{
item.Metadata = metadata;
item.checkVariables(metadata);
item.ItemState = MediaItemState.LOADED;
}
reference = new WeakReference <MediaFileItem>(item);
dictionary.Remove(location);
dictionary.Add(location, reference);
}
}
else
{
// item did not exist yet
item = new MediaFileItem(location);
if (metadata != null)
{
item.Metadata = metadata;
item.checkVariables(metadata);
item.ItemState = MediaItemState.LOADED;
}
reference = new WeakReference <MediaFileItem>(item);
dictionary.Add(location, reference);
}
return(item);
}
finally
{
rwLock.ExitWriteLock();
}
}
public Constant Verify(int opPositin, BaseMetadata[] args)
{
if (args == null)
{
throw new ArgumentException("运算操作符参数为空");
}
if (args.Length != 1)
{
//抛异常
throw new IllegalExpressionException("操作符\"" + THIS_OPERATOR.Token + "\"参数个数不匹配"
, THIS_OPERATOR.Token
, opPositin
);
}
BaseMetadata first = args[0];
if (first == null)
{
throw new NullReferenceException("操作符\"" + THIS_OPERATOR.Token + "\"参数为空");
}
if (DataType.DATATYPE_DOUBLE == first.GetDataType())
{
return(new Constant(DataType.DATATYPE_DOUBLE, 0.0D));
}
else if (DataType.DATATYPE_FLOAT == first.GetDataType())
{
return(new Constant(DataType.DATATYPE_FLOAT, 0F));
}
else if (DataType.DATATYPE_LONG == first.GetDataType())
{
return(new Constant(DataType.DATATYPE_LONG, 0L));
}
else if (DataType.DATATYPE_INT == first.GetDataType())
{
return(new Constant(DataType.DATATYPE_INT, 0));
}
else
{
//抛异常
throw new IllegalExpressionException("操作符\"" + THIS_OPERATOR.Token + "\"参数类型错误"
, THIS_OPERATOR.Token
, opPositin
);
}
}
public static void write(BaseMetadata metadata, WriteOptions options, CancellableOperationProgressBase progress = null)
{
if (options.HasFlag(WriteOptions.AUTO) || options.HasFlag(WriteOptions.WRITE_TO_DISK))
{
MetadataFileFactory.write(metadata, progress);
}
if (metadata.IsImported && (options.HasFlag(WriteOptions.AUTO) || options.HasFlag(WriteOptions.WRITE_TO_DATABASE)))
{
using (MetadataDbCommands metadataCommands = new MetadataDbCommands())
{
metadata = metadataCommands.update(metadata);
}
}
metadata.IsModified = false;
}
/// <summary>
/// 执行操作符校验
/// </summary>
/// <param name="opToken"></param>
/// <param name="verifyStack"></param>
/// <returns></returns>
private ExpressionToken VerifyOperator(ExpressionToken opToken, Stack <ExpressionToken> verifyStack)
{
//判定几元操作符
Operator op = opToken.Op;
int opType = op.OpType;
//取得相应的参数个数
var args = new BaseMetadata[opType];
ExpressionToken argToken = null;
for (int i = 0; i < opType; i++)
{
if (!(verifyStack.Count == 0))
{
argToken = verifyStack.Pop();
if (ExpressionToken.ETokenType.ETOKEN_TYPE_CONSTANT == argToken.TokenType)
{
args[i] = argToken.Constant;
}
else if (ExpressionToken.ETokenType.ETOKEN_TYPE_VARIABLE == argToken.TokenType)
{
args[i] = argToken.Variable;
}
else
{
//如果取到的Token不是常量，也不是变量，则抛出错误
throw new IllegalExpressionException("表达式不合法，操作符\"" + op.Token + "\"参数错误;位置：" + argToken.StartPosition
, opToken.ToString()
, opToken.StartPosition);
}
}
else
{
//栈已经弹空，没有取道操作符对应的操作数
throw new IllegalExpressionException("表达式不合法，操作符\"" + op.Token + "\"找不到相应的参数，或参数个数不足;"
, opToken.ToString()
, opToken.StartPosition);
}
}
//执行操作符校验，并返回校验
Constant result = op.Verify(opToken.StartPosition, args);
return(ExpressionToken.CreateConstantToken(result));
}
/// <summary>
/// Returns null when metadata does not exist
/// UnknownMetadata when metadata is not recognized
/// </summary>
/// <param name="location"></param>
/// <param name="options"></param>
/// <param name="token"></param>
/// <returns></returns>
public static BaseMetadata read(string location, ReadOptions options, CancellationToken token, int timeoutSeconds = 60)
{
limitConcurrentReadsSemaphore.Wait(token);
try
{
// initialize metadata with a dummy in case of exceptions
BaseMetadata metadata = null;
if (string.IsNullOrEmpty(location) || token.IsCancellationRequested == true)
{
return(metadata);
}
else if (FileUtils.isUrl(location))
{
metadata = readMetadataFromWeb(location, options, token, timeoutSeconds);
}
else
{
if (options.HasFlag(ReadOptions.AUTO) || options.HasFlag(ReadOptions.READ_FROM_DATABASE))
{
metadata = readMetadataFromDatabase(location, options, token, timeoutSeconds);
}
if ((metadata == null && options.HasFlag(ReadOptions.AUTO)) ||
options.HasFlag(ReadOptions.READ_FROM_DISK))
{
metadata = MetadataFileFactory.read(location, options, token, timeoutSeconds);
}
}
metadata.IsModified = false;
return(metadata);
}
catch (OperationCanceledException)
{
// convert operationcanceled to taskcanceled when the token aborts waiting for the semaphore
throw new TaskCanceledException();
}
finally
{
limitConcurrentReadsSemaphore.Release();
}
}
public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
{
BaseMetadata media = (BaseMetadata)value;
if (media == null || media.Thumbnail == null)
{
if (media is AudioMetadata)
{
return(audioIcon);
}
else
{
return(parameter);
}
}
else
{
return(media.Thumbnail.Image);
}
}
string parseNewFilename(string newFilename, string replaceFilename, bool isRegexEnabled, string oldFilename,
BaseMetadata media)
{
string outputFilename = null;
if (isRegexEnabled == false)
{
if (String.IsNullOrEmpty(newFilename) || String.IsNullOrWhiteSpace(newFilename))
{
outputFilename = oldFilename;
}
else
{
outputFilename = newFilename;
}
}
else
{
Regex regex = new Regex(newFilename, RegexOptions.Singleline);
replaceFilename = parseReplaceFilename(replaceFilename, media);
if (replaceFilename.Equals("#upper"))
{
outputFilename = regex.Replace(oldFilename, m => m.Value.ToUpperInvariant());
}
else if (replaceFilename.Equals("#lower"))
{
outputFilename = regex.Replace(oldFilename, m => m.Value.ToLowerInvariant());
}
else
{
outputFilename = regex.Replace(oldFilename, replaceFilename);
}
}
outputFilename = FileUtils.removeIllegalCharsFromFileName(outputFilename, "-");
return(outputFilename);
}
public ICollection <BaseMetadata> GetFieldAndFill(FieldType type, IEnumerable <BaseMetadata> metadatas)
{
var _metadatas = new List <BaseMetadata>();
var fields = metadataFieldRepository.GetByType(type);
fields.ForEach(field =>
{
var metadataDb = !metadatas.IsNull() ? metadatas.FirstOrDefault(m => m.Field.JsonId == field.JsonId) : null;
if (metadataDb.IsNull())
{
_metadatas.Add(BaseMetadata.CreateInstance(field, metadataDb));
}
else
{
_metadatas.Add(metadataDb);
}
});
return(_metadatas);
}
public Constant Verify(int opPositin, BaseMetadata[] args)
{
if (args == null)
{
throw new ArgumentException("运算操作符参数为空");
}
if (args.Length != 2)
{
//抛异常
throw new IllegalExpressionException("操作符\"" + THIS_OPERATOR.Token + "\"参数个数不匹配"
, THIS_OPERATOR.Token
, opPositin
);
}
BaseMetadata first = args[1];
BaseMetadata second = args[0];
if (first == null || second == null)
{
throw new NullReferenceException("操作符\"" + THIS_OPERATOR.Token + "\"参数为空");
}
if (DataType.DATATYPE_BOOLEAN == first.GetDataType() &&
DataType.DATATYPE_BOOLEAN == second.GetDataType())
{
return(new Constant(DataType.DATATYPE_BOOLEAN, false));
}
else
{
//抛异常
throw new IllegalExpressionException("操作符\"" + THIS_OPERATOR.Token + "\"参数类型错误"
, THIS_OPERATOR.Token
, opPositin
);
}
}
public static void write(BaseMetadata metadata, CancellableOperationProgressBase progress = null)
{
if (metadata is ImageMetadata)
{
ImageFileMetadataWriter imageMetadataWriter = new ImageFileMetadataWriter();
imageMetadataWriter.writeMetadata(metadata, progress);
}
else if (metadata is VideoMetadata)
{
VideoFileMetadataWriter videoMetadataWriter = new VideoFileMetadataWriter();
videoMetadataWriter.writeMetadata(metadata, progress);
}
else if (metadata is AudioMetadata)
{
AudioFileMetadataWriter audioMetadataWriter = new AudioFileMetadataWriter();
audioMetadataWriter.writeMetadata(metadata, progress);
}
else
{
MetadataFileWriter metadataFileWriter = new MetadataFileWriter();
metadataFileWriter.writeMetadata(metadata, progress);
}
}
/* (non-Javadoc)
* @see org.wltea.expression.op.IOperatorExecution#verify(int, org.wltea.expression.ExpressionToken[])
*/
public Constant Verify(int opPositin, BaseMetadata[] args)
{
if (args == null)
{
throw new ArgumentException("运算操作符参数为空");
}
if (args.Length != 2)
{
//抛异常
throw new IllegalExpressionException("操作符\"" + THIS_OPERATOR.Token + "\"参数个数不匹配"
, THIS_OPERATOR.Token
, opPositin
);
}
BaseMetadata first = args[1];
BaseMetadata second = args[0];
if (first == null || second == null)
{
throw new NullReferenceException("操作符\"" + THIS_OPERATOR.Token + "\"参数为空");
}
//APPEND接受任何类型的参数，总是返回Collection类型的常量
return(new Constant(DataType.DATATYPE_LIST, null));
}
private string parseReplaceFilename(string replaceFilename, BaseMetadata media)
{
Regex counterRegEx = new Regex("#counter([0-9]+)");
replaceFilename = counterRegEx.Replace(replaceFilename, m =>
{
if (!counter.HasValue)
{
int initialCount = int.Parse(m.Groups[1].Value);
counter = initialCount;
}
else
{
counter++;
}
return(counter.ToString());
});
Regex parentDirRegEx = new Regex(parentDirMarker);
replaceFilename = parentDirRegEx.Replace(replaceFilename, m =>
{
String directoryName = Path.GetDirectoryName(media.Location);
string parentDir = "";
int index = directoryName.LastIndexOf('\\');
if (index != -1 && index < directoryName.Length)
{
parentDir = directoryName.Substring(index + 1);
}
return(parentDir);
});
Regex widthRegEx = new Regex(widthMarker);
replaceFilename = widthRegEx.Replace(replaceFilename, m =>
{
String width = media is VideoMetadata ? (media as VideoMetadata).Width.ToString() : "";
width = media is ImageMetadata ? (media as ImageMetadata).Width.ToString() : "";
return(width);
});
Regex heightRegEx = new Regex(heightMarker);
replaceFilename = heightRegEx.Replace(replaceFilename, m =>
{
String height = media is VideoMetadata ? (media as VideoMetadata).Height.ToString() : "";
height = media is ImageMetadata ? (media as ImageMetadata).Height.ToString() : "";
return(height);
});
Regex bitrateRegEx = new Regex(bitrateMarker);
replaceFilename = bitrateRegEx.Replace(replaceFilename, m =>
{
String bitrateKB = "";
if (media is VideoMetadata)
{
VideoMetadata video = media as VideoMetadata;
long totalBitrate = 0;
if (video.VideoBitRate.HasValue)
{
totalBitrate += video.VideoBitRate.Value;
}
if (video.AudioBitRate.HasValue)
{
totalBitrate += video.AudioBitRate.Value;
}
if (totalBitrate > 0)
{
bitrateKB = (totalBitrate / (8 * 1024)).ToString();
}
}
else if (media is AudioMetadata)
{
AudioMetadata audio = media as AudioMetadata;
if (audio.BitRate.HasValue)
{
bitrateKB = (audio.BitRate.Value / (8 * 1024)).ToString();
}
}
return(bitrateKB);
});
Regex dateRegex = new Regex(dateMarker);
replaceFilename = bitrateRegEx.Replace(replaceFilename, m =>
{
String creationDate = "";
if (media.CreationDate.HasValue)
{
creationDate = media.CreationDate.Value.ToString("dd/M/yyyy");
}
return(creationDate);
});
return(replaceFilename);
}
public override void readMetadata_URLock(MetadataFactory.ReadOptions options, CancellationToken token)
{
if (ItemState == MediaItemState.RELOAD)
{
reloadFromDisk_URLock(token);
return;
}
EnterWriteLock();
ItemState = MediaItemState.LOADING;
ExitWriteLock(false);
MediaItemState itemState = MediaItemState.ERROR;
BaseMetadata metadata = null;
try
{
metadata = MetadataFactory.read(Location, options, token);
if (metadata == null || metadata is UnknownMetadata)
{
itemState = MediaItemState.ERROR;
}
else
{
if (metadata.MetadataReadError != null)
{
if (metadata.MetadataReadError is FileNotFoundException)
{
itemState = MediaItemState.FILE_NOT_FOUND;
}
else
{
itemState = MediaItemState.ERROR;
}
}
else
{
itemState = MediaItemState.LOADED;
}
}
}
catch (TimeoutException)
{
itemState = MediaItemState.TIMED_OUT;
}
catch (Exception e)
{
itemState = MediaItemState.ERROR;
Logger.Log.Info("Error loading Metadata:" + Location, e);
}
finally
{
EnterWriteLock();
Metadata = metadata;
ItemState = itemState;
if (Metadata != null)
{
IsReadOnly = Metadata.IsReadOnly;
checkVariables(Metadata);
}
ExitWriteLock(false);
}
}
// IMetadata
/// <inheritdoc />
public bool ContainsKey(string key) =>
(Metadata?.ContainsKey(key) ?? false) ||
PropertyMetadata <TDocument> .For((TDocument)this).ContainsKey(key) ||
(BaseMetadata?.ContainsKey(key) ?? false);
public bool HasValueByJsonId(BaseMetadata metadata)
{
return(metadataRepository.HasValueByJsonId(metadata));
}
public bool HasValueByJsonId(BaseMetadata metadata)
{
return(Collection.Any(c => c.Field.JsonId == metadata.Field.JsonId));
}
private void getExifProperties(ObservableCollection <Tuple <string, string> > p, BaseMetadata media)
{
p.Add(new Tuple <string, string>("Size", MediaViewer.Model.Utils.MiscUtils.formatSizeBytes(media.SizeBytes)));
if (media.FileDate != null)
{
p.Add(new Tuple <string, string>("File Date", media.FileDate.ToString()));
}
if (media.LastModifiedDate != null)
{
p.Add(new Tuple <string, string>("File Modified", media.LastModifiedDate.ToString()));
}
int nrProps = p.Count;
if (media.Software != null)
{
p.Add(new Tuple <string, string>("Software", media.Software));
}
if (media.MetadataDate != null)
{
p.Add(new Tuple <string, string>("Metadata Date", media.MetadataDate.ToString()));
}
if (media.MetadataModifiedDate != null)
{
p.Add(new Tuple <string, string>("Metadata Modified", media.MetadataModifiedDate.ToString()));
}
if (media is ImageMetadata)
{
foreach (Tuple <string, string> item in FormatMetaData.formatProperties(media as ImageMetadata))
{
p.Add(item);
}
}
else if (media is AudioMetadata)
{
AudioMetadata audio = media as AudioMetadata;
if (audio.Genre != null)
{
p.Add(new Tuple <string, string>("Genre", audio.Genre));
}
if (audio.Album != null)
{
p.Add(new Tuple <string, string>("Album", audio.Album));
}
if (audio.TrackNr != null)
{
String value = audio.TrackNr.ToString();
if (audio.TotalTracks != null)
{
value += " / " + audio.TotalTracks;
}
p.Add(new Tuple <string, string>("Track", value));
}
if (audio.DiscNr != null)
{
String value = audio.DiscNr.ToString();
if (audio.TotalDiscs != null)
{
value += " / " + audio.TotalDiscs;
}
p.Add(new Tuple <string, string>("Disc", value));
}
}
if (media.Latitude != null)
{
p.Add(new Tuple <string, string>("GPS Latitude", media.Latitude.Value.ToString("0.00000")));
}
if (media.Longitude != null)
{
p.Add(new Tuple <string, string>("GPS Longitude", media.Longitude.Value.ToString("0.00000")));
}
if (p.Count > nrProps)
{
p.Insert(nrProps, new Tuple <string, string>("", "EXIF"));
}
}
void grabData()
{
if (items.Count == 1 && Items.ElementAt(0).Metadata != null)
{
MediaFileItem media = Items.ElementAt(0);
BaseMetadata metadata = media.Metadata;
if (metadata.SupportsXMPMetadata == false)
{
clear();
}
Filename = Path.GetFileNameWithoutExtension(metadata.Name);
Location = metadata.Path;
DynamicProperties.Clear();
if (metadata is ImageMetadata)
{
getImageProperties(DynamicProperties, metadata as ImageMetadata);
}
if (metadata is VideoMetadata)
{
getVideoProperties(DynamicProperties, metadata as VideoMetadata);
}
else if (metadata is AudioMetadata)
{
getAudioProperties(DynamicProperties, metadata as AudioMetadata);
}
Rating = metadata.Rating == null ? null : new Nullable <double>(metadata.Rating.Value / 5);
Title = metadata.Title;
Description = metadata.Description;
Author = metadata.Author;
Copyright = metadata.Copyright;
Creation = metadata.CreationDate;
IsImported = metadata.IsImported;
IsReadOnly = media.IsReadOnly || !metadata.SupportsXMPMetadata || metadata is UnknownMetadata;
Geotag = new GeoTagCoordinatePair(metadata.Latitude, metadata.Longitude);
lock (tagsLock)
{
Tags.Clear();
foreach (Tag tag in metadata.Tags)
{
Tags.Add(tag);
}
}
getExifProperties(DynamicProperties, metadata);
SelectedMetaDataPreset = noPresetMetaData;
IsEnabled = true;
BatchMode = false;
}
else if (items.Count > 1 && BatchMode == true)
{
}
else
{
if (items.Count > 1)
{
IsEnabled = true;
BatchMode = true;
IsReadOnly = false;
clear();
}
else if (items.Count == 0)
{
BatchMode = false;
IsEnabled = false;
IsReadOnly = true;
IsRegexEnabled = false;
clear();
}
}
}
public MetadataField(DO.MetadataField field, BaseMetadata metadata)
: this(field)
{
switch (field.Format)
{
case FormatType.Integer:
if (metadata.Value.IsNullOrWhiteSpace())
{
Value = null;
}
else
{
Value = metadata.Value.AsLong();
}
break;
case FormatType.Decimal:
if (metadata.Value.IsNullOrWhiteSpace())
{
Value = null;
}
else
{
decimal _value;
decimal.TryParse(metadata.Value, NumberStyles.Any, CultureInfo.InvariantCulture, out _value);
Value = _value;
}
break;
case FormatType.Date:
var value = metadata.Value.AsDateTime();
if (metadata.Value.IsNullOrWhiteSpace() || value == DateTime.MinValue)
{
Value = null;
}
else
{
Value = value;
}
break;
case FormatType.Boolean:
if (metadata.Value.IsNullOrWhiteSpace())
{
Value = null;
}
else
{
Value = metadata.Value.AsBool();
}
break;
default:
Value = metadata.Value;
break;
}
}
bool updateMetadata(MediaFileItem item, MetaDataUpdateViewModelAsyncState state)
{
bool isModified = false;
if (item.Metadata == null || item.Metadata is UnknownMetadata)
{
throw new Exception("Missing or invalid metadata in media");
}
isModified = item.Metadata.IsModified;
BaseMetadata media = item.Metadata;
if (state.RatingEnabled)
{
Nullable <double> oldValue = media.Rating;
media.Rating = state.Rating.HasValue == false ? null : state.Rating * 5;
if (media.Rating != oldValue)
{
isModified = true;
}
}
if (state.TitleEnabled && !EqualityComparer <String> .Default.Equals(media.Title, state.Title))
{
media.Title = state.Title;
isModified = true;
}
if (state.DescriptionEnabled && !EqualityComparer <String> .Default.Equals(media.Description, state.Description))
{
media.Description = state.Description;
isModified = true;
}
if (state.AuthorEnabled && !EqualityComparer <String> .Default.Equals(media.Author, state.Author))
{
media.Author = state.Author;
isModified = true;
}
if (state.CopyrightEnabled && !EqualityComparer <String> .Default.Equals(media.Copyright, state.Copyright))
{
media.Copyright = state.Copyright;
isModified = true;
}
if (state.CreationEnabled && !(Nullable.Compare <DateTime>(media.CreationDate, state.Creation) == 0))
{
media.CreationDate = state.Creation;
isModified = true;
}
if (state.IsGeoTagEnabled && !(Nullable.Compare <double>(media.Latitude, state.Latitude) == 0))
{
media.Latitude = state.Latitude;
isModified = true;
}
if (state.IsGeoTagEnabled && !(Nullable.Compare <double>(media.Longitude, state.Longitude) == 0))
{
media.Longitude = state.Longitude;
isModified = true;
}
if (state.BatchMode == false && !state.Tags.SequenceEqual(media.Tags))
{
media.Tags.Clear();
foreach (Tag tag in state.Tags)
{
media.Tags.Add(tag);
}
isModified = true;
}
else if (state.BatchMode == true)
{
bool addedTag = false;
bool removedTag = false;
foreach (Tag tag in state.AddTags)
{
// Hashset compares items using their gethashcode function
// which can be different for the same database entities created at different times
if (!media.Tags.Contains(tag, EqualityComparer <Tag> .Default))
{
media.Tags.Add(tag);
addedTag = true;
}
}
foreach (Tag tag in state.RemoveTags)
{
Tag removeTag = media.Tags.FirstOrDefault((t) => t.Name.Equals(tag.Name));
if (removeTag != null)
{
media.Tags.Remove(removeTag);
removedTag = true;
}
}
if (removedTag || addedTag)
{
isModified = true;
}
}
return(isModified);
}
