public Task SaveMedia(Stream stream, LocalItem localItem, ServerInfo server)
{
return(Task.FromResult(true));
}
public static LocalItem CreateLocalItem(int ID)
{
LocalItem localItem = new LocalItem();
localItem.ID = ID;
return localItem;
}
public Task Delete(LocalItem item)
{
return(Task.FromResult(true));
}
public Task <List <ItemFileInfo> > GetFiles(LocalItem item)
{
return(Task.FromResult(new List <ItemFileInfo>()));
}
private void SetStaticMediaSourceInfo(LocalItem item, MediaSourceInfo mediaSource)
{
mediaSource.Id = item.Id;
mediaSource.SupportsTranscoding = false;
}
public Task SaveMedia(Windows.Storage.IStorageFile file, LocalItem localItem, ServerInfo server)
{
return(Task.FromResult(true));
}
public async Task <List <BaseItem> > GetChangesFromChangeTracker(KnownLibraryId libraryId, FolderAssociation association, List <StorageLibraryChangeType> supportedChangeTypes)
{
var result = new List <BaseItem>();
var library = await StorageLibrary.GetLibraryAsync(libraryId);
library.ChangeTracker.Enable();
_changeReader = library.ChangeTracker.GetChangeReader();
var changes = await _changeReader.ReadBatchAsync();
foreach (var change in changes)
{
if (change.ChangeType == StorageLibraryChangeType.ChangeTrackingLost)
{
await LogHelper.Write($"Changetracking lost: {change.Path}");
library.ChangeTracker.Reset();
return(null);
}
try
{
if (supportedChangeTypes.Contains(change.ChangeType))
{
Debug.WriteLine($"File: {change.Path} ChangeType: {change.ChangeType}");
if (change.Path.EndsWith("thumb"))
{
continue;
}
var file = await change.GetStorageItemAsync();
if (file == null && change.ChangeType == StorageLibraryChangeType.Deleted)
{
var localItem = new LocalItem();
localItem.Association = association;
localItem.EntityId = change.Path;
result.Add(localItem);
}
else if (file == null || file.IsOfType(StorageItemTypes.Folder))
{
await LogHelper.Write($"Skipping {change.Path}");
}
else
{
try
{
//check if the file is currently in use, for example a video currently being recorded
var stream = await((StorageFile)file).OpenStreamForWriteAsync();
stream.Dispose();
}
catch (Exception)
{
continue;
}
var props = await file.GetBasicPropertiesAsync();
var item = new LocalItem(association, file, props);
if (change.ChangeType == StorageLibraryChangeType.ContentsChanged)
{
//for some reason something is writing to the files after the upload, but without making changes
var existingItem = ItemTableModel.GetDefault().GetItem(item);
if (existingItem?.Size == item.Size)
{
continue;
}
}
result.Add(item);
}
}
}
catch (Exception e)
{
await LogHelper.Write($"InstantUpload: {e.Message} File: {change.Path} ChangeType: {change.ChangeType}");
await LogHelper.Write(e.StackTrace);
}
}
return(result);
}
/// <summary>
/// Adds the or update.
/// </summary>
/// <param name="item">The item.</param>
/// <returns>Task.</returns>
public Task AddOrUpdate(LocalItem item)
{
return(_itemRepository.AddOrUpdate(item));
}
/// <summary>
/// Fills element in the remote storage from the element synchronization
/// in the local storage.<paramref name="localItem"/>.
/// </summary>
/// <param name="localItem">The element synchronization in the local storage.</param>
/// <param name="context">Synchronization context.</param>
public override void FillRemoteItem(SyncContext context, LocalItem localItem)
{
var exchangeContact = (Exchange.Contact)Item;
SyncEntity localEntity = localItem.Entities["Contact"][0];
if (localEntity == null)
{
return;
}
if (localEntity.State == SyncState.Deleted)
{
return;
}
if (Action == SyncAction.None)
{
return;
}
var localContact = localEntity.Entity;
if (localContact == null || GetEntityLockedForSync(localContact.PrimaryColumnValue, context))
{
Action = SyncAction.None;
return;
}
if (Action == SyncAction.Update)
{
InitIdProperty(context);
}
exchangeContact.DisplayName = localContact.GetTypedColumnValue <string>("Name");
exchangeContact.Surname = localContact.GetTypedColumnValue <string>("Surname");
exchangeContact.GivenName = localContact.GetTypedColumnValue <string>("GivenName");
exchangeContact.MiddleName = localContact.GetTypedColumnValue <string>("MiddleName");
exchangeContact.CompanyName = localContact.GetTypedColumnValue <string>("AccountName");
exchangeContact.JobTitle = localContact.GetTypedColumnValue <string>("JobTitle");
exchangeContact.Department = localContact.GetTypedColumnValue <string>("DepartmentName");
var birthDate = localContact.GetTypedColumnValue <DateTime>("BirthDate");
if (birthDate != DateTime.MinValue)
{
exchangeContact.Birthday = birthDate;
}
if (Action == SyncAction.Create)
{
exchangeContact.FileAsMapping = Exchange.FileAsMapping.DisplayName;
exchangeContact.SetExtendedProperty(ExchangeUtilityImpl.LocalIdProperty, localContact.PrimaryColumnValue.ToString());
}
exchangeContact.BusinessHomePage = GetWebPageForRemoteItem(localItem, context.UserConnection,
localContact.PrimaryColumnValue);
SetContactTitle(exchangeContact, localContact.GetTypedColumnValue <string>("SalutationTypeName"));
SetContactGender(exchangeContact, localContact.GetTypedColumnValue <Guid>("GenderId"));
var emailAddressesSynchronizer =
new ExchangeEmailAddressDetailsSynchronizer(context, localItem, exchangeContact);
var addressesSynchronizer =
new ExchangeAddressDetailsSynchronizer(context, localItem, exchangeContact);
var phoneNumbersSynchronizer =
new ExchangePhoneNumbersDetailsSynchronizer(context, localItem, exchangeContact);
emailAddressesSynchronizer.SyncRemoteDetails();
addressesSynchronizer.SyncRemoteDetails();
phoneNumbersSynchronizer.SyncRemoteDetails();
}
static public string GetLocalText(LocalLang lang, LocalItem item)
{
return(lang == LocalLang.RU ? russianLocalText[(int)item] : englishLocalText[(int)item]);
}
/// <summary>
/// Fills element synchronization in the local storage <paramref name="localItem"/>
/// the value of the element in the external storage.
/// </summary>
/// <param name="localItem">Local storage synchronization element.</param>
/// <param name="context">Synchronization context.</param>
public override void FillLocalItem(SyncContext context, ref LocalItem localItem)
{
if (IsDeletedProcessed("Contact", ref localItem) || IsLocalItemDeleted(ref localItem))
{
return;
}
var contactRemoteProvider = context.RemoteProvider as ExchangeContactSyncProviderImpl;
var exchangeContact = Item as Exchange.Contact;
if (exchangeContact == null)
{
context.LogError(Action, SyncDirection.Upload,
GetLocalizableString(context.UserConnection, "InvalidItemTypeTpl"), GetItemSimpleId(),
Item.Subject);
Action = SyncAction.None;
return;
}
string surname = exchangeContact.Surname;
string givenName = exchangeContact.GivenName;
string middleName = exchangeContact.MiddleName;
if (GetIsContactNameEmpty(exchangeContact, context) || GetRemoteItemLockedForSync(context))
{
Action = SyncAction.None;
return;
}
LoadItemProperties(exchangeContact);
var contact = GetContactInstance(context, localItem, exchangeContact);
if (contact == null || !SetContactExtendProperty(context, exchangeContact, contact.PrimaryColumnValue))
{
Action = SyncAction.None;
return;
}
contact.SetColumnValue("Surname", surname);
contact.SetColumnValue("GivenName", givenName);
contact.SetColumnValue("MiddleName", middleName);
contact.SetColumnValue("OwnerId", context.UserConnection.CurrentUser.ContactId);
contact.SetColumnValue("JobTitle", exchangeContact.JobTitle);
var birthdate = exchangeContact.SafeGetValue <DateTime>(Exchange.ContactSchema.Birthday);
if (birthdate != DateTime.MinValue)
{
contact.SetColumnValue("BirthDate", birthdate);
}
Dictionary <string, Guid> accountsMap = contactRemoteProvider.AccountsMap;
if (accountsMap != null)
{
string companyName = exchangeContact.CompanyName;
if (string.IsNullOrEmpty(companyName))
{
contact.SetColumnValue("AccountId", null);
}
else if (accountsMap.ContainsKey(companyName))
{
contact.SetColumnValue("AccountId", accountsMap[companyName]);
}
}
AddOrReplaceWebPageInLocalItem(context.UserConnection, localItem, contact.PrimaryColumnValue,
exchangeContact.BusinessHomePage);
var emailAddressesSynchronizer = new ExchangeEmailAddressDetailsSynchronizer(context, localItem,
exchangeContact);
var addressesSynchronizer = new ExchangeAddressDetailsSynchronizer(context, localItem, exchangeContact);
var phoneNumbersSynchronizer = new ExchangePhoneNumbersDetailsSynchronizer(context, localItem,
exchangeContact);
emailAddressesSynchronizer.SyncLocalDetails();
addressesSynchronizer.SyncLocalDetails();
phoneNumbersSynchronizer.SyncLocalDetails();
}
public static async Task <LocalItem> GetItemInfo(LocalItem item)
{
throw new NotImplementedException();
}
public void AddToLocal(LocalItem localItem)
{
base.AddObject("Local", localItem);
}
public Task SaveMedia(Stream stream, LocalItem localItem, ServerInfo server)
{
_logger.Debug("Saving media to " + localItem.LocalPath);
return(_fileRepository.SaveFile(stream, localItem.LocalPath));
}
/// <summary>Returns activity instance for exchange appointment, in case of changed remote id.</summary>
/// <param name="context">Synchronization context.</param>
/// <param name="exchangeItem">Exchange item in external storage.</param>
/// <param name="storedId">Id of bpm activity, stored in external property of exchange item.</param>
/// <param name="localItem">Local storage item.</param>
/// <returns>Activity instance.</returns>
protected Entity GetSyncedActivityWithChangedRemoteId(SyncContext context, Exchange.Item exchangeItem, Guid storedId, LocalItem localItem)
{
Entity instance;
var syncValueName = localItem.Schema.SyncValueName;
var schema = context.UserConnection.EntitySchemaManager.GetInstanceByName("Activity");
instance = schema.CreateEntity(context.UserConnection);
if (!localItem.Entities["Activity"].Any(se => se.EntityId.Equals(storedId)) &&
instance.FetchFromDB(storedId))
{
SyncEntity syncEntity = SyncEntity.CreateNew(instance);
var isCurrentUserOwner = context.UserConnection.CurrentUser.ContactId == instance.GetTypedColumnValue <Guid>("OwnerId");
syncEntity.Action = isCurrentUserOwner ? SyncAction.Update : SyncAction.None;
context.LogInfo(SyncAction.None, SyncDirection.DownloadAndUpload,
"GetSyncedActivityWithChangedRemoteId set action {0} for {1}",
syncEntity.Action, GetDisplayName());
localItem.AddOrReplace("Activity", syncEntity);
if (syncValueName == ExchangeConsts.ExchangeAppointmentClassName)
{
context.LogInfo(SyncAction.None, SyncDirection.DownloadAndUpload,
"GetSyncedActivityWithChangedRemoteId ExchangeAppointmentClassName action update for {0}",
GetDisplayName());
Action = SyncAction.Update;
syncEntity.Action = SyncAction.Update;
}
else
{
Action = isCurrentUserOwner ? SyncAction.Update : SyncAction.None;
context.LogInfo(SyncAction.None, SyncDirection.DownloadAndUpload,
"GetSyncedActivityWithChangedRemoteId action {0} for {1}", Action, GetDisplayName());
if (isCurrentUserOwner)
{
ActualizeOldMetadata(context, storedId, Id);
}
}
}
else
{
context.LogInfo(SyncAction.None, SyncDirection.DownloadAndUpload,
"GetSyncedActivityWithChangedRemoteId not found entity action {0} for {1}",
Action, GetDisplayName());
instance = GetEntityInstance <Entity>(context, localItem, "Activity");
}
return(instance);
}
/// <summary>
/// Deletes the specified item.
/// </summary>
/// <param name="item">The item.</param>
/// <returns>Task.</returns>
public Task Delete(LocalItem item)
{
return(_itemRepository.Delete(item.Id));
}
/// <summary>
/// Returns activity instance.
/// </summary>
/// <param name="context">Synchronization context.</param>
/// <param name="exchangeItem">Sync element in external storage.</param>
/// <param name="localItem">Sync element in local storage.</param>
protected Entity GetActivity(SyncContext context, Exchange.Item exchangeItem, ref LocalItem localItem)
{
Entity instance;
Object localId;
if (exchangeItem.TryGetProperty(ExchangeUtilityImpl.LocalIdProperty, out localId))
{
context.LogInfo(SyncAction.None, SyncDirection.DownloadAndUpload,
"GetActivity use localId action {0} for {1}",
Action, GetDisplayName());
instance = GetSyncedActivityWithChangedRemoteId(context, exchangeItem, Guid.Parse(localId.ToString()), localItem);
}
else
{
context.LogInfo(SyncAction.None, SyncDirection.DownloadAndUpload,
"GetActivity not use localId action {0} for {1}",
Action, GetDisplayName());
instance = GetEntityInstance <Entity>(context, localItem, "Activity");
}
return(instance);
}
private async Task _GetChangesFromSearchIndex(StorageFolder folder, long associationId,
List <BaseItem> result)
{
var association = FolderAssociationTableModel.GetDefault().GetItem(associationId);
var files = new List <IStorageItem>();
var options = new QueryOptions();
options.FolderDepth = FolderDepth.Deep;
options.IndexerOption = IndexerOption.UseIndexerWhenAvailable;
//details about filesystem queries using the indexer
//https://msdn.microsoft.com/en-us/magazine/mt620012.aspx
string timeFilter = "System.Search.GatherTime:>=" + association.LastSync;
options.ApplicationSearchFilter = timeFilter;
var prefetchedProperties = new List <string> {
"System.DateModified", "System.Size"
};
options.SetPropertyPrefetch(PropertyPrefetchOptions.BasicProperties, prefetchedProperties);
if (!folder.AreQueryOptionsSupported(options))
{
throw new Exception($"Windows Search Index has to be enabled for {folder.Path}");
}
var queryResult = folder.CreateItemQueryWithOptions(options);
queryResult.ApplyNewQueryOptions(options);
files.AddRange(await queryResult.GetItemsAsync());
foreach (var file in files)
{
try
{
IDictionary <string, object> propertyResult = null;
if (file.IsOfType(StorageItemTypes.File))
{
propertyResult =
await((StorageFile)file).Properties.RetrievePropertiesAsync(prefetchedProperties);
}
else if (file.IsOfType(StorageItemTypes.Folder))
{
propertyResult =
await((StorageFolder)file).Properties.RetrievePropertiesAsync(prefetchedProperties);
}
var item = new LocalItem(new FolderAssociation {
Id = associationId
}, file, propertyResult);
var existingItem = ItemTableModel.GetDefault().GetItem(item);
if (existingItem != null)
{
if (!item.IsCollection)
{
//additional check if the file has changed:
//even though the size not the best way to make sure if a file has changed
//its very unlikely that after a change they have the exact same byte count
//so its the best option we have
if ((ulong)propertyResult["System.Size"] == existingItem.Size)
{
continue;
}
}
}
result.Add(item);
}
catch (Exception)
{
Debug.WriteLine(file);
throw;
}
}
if (files.Count == 0)
{
await _GetChangedFilesRecursive(folder, association, result);
}
if (!IsBackgroundSync)
{
var unsynced =
ItemTableModel.GetDefault()
.GetPostponedItems()
.Where(x => x.AdapterType == typeof(FileSystemAdapter));
foreach (var abstractItem in unsynced)
{
abstractItem.SyncPostponed = false;
}
result.AddRange(unsynced);
}
}
/// <summary> /// Fills BPM synchronization item<paramref name="localItem"/> /// the values of the elements in the external storage. /// </summary> /// <param name="localItem">BPM item.</param> /// <param name="context">Synchronization context.</param> public abstract void FillLocalItem(SyncContext context, ref LocalItem localItem);
public Task GetItem(LocalItem item)
{
throw new NotImplementedException();
}
/// <summary> /// Fills item in remote storage the values /// of the BPM element<paramref name="localItem"/>. /// </summary> /// <param name="localItem">BPM item.</param> /// <param name="context">Synchronization context.</param> public abstract void FillRemoteItem(SyncContext context, LocalItem localItem);
private void SelecionaLocalItem(LocalItem localItem)
{
_localItemSelecionado = localItem;
_localItemSelecionado.Highlight();
}
public Task SaveMedia(Windows.Storage.IStorageFile file, LocalItem localItem, ServerInfo server)
{
_logger.Debug("Saving media to " + localItem.LocalPath);
return(_fileRepository.SaveFile(file, localItem.LocalPath));
}
public Task AddOrUpdate(LocalItem item)
{
return(Task.FromResult(true));
}
private async Task <SendFileResult> SendFile(IServerSyncProvider provider, string inputPath, LocalItem item, SyncTarget target, CancellationToken cancellationToken)
{
using (var stream = _fileSystem.GetFileStream(inputPath, FileMode.Open, FileAccess.Read, FileShare.Read, true))
{
return(await provider.SendFile(stream, item.LocalPath, target, new Progress <double>(), cancellationToken).ConfigureAwait(false));
}
}
public Task <string> SaveSubtitles(Stream stream, string format, LocalItem item, string language, bool isForced)
{
throw new NotImplementedException();
}
private async Task <List <ItemFileInfo> > GetFiles(IServerSyncProvider provider, LocalItem item, SyncTarget target, CancellationToken cancellationToken)
{
var path = item.LocalPath;
path = provider.GetParentDirectoryPath(path, target);
var list = await provider.GetFileSystemEntries(path, target, cancellationToken).ConfigureAwait(false);
var itemFiles = new List <ItemFileInfo>();
var name = Path.GetFileNameWithoutExtension(item.LocalPath);
foreach (var file in list.Where(f => f.Name.Contains(name)))
{
var itemFile = new ItemFileInfo
{
Path = file.Path,
Name = file.Name
};
if (IsSubtitleFile(file.Name))
{
itemFile.Type = ItemFileType.Subtitles;
}
itemFiles.Add(itemFile);
}
return(itemFiles);
}
public ItemModel()
{
BasicItem = new Item();
FoodItem = new FoodItem();
LocalItem = new LocalItem();
}
Task IItemRepository.AddOrUpdate(LocalItem item)
{
throw new NotImplementedException();
}
