public bool VerifyFile(CheckUpdateDto data)
{
FileTag fileTags = new FileTag();
SlideTagExCollection slideTags = new SlideTagExCollection();
LibrarianContentManifest libraryContentManifest = new LibrarianContentManifest();
using (Stream stream = new FileStream(data.FileUrl, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
{
using (PresentationDocument openXmlDoc = PresentationDocument.Open(stream, false))
{
var presentationPart = openXmlDoc.PresentationPart;
fileTags = _tagManagerService.GetFileTag(presentationPart);
slideTags = _tagManagerService.GetSlideTags(presentationPart);
libraryContentManifest = XmlUtils.Deserialize <LibrarianContentManifest>(_filesService.GetCustomXmlPart(presentationPart));
if (fileTags != null)
{
return(true);
}
if (slideTags.Count > 0)
{
return(true);
}
if (libraryContentManifest != null)
{
return(true);
}
}
}
return(false);
}
public LibraryFileInfoEx GetFileInfo(CheckUpdateDto data)
{
LibraryFileInfoEx libraryFileInfoEx = new LibraryFileInfoEx();
HttpWebRequest request = (HttpWebRequest)WebRequest.Create($"{data.ServerInfo.WebClientUrl}{data.ServerInfo.ShortLibraryName}/Default.ashx?m=getfi&fid={data.FileId}&useweb=true?out=xml");
request.Method = "GET";
request.Headers.Add("Authorization", data.ServerInfo.AuthHash);
request.Proxy.Credentials = CredentialCache.DefaultCredentials;
try
{
using (HttpWebResponse response = (HttpWebResponse)request.GetResponse())
{
var responseStream = Helper.ReadResponseAsStream(response);
var responseXMLString = Helper.ReadResponseAsString(responseStream);
libraryFileInfoEx = Helper.DeserializeXmlResponse <LibraryFileInfoEx>(responseXMLString);
}
}
catch (Exception ex)
{
return(null);
}
return(libraryFileInfoEx);
}
public void InsertCustomXml(CheckUpdateDto data)
{
var stringData = string.Empty;
HttpWebRequest request = (HttpWebRequest)WebRequest.Create($"{data.ServerInfo.WebClientUrl}{data.ServerInfo.ShortLibraryName}/Default.ashx?m=getfi&fid={data.FileId}&useweb=True&out=json");
request.Method = "GET";
request.Headers.Add("Authorization", data.ServerInfo.AuthHash);
request.Proxy.Credentials = CredentialCache.DefaultCredentials;
using (HttpWebResponse response = (HttpWebResponse)request.GetResponse())
{
Stream dataStream = response.GetResponseStream();
StreamReader reader = new StreamReader(dataStream);
stringData = reader.ReadToEnd();
reader.Close();
dataStream.Close();
}
var dataObject = JObject.Parse(stringData);
var lastModDate = dataObject.SelectToken("LastModDate").Value <string>();
var librarianContentManifest = new LibrarianContentManifest
{
CatType = CategoryType.Generic,
ContentId = data.FileId,
ContentType = ContentType.File,
DateCreatedUTC = DateTime.UtcNow.ToString("o"),
Filename = data.FileName,
LastModDate = DateTime.Parse(lastModDate).ToString("o"),
LibraryName = data.ServerInfo.ShortLibraryName,
LiveDb = true,
Server = data.ServerInfo.EnvironmentName.Replace(" ", ""),
PageCount = dataObject.SelectToken("PageCount").Value <int>(),
Items = new List <ContentItem>()
{
new ContentItem {
ContentType = ContentType.File,
FileId = data.FileId,
LastModDate = DateTime.Parse(lastModDate).ToString("o"),
PageCount = dataObject.SelectToken("PageCount").Value <int>(),
ParentContentId = data.FileId,
ParentContentType = ContentType.File,
ParentItemIndex = -1,
ParentLastModDate = DateTime.Parse(lastModDate).ToString("o"),
SlideId = -1,
SlideNumber = -1
}
}
};
var result = Utils.InsertCustomXml(data.FileUrl, XmlUtils.Serialize(librarianContentManifest));
}
public static int GetCategoryIdForFile(ICategoryService categoryService, CheckUpdateDto data, int fileId, bool useWeb)
{
int catId = -1;
string catPath = categoryService.GetFileCatPath(data, useWeb);
string[] slashes = catPath.Split('/');
if (slashes.Length >= 2)
{
catId = Convert.ToInt32(slashes[slashes.Length - 2].Substring(1));
}
return(catId);
}
public LibraryCategoryInfo GetLibraryCategoryInfo(CheckUpdateDto data, int catId, bool useWeb, bool isIncludeFile = false)
{
HttpWebRequest request = (HttpWebRequest)WebRequest.Create($"{data.ServerInfo.WebClientUrl}{data.ServerInfo.ShortLibraryName}/Default.ashx?m=getci&cid={catId}&useweb={useWeb}&out=xml");
request.Method = "GET";
request.Headers.Add("Authorization", data.ServerInfo.AuthHash);
request.Proxy.Credentials = CredentialCache.DefaultCredentials;
using (HttpWebResponse response = (HttpWebResponse)request.GetResponse())
{
var responseStream = Helper.ReadResponseAsStream(response);
return(Helper.DeserializeResponse <LibraryCategoryInfo>(responseStream));
}
}
public string GetFileCatPath(CheckUpdateDto data, bool useWeb)
{
HttpWebRequest request = (HttpWebRequest)WebRequest.Create($"{data.ServerInfo.WebClientUrl}{data.ServerInfo.ShortLibraryName}/Default.ashx?m=getpath&ftype=0&cid=-1&fid={data.FileId}&useweb={useWeb}&out=xml");
request.Method = "GET";
request.Headers.Add("Authorization", data.ServerInfo.AuthHash);
request.Proxy.Credentials = CredentialCache.DefaultCredentials;
using (HttpWebResponse response = (HttpWebResponse)request.GetResponse())
{
var responseStream = Helper.ReadResponseAsStream(response);
return(Helper.DeserializeResponse <string>(responseStream));
}
}
public string GetLatestFile(CheckUpdateDto data)
{
HttpWebRequest request = (HttpWebRequest)WebRequest.Create($"{data.ServerInfo.WebClientUrl}{data.ServerInfo.ShortLibraryName}/Download.ashx?mode=dnld&fid={data.FileId}&useweb=false&out=xml");
request.Method = "GET";
request.Headers.Add("Accept-Encoding: gzip, deflate");
request.Headers.Add("Accept-Language: en-US");
request.Accept = "application/x-ms-application, image/jpeg, application/xaml+xml, image/gif, image/pjpeg, application/x-ms-xbap, application/vnd.ms-excel, application/vnd.ms-powerpoint, application/msword, */*";
request.Headers.Add("Authorization", data.ServerInfo.AuthHash);
request.Proxy.Credentials = CredentialCache.DefaultCredentials;
using (HttpWebResponse response = (HttpWebResponse)request.GetResponse())
{
return(SaveFile(response, $"{data.FileName}"));
}
}
public IActionResult GetFile([FromBody] CheckUpdateDto data)
{
var result = _fileServices.GetLatestFile(data);
if (string.IsNullOrEmpty(result))
{
return(NotFound());
}
data.FileUrl = result;
if (!data.IsOverwrite)
{
_fileServices.InsertCustomXml(data);
}
else
{
_tagManagerService.SetTags(data, false);
}
return(Ok(Path.Combine(_hostingEnvironment.ContentRootPath, result)));
}
private bool CheckContentForUpdates(ContentType contentType, DateTime lastModDateUtc, CheckUpdateDto fileInfo)
{
bool updatesExist = false;
if (contentType == ContentType.File)
{
LibraryFileInfoEx libraryFileInfoEx = _filesService.GetFileInfo(fileInfo);
if (libraryFileInfoEx == null)
{
isExcuted = false;
return(updatesExist);
}
updatesExist = libraryFileInfoEx.LastModDate > lastModDateUtc;
LibraryCategoryInfo libraryCategoryInfo = Utils.GetCategoryInfoForFile(_categoryService, fileInfo, libraryFileInfoEx.FileId, !libraryFileInfoEx.IsUserFile);
isLibraryFile = !libraryCategoryInfo.Type.IsUserCategory();
}
else
{
if (contentType == ContentType.GlobalFavorite)
{
//ContentGroupInfo contentGroupInfo = da.LibrarianRpc.GetContentGroupInfo(contentId);
//updatesExist = contentGroupInfo.LastModDate > lastModDateUtc;
}
else if (contentType == ContentType.MyFavorite)
{
//VirtualPresentation virtualPresentation = session.LibrarianRpc.GetVirtualPresentation(contentId);
//updatesExist = virtualPresentation.CreatedDate > lastModDateUtc;
}
}
return(updatesExist);
}
public static LibraryCategoryInfo GetCategoryInfoForFile(ICategoryService categoryService, CheckUpdateDto data, int fileId, bool useWeb)
{
int catId = GetCategoryIdForFile(categoryService, data, fileId, useWeb);
LibraryCategoryInfo libraryCategoryInfo = categoryService.GetLibraryCategoryInfo(data, catId, useWeb, false);
return(libraryCategoryInfo);
}
public bool SetTags(CheckUpdateDto data, bool overwriteExistingTags)
{
bool setTags = false;
using (Stream stream = new FileStream(data.FileUrl, FileMode.Open, FileAccess.ReadWrite, FileShare.ReadWrite))
{
using (PresentationDocument openXmlDoc = PresentationDocument.Open(stream, true))
{
var presentationPart = openXmlDoc.PresentationPart;
SlideTagExCollection slideTags = GetSlideTags(presentationPart);
var libraryFileSlides = _fileService.GetFileSlidesInfo(data);
if (overwriteExistingTags || !slideTags.Any())
{
var fileInfo = _fileService.GetFileInfo(data);
FileTag fileTag = new FileTag();
fileTag.Library.Environment = data.ServerInfo.EnvironmentName;
fileTag.Library.ShortName = data.ServerInfo.ShortLibraryName;
fileTag.File.Id = int.Parse(data.FileId);
fileTag.File.ContentType = ContentType.File;
fileTag.File.LastModDate = fileInfo.LastModDate.Value.ToLocalTime();
TagList tagList = new TagList();
tagList.Append(new Tag()
{
Name = PL_TAG,
Val = XmlUtils.Serialize(fileTag)
});
if (presentationPart.UserDefinedTagsPart == null)
{
presentationPart.AddNewPart <UserDefinedTagsPart>();
presentationPart.UserDefinedTagsPart.TagList = tagList;
}
foreach (var slidePart in presentationPart.SlideParts)
{
var slideId = presentationPart.Presentation.SlideIdList.Where(s => ((SlideId)s).RelationshipId == presentationPart.GetIdOfPart(slidePart)).Select(s => (SlideId)s).FirstOrDefault();
var slideInfo = libraryFileSlides.Slides.Where(x => x.SlidePptId == slideId.Id).FirstOrDefault();
SlideTag slideTag = new SlideTag(fileTag);
slideTag.Slide.Id = slideInfo.SlideId;
slideTag.Slide.LastModDate = ((DateTime)slideInfo.LastModDate).ToLocalTime();
Tag slideObjectTag = new Tag()
{
Name = PL_TAG, Val = XmlUtils.Serialize(slideTag)
};
UserDefinedTagsPart userDefinedTagsPart1 = slidePart.AddNewPart <UserDefinedTagsPart>();
if (userDefinedTagsPart1.TagList == null)
{
userDefinedTagsPart1.TagList = new TagList();
}
userDefinedTagsPart1.TagList.Append(slideObjectTag);
var id = slidePart.GetIdOfPart(userDefinedTagsPart1);
if (slidePart.Slide.CommonSlideData == null)
{
slidePart.Slide.CommonSlideData = new CommonSlideData();
}
if (slidePart.Slide.CommonSlideData.CustomerDataList == null)
{
slidePart.Slide.CommonSlideData.CustomerDataList = new CustomerDataList();
}
CustomerDataTags tags = new CustomerDataTags
{
Id = id
};
slidePart.Slide.CommonSlideData.CustomerDataList.AppendChild(tags);
slidePart.Slide.Save();
}
}
else if (presentationPart.UserDefinedTagsPart == null)
{
FileTag fileTag = new FileTag();
fileTag.Library.Environment = data.ServerInfo.EnvironmentName;
fileTag.Library.ShortName = data.ServerInfo.ShortLibraryName;
fileTag.File.Id = -1;
fileTag.File.ContentType = ContentType.Undefined;
fileTag.File.LastModDate = DateTime.Now;
TagList tagList = new TagList();
tagList.Append(new Tag()
{
Name = PL_TAG,
Val = XmlUtils.Serialize(fileTag)
});
if (presentationPart.UserDefinedTagsPart == null)
{
presentationPart.AddNewPart <UserDefinedTagsPart>();
presentationPart.UserDefinedTagsPart.TagList = tagList;
}
foreach (var slidePart in presentationPart.SlideParts)
{
var slideId = presentationPart.Presentation.SlideIdList.Where(s => ((SlideId)s).RelationshipId == presentationPart.GetIdOfPart(slidePart)).Select(s => (SlideId)s).FirstOrDefault();
var slideInfo = libraryFileSlides.Slides.Where(x => x.SlidePptId == slideId.Id).FirstOrDefault();
var index = libraryFileSlides.Slides.IndexOf(slideInfo);
SlideTag slideTag = new SlideTag(data.ServerInfo.EnvironmentName, data.ServerInfo.ShortLibraryName, libraryFileSlides.Slides[index], -1);
Tag slideObjectTag = new Tag()
{
Name = PL_TAG, Val = XmlUtils.Serialize(slideTag)
};
if (slidePart.UserDefinedTagsParts.Count() > 0)
{
var customerDataPart = slidePart.UserDefinedTagsParts.FirstOrDefault().TagList;
customerDataPart.ReplaceChild(slideObjectTag, customerDataPart.FirstChild);
slidePart.Slide.Save();
}
}
}
setTags = true;
}
}
return(setTags);
}
public IActionResult VerifyFile([FromBody] CheckUpdateDto data)
{
return(Ok(_slideUpdateManagerService.VerifyFile(data)));
}
public IActionResult CheckUpdate([FromBody] CheckUpdateDto data)
{
var result = _slideUpdateManagerService.CheckForUpdates(data);
return(Ok(result));
}
//PRIVATE METHOD
private bool CheckFileForUpdates(FileTag fileTag, SlideTagExCollection slideTags, CheckUpdateDto fileInfo)
{
bool updatesExist = false;
if (fileTag != null)
{
updatesExist = CheckContentForUpdates(fileTag.File.ContentType, fileTag.File.LastModDate.ToUniversalTime(), fileInfo);
}
if (slideTags != null)
{
updatesExist |= CheckSlidesForUpdates(slideTags, isLibraryFile, fileInfo);
}
return(updatesExist);
}
private bool CheckSlidesForUpdates(SlideTagExCollection slideTags, bool isLibraryFile, CheckUpdateDto fileInfo)
{
bool updatesExist = false;
for (int x = 0; x < slideTags.Count; x++)
{
SlideTagEx slideTagEx = slideTags[x];
if (slideTagEx.SlideStatus == TagUpdateStatus.Unknown)
{
LibraryFileSlides libraryFileSlides = null;
try
{
if (fileInfo.FileId == "-1")
{
fileInfo.FileId = slideTagEx.File.Id.ToString();
}
libraryFileSlides = _filesService.GetFileSlidesInfo(fileInfo);
}
catch (Exception ex)
{
isExcuted = false;
return(updatesExist);
}
if (libraryFileSlides != null)
{
for (int i = 0; i < libraryFileSlides.Slides.Count; i++)
{
SlideInfo librarySlideInfo = libraryFileSlides.Slides[i];
SlideTagExCollection findSlideTags;
findSlideTags = slideTags.FindBySlideId(fileInfo.ServerInfo.EnvironmentName, fileInfo.ServerInfo.ShortLibraryName, librarySlideInfo.SlideId);
if (findSlideTags.Any())
{
int movedCount = 0;
for (int z = 0; z < findSlideTags.Count; z++)
{
SlideTagEx foundSlideTag = findSlideTags[z];
if (isLibraryFile && foundSlideTag.PptSlideIndex != librarySlideInfo.SlideNumber)
{
if (z == 0 && movedCount == 0)
{
foundSlideTag.SlideStatus = TagUpdateStatus.Moved;
++movedCount;
}
else
{
foundSlideTag.SlideStatus = TagUpdateStatus.Added;
}
}
else if (librarySlideInfo.LastModDate <= foundSlideTag.Slide.LastModDate.ToUniversalTime())
{
foundSlideTag.SlideStatus = TagUpdateStatus.NoChange;
}
else
{
foundSlideTag.SlideStatus = TagUpdateStatus.Updated;
updatesExist = true;
}
foundSlideTag.SourceFilename = librarySlideInfo.FileName;
foundSlideTag.SourceSlideNum = librarySlideInfo.SlideNumber;
foundSlideTag.SourceLastModDate = (DateTime)librarySlideInfo.LastModDate;
}
}
else if (isLibraryFile)
{
SlideTagEx newSlideTag = new SlideTagEx(fileInfo.ServerInfo.EnvironmentName, fileInfo.ServerInfo.ShortLibraryName, librarySlideInfo, -1)
{
SlideStatus = TagUpdateStatus.New,
Title = librarySlideInfo.Title,
SourceFilename = librarySlideInfo.FileName,
SourceSlideNum = librarySlideInfo.SlideNumber,
SourceLastModDate = (DateTime)librarySlideInfo.LastModDate
};
slideTags.Insert(i, newSlideTag);
updatesExist = true;
}
}
}
foreach (SlideTagEx nextSlideTagEx in slideTags)
{
if (nextSlideTagEx.SlideStatus == TagUpdateStatus.Unknown)
{
if (nextSlideTagEx.File.Id == slideTagEx.File.Id &&
nextSlideTagEx.Library.ShortName == slideTagEx.Library.ShortName &&
nextSlideTagEx.Library.Environment == slideTagEx.Library.Environment)
{
if (isLibraryFile)
{
nextSlideTagEx.SlideStatus = TagUpdateStatus.Added;
}
else
{
updatesExist = true;
nextSlideTagEx.SlideStatus = TagUpdateStatus.MissingOrDeleted;
if (libraryFileSlides != null && libraryFileSlides.Slides.Any())
{
nextSlideTagEx.SourceFilename = libraryFileSlides.Slides[0].FileName;
}
}
}
}
}
}
}
return(updatesExist);
}
public object CheckForUpdates(CheckUpdateDto data)
{
bool updatesExist = false;
bool showConfirmation = true;
FileTag fileTags = new FileTag();
SlideTagExCollection slideTags = new SlideTagExCollection();
LibrarianContentManifest libraryContentManifest = new LibrarianContentManifest();
using (Stream stream = new FileStream(data.FileUrl, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
{
using (PresentationDocument openXmlDoc = PresentationDocument.Open(stream, false))
{
var presentationPart = openXmlDoc.PresentationPart;
fileTags = _tagManagerService.GetFileTag(presentationPart);
slideTags = _tagManagerService.GetSlideTags(presentationPart);
if (fileTags != null)
{
data.FileId = fileTags.File.Id.ToString();
if (data.AskFirst)
{
if (fileTags != null && fileTags.File.ContentType == ContentType.File)
{
return(new CheckUpdateResponseDto()
{
FileId = data.FileId,
StatusCode = (HttpStatusCode)CheckUpdateStatusCode.HasNewVersion,
StatusText = System.Enum.GetName(typeof(CheckUpdateStatusCode), CheckUpdateStatusCode.HasNewVersion)
});
}
else
{
return(new CheckUpdateResponseDto()
{
FileId = data.FileId,
StatusCode = (HttpStatusCode)CheckUpdateStatusCode.CheckUpdate,
StatusText = System.Enum.GetName(typeof(CheckUpdateStatusCode), CheckUpdateStatusCode.CheckUpdate)
});
}
}
if (data.IsConfirm)
{
updatesExist = CheckFileForUpdates(fileTags, slideTags, data);
if (!isExcuted)
{
return(new CheckUpdateResponseDto()
{
StatusCode = HttpStatusCode.BadRequest,
StatusText = Message.ExcuteFailed
});
}
if (slideTags.Count > 0)
{
_downloadLatestVersion = true;
return(new
{
FileId = data.FileId,
StatusCode = 215,
Value = UpdateListOfSlides(slideTags)
});
}
updatesExist = slideTags.Count > 0;
showConfirmation = updatesExist;
}
else
{
showConfirmation = false;
}
}
else if (slideTags != null && slideTags.Count > 0)
{
data.FileId = slideTags.FirstOrDefault().File.Id.ToString();
if (data.AskFirst)
{
return(new CheckUpdateResponseDto()
{
FileId = data.FileId,
StatusCode = (HttpStatusCode)CheckUpdateStatusCode.CheckUpdate,
StatusText = System.Enum.GetName(typeof(CheckUpdateStatusCode), CheckUpdateStatusCode.CheckUpdate)
});
}
if (data.IsConfirm)
{
updatesExist = CheckSlidesForUpdates(slideTags, false, data);
if (!isExcuted)
{
return(new CheckUpdateResponseDto()
{
StatusCode = HttpStatusCode.BadRequest,
StatusText = Message.ExcuteFailed
});
}
if (slideTags.Count > 0)
{
_downloadLatestVersion = true;
return(new
{
FileId = data.FileId,
StatusCode = 215,
Value = UpdateListOfSlides(slideTags)
});
}
updatesExist = slideTags.Count > 0;
showConfirmation = updatesExist;
}
else
{
showConfirmation = false;
}
}
else
{
libraryContentManifest = XmlUtils.Deserialize <LibrarianContentManifest>(_filesService.GetCustomXmlPart(presentationPart));
if (libraryContentManifest != null)
{
data.FileName = libraryContentManifest.Filename;
data.FileId = libraryContentManifest.ContentId;
if (data.AskFirst)
{
return(new CheckUpdateResponseDto()
{
FileName = data.FileName,
FileId = data.FileId,
StatusCode = (HttpStatusCode)CheckUpdateStatusCode.HasNewVersion,
StatusText = System.Enum.GetName(typeof(CheckUpdateStatusCode), CheckUpdateStatusCode.HasNewVersion)
});
}
updatesExist = CheckManifestForUpdates(libraryContentManifest, data);
if (!isExcuted)
{
return(new CheckUpdateResponseDto()
{
StatusCode = HttpStatusCode.BadRequest,
StatusText = Message.ExcuteFailed
});
}
}
else
{
showConfirmation = false;
}
}
}
}
if (showConfirmation && !updatesExist)
{
return(new CheckUpdateResponseDto()
{
FileId = data.FileId,
StatusCode = (HttpStatusCode)CheckUpdateStatusCode.UptoDate,
StatusText = System.Enum.GetName(typeof(CheckUpdateStatusCode), CheckUpdateStatusCode.UptoDate)
});
}
if (updatesExist)
{
if (fileTags != null && _downloadLatestVersion)
{
_filesService.GetLatestFile(data);
}
else if (slideTags != null && slideTags.Count > 0)
{
return(new
{
FileId = data.FileId,
StatusCode = 215,
Value = UpdateListOfSlides(slideTags)
});
}
else if (libraryContentManifest != null)
{
return(new CheckUpdateResponseDto()
{
FileId = libraryContentManifest.ContentId,
StatusCode = (HttpStatusCode)CheckUpdateStatusCode.UpdatedAvailable,
StatusText = System.Enum.GetName(typeof(CheckUpdateStatusCode), CheckUpdateStatusCode.UpdatedAvailable)
});
}
}
return(updatesExist);
}
private bool CheckManifestForUpdates(LibrarianContentManifest librarianContentManifest, CheckUpdateDto fileInfo)
{
bool updatesExist = CheckContentForUpdates(librarianContentManifest.ContentType, DateTime.Parse(librarianContentManifest.LastModDate), fileInfo);
if (!updatesExist && (librarianContentManifest.ContentType == ContentType.GlobalFavorite || librarianContentManifest.ContentType == ContentType.MyFavorite))
{
foreach (var contentItem in librarianContentManifest.Items)
{
LibraryFileInfoEx libraryFileInfo = _filesService.GetFileInfo(fileInfo);
updatesExist = libraryFileInfo.LastModDate > DateTime.Parse(contentItem.LastModDate);
//if (!updatesExist && contentItem.EditItem != null)
//{
// SlidePreviewRequestEx slidePreviewRequestEx = session.LibrarianRpc.GetVirtualPresentationItemEdits(contentItem.EditItem.LinkId, contentItem.SlideId);
// updatesExist = slidePreviewRequestEx.LastModDate > contentItem.EditItem.LastModDate;
//}
if (updatesExist)
{
break; // exit loop
}
}
}
return(updatesExist);
}
