Dictionary RefreshDictionary(DictionaryInfo dictInfo, User user, Stream stream)
{
using (var db = new DictServiceEntities())
{
var dict = db.Dictionaries.Single(x => x.Dictionary_id == dictInfo.Dictionary_id.Value);
dict.DictionaryState = db.DictionaryStates.Single(x => x.State_id == (int)DictionaryStateEnum.Refreshing);
db.Entry(dict).State = EntityState.Modified;
var change = new UserChangeHistory()
{
Dictionary_id = dict.Dictionary_id,
Action_id = (int)ActionEnum.EditDict,
DateHistory = DateTime.Now,
User_id = user.User_id
};
db.UserChangeHistories.Add(change);
db.SaveChanges();
ExistDictFileProcessing(stream, dict, change);
dict.DictionaryState = db.DictionaryStates.Single(x => x.State_id == (int)DictionaryStateEnum.Available);
db.Entry(dict).State = EntityState.Modified;
db.SaveChanges();
AddNewQueue(dict.Dictionary_id, ActionEnum.EditDict, change.UserHistory_id);
return(dict);
}
}
public UploadResponse Upload(UploadRequest request)
{
try
{
DictionaryInfo dictInfo = request.DictInfo;
using (var db = new DictServiceEntities())
{
var user = db.Users.SingleOrDefault(x => x.Login == dictInfo.SenderLogin);
if (user == null)
{
user.Login = request.DictInfo.SenderLogin;
db.Users.Add(user);
db.SaveChanges();
}
//if (!CheckExtension(dictInfo.FileName, ".mdb"))
//{
// throw new NotSupportedException();
//}
if (!CheckPermission(user, dictInfo.Action))
{
throw new Exception("Нету прав!!!");
}
switch (dictInfo.Action)
{
case ActionEnum.AddDict:
{
AddNewDicionary(request.DictInfo, user, request.Stream);
break;
}
case ActionEnum.EditDict:
{
RefreshDictionary(request.DictInfo, user, request.Stream);
break;
}
}
return(new UploadResponse
{
UploadSucceeded = true
});
}
}
catch (DbEntityValidationException dbEx)
{
foreach (var validationErrors in dbEx.EntityValidationErrors)
{
foreach (var validationError in validationErrors.ValidationErrors)
{
Trace.TraceInformation("Property: {0} Error: {1}",
validationError.PropertyName,
validationError.ErrorMessage);
}
}
return(new UploadResponse
{
UploadSucceeded = false,
Error = dbEx.ToString()
});
}
}
int NewDictFileProcessing(Stream stream, string uploadPath, DictionaryInfo dictInfo)
{
var tmpFolder = FileHelper.GetTemporaryDirectory();
var tmpFile = Path.Combine(tmpFolder, dictInfo.FileName);
FileHelper.LoadFileFromStream(stream, tmpFile);
ZipHelper.UnZip(tmpFile);
var file = Directory.GetFiles(tmpFolder, "*.mdb").Single();
if (!dictInfo.Dictionary_id.HasValue)
{
using (var db = new DictServiceEntities())
{
var dict = new Dictionary()
{
FileName = dictInfo.FileName,
Category_id = dictInfo.Category_id,
Description = dictInfo.Description,
PathToDict = Path.Combine(uploadPath, dictInfo.FileName),
FriendlyName = dictInfo.FriendlyName
};
db.Dictionaries.Add(dict);
db.SaveChanges();
AccessHelper.SetDbStamp(file, dict.Dictionary_id);
dictInfo.Dictionary_id = dict.Dictionary_id;
}
}
ZipHelper.CreateZipDictionary(file, uploadPath);
return(dictInfo.Dictionary_id.Value);
}
public void ChangeDictionaryStatus(int dictionary_id, DictionaryStateEnum state)
{
using (var db = new DictServiceEntities())
{
var dict = db.Dictionaries.Single(x => x.Dictionary_id == dictionary_id);
dict.State_id = (int)state;
db.Entry(dict).State = EntityState.Modified;
db.SaveChanges();
}
}
public void AddCategory(string name, string description)
{
using (var db = new DictServiceEntities())
{
var category = new DictionaryCategory()
{
Name = name,
Description = description
};
db.DictionaryCategories.Add(category);
db.SaveChanges();
}
}
private void AddNewDicionary(DictionaryInfo dictInfo, User user, Stream stream)
{
string uploadPath = GetUploadPath(dictInfo.Category_id, dictInfo.FriendlyName, dictInfo.FileName);
// FileHelper.LoadFileFromStream(stream, uploadPath);
var id = NewDictFileProcessing(stream, uploadPath, dictInfo);
using (var db = new DictServiceEntities())
{
var change = new UserChangeHistory()
{
User_id = user.User_id,
Dictionary_id = id,
Action_id = (int)dictInfo.Action,
DateHistory = DateTime.Now
};
db.UserChangeHistories.Add(change);
db.SaveChanges();
}
}
void ExistDictFileProcessing(Stream stream, Dictionary dict, UserChangeHistory change)
{
var tmpFolder = FileHelper.GetTemporaryDirectory();
var tmpFile = Path.Combine(tmpFolder, Path.GetFileName(dict.FileName));
FileHelper.LoadFileFromStream(stream, tmpFile);
ZipHelper.UnZip(tmpFile);
var newFile = Directory.GetFiles(tmpFolder, "*.mdb").Single();
if (AccessHelper.CheckIdentifyInfo(newFile) == dict.Dictionary_id)
{
var unZipFoler = ZipHelper.UnZipToTempDir(dict.PathToDict);
var oldDict = Directory.GetFiles(unZipFoler, "*.mdb").Single();
var changes = DBComparer.CompareDataBase(newFile, oldDict);
if (changes.Any())
{
using (var db = new DictServiceEntities())
{
db.DictionaryChangeHistories.AddRange(changes.Select(x => new DictionaryChangeHistory()
{
UserHistory_id = change.UserHistory_id,
Change_id = (int)x.ChangeType,
Dictionary_id = dict.Dictionary_id,
TableName = x.TableName,
PrimaryKey = x.PrimaryKey,
ColumnName = x.ColumnName,
OldValue = x.OldValue,
NewValue = x.NewValue
}));
db.SaveChanges();
}
CreateDictionaryVersion(dict);
File.Move(tmpFile, dict.PathToDict);
}
}
else
{
throw new Exception("Попытка загрузить неизвестный словарь");
}
}
public void ChangeDictionaryInfo(DictionaryData dictData)
{
using (var db = new DictServiceEntities())
{//Проверка прав, запись в хистори
var dict = db.Dictionaries.Single(x => x.Dictionary_id == dictData.Dictionary_id);
if (dictData.Category_id != dict.Category_id || dictData.FriendlyName != dict.FriendlyName)
{
var categoryName = db.DictionaryCategories.Single(x => x.Category_id == dictData.Category_id).Name;
var newPath = TransferDictionary(dict.PathToDict, categoryName, dictData.FriendlyName);
var versions = db.Versions.Where(x => x.Dictionary_id == dict.Dictionary_id && x.DateDel == null).ToList();
if (versions.Any())
{
versions.ForEach(x => x.PathToVersion = x.PathToVersion.Replace(Path.GetDirectoryName(x.PathToVersion), newPath));
}
dict.PathToDict = dict.PathToDict.Replace(Path.GetDirectoryName(dict.PathToDict), newPath);
dict.Category_id = dictData.Category_id;
dict.FriendlyName = dictData.FriendlyName;
}
dict.Description = dictData.Description;
db.SaveChanges();
}
}
public void CreateDictionaryVersion(Dictionary dict)
{
using (var db = new DictServiceEntities())
{
string PathToVersions = Path.Combine(Path.GetDirectoryName(dict.PathToDict), "Versions");
string newFileName = DateTime.Now.ToString("yyyy-MM-dd hh-mm-ss_") + Path.GetFileName(dict.PathToDict);
if (!Directory.Exists(PathToVersions))
{
Directory.CreateDirectory(PathToVersions);
}
string dstPath = Path.Combine(PathToVersions, newFileName);
File.Copy(dict.PathToDict, dstPath);
File.Delete(dict.PathToDict);
var version = new Version()
{
Dictionary_id = dict.Dictionary_id,
PathToVersion = dstPath,
DateAdd = DateTime.Now
};
db.Versions.Add(version);
db.SaveChanges();
}
}
void AddNewQueue(int dictId, ActionEnum action, int changeId)
{
using (var db = new DictServiceEntities())
{
if (!db.DictionaryOnTasks.Any(x => x.Dictionary.Dictionary_id == dictId && x.DateDel == null))
{
return;
}
var result = db.DictionaryOnTasks.Where(x => x.Dictionary.Dictionary_id == dictId && x.DateDel == null);
foreach (var element in result)
{
var queue = new Queue()
{
Project_id = element.Project_id,
Server_id = element.Server_id,
Task = element.Task,
Action_id = (int)action,
UserHistory_id = changeId
};
db.Queues.Add(queue);
}
db.SaveChanges();
}
}
List <int> ApplyChanges(XDocument xml, int server_id, int project_id, int task_id)
{
List <int> dictIds = new List <int>();
int tmp;
var extensions =
xml.XPathSelectElements("*//Extenders/Ext[((contains(@Id,'SimpleDictionary') or contains(@Id,'ImportDictionary')) and @Event)]").Select(x => new
{
DictType = x.Attribute("Id").Value,
DictionaryOnTask_id = int.TryParse(x.Attribute("DictionaryOnTask_id").Value, out tmp) ? tmp : default(int?)
,
Dictionary_id = int.Parse(x.Attribute("Dictionary_id").Value),
Event = x.Attribute("Event")?.Value ?? "",
Ext = x
}).ToList();
using (var db = new DictServiceEntities())
{
foreach (var ext in extensions)
{
if (ext.Event == "")
{
ext.Ext.Attribute("Event").Remove();
continue;
}
if (ext.Event == "Add")
{
var dictOnTask = new DictionaryOnTask()
{
Dictionary_id = ext.Dictionary_id,
Server_id = server_id,
Project_id = project_id,
Task_id = task_id,
DateAdded = DateTime.Now,
DateSync = DateTime.Now
};
db.DictionaryOnTasks.Add(dictOnTask);
db.SaveChanges();
ext.Ext.Attribute("DictionaryOnTask_id").Value = dictOnTask.DictionaryOnTask_id.ToString();
ProcessingConnectionString(ext.Ext, ext.DictType, server_id, project_id, task_id, ext.Dictionary_id);
dictIds.Add(ext.Dictionary_id);
continue;
}
if (ext.Event == "Remove")
{
var dictOnTask = db.DictionaryOnTasks.Single(x => x.DictionaryOnTask_id == ext.Dictionary_id);
dictOnTask.DateDel = DateTime.Now;
ext.Ext.Remove();
continue;
}
if (ext.Event == "Change")
{
var dictOnTask = db.DictionaryOnTasks.Single(x => x.DictionaryOnTask_id == ext.Dictionary_id);
dictOnTask.Dictionary_id = ext.Dictionary_id;
ProcessingConnectionString(ext.Ext, ext.DictType, server_id, project_id, task_id, ext.Dictionary_id);
ext.Ext.Attribute("Event").Remove();
dictIds.Add(ext.Dictionary_id);
continue;
}
}
}
return(dictIds);
}
