public int Update(ValidationSetting validationSetting)
{
using (var model = new gb_dvsstagingEntities())
{
val_validationsetting val_Setting = model.val_validationsetting.First(x => x.Id == validationSetting.Id);
val_Setting.Name = validationSetting.Name;
val_Setting.Description = validationSetting.Description;
val_Setting.PriorityId = validationSetting.PriorityId;
val_Setting.ProductId = validationSetting.ProductId;
val_Setting.Expression = validationSetting.Expression;
val_Setting.UpdatedBy = "Admin";
val_Setting.UpdatedOn = DateTime.UtcNow;
val_Setting.IsSlackEnabled = validationSetting.IsSlackEnabled;
val_Setting.SlackChannel = validationSetting.SlackChannel;
model.Entry(val_Setting).State = EntityState.Modified;
model.SaveChanges();
return(val_Setting.Id);
}
}
public int Update(ValidationRule validationRule)
{
using (var model = new gb_dvsstagingEntities())
{
val_validationrule val_Rule = model.val_validationrule.First(x => x.Id == validationRule.Id);
val_Rule.ValidationSettingId = validationRule.ValidationSettingId;
val_Rule.RuleName = validationRule.RuleName;
val_Rule.PropertyName = validationRule.PropertyName;
val_Rule.PropertyXPath = validationRule.PropertyName.Replace(".", "/");
val_Rule.OperatorId = validationRule.OperatorId;
val_Rule.ParameterId = validationRule.ParameterId;
val_Rule.UpdatedBy = "Admin";
val_Rule.UpdatedOn = DateTime.UtcNow;
val_Rule.IsTime = validationRule.IsTime;
val_Rule.IsForAllNodes = validationRule.IsForAllNodes;
SetValueByParameter(validationRule, val_Rule);
model.Entry(val_Rule).State = EntityState.Modified;
model.SaveChanges();
return(val_Rule.Id);
}
}
public int Insert(ValidationRule validationRule)
{
using (var model = new gb_dvsstagingEntities())
{
val_validationrule val_Rule = new val_validationrule()
{
ValidationSettingId = validationRule.ValidationSettingId,
RuleName = validationRule.RuleName,
PropertyName = validationRule.PropertyName,
PropertyXPath = validationRule.PropertyName.Replace(".", "/"),
ParameterId = validationRule.ParameterId,
OperatorId = validationRule.OperatorId,
CreatedBy = "Admin",
CreatedOn = DateTime.UtcNow,
IsTime = validationRule.IsTime,
IsForAllNodes = validationRule.IsForAllNodes,
IsActive = true
};
SetValueByParameter(validationRule, val_Rule);
model.val_validationrule.Add(val_Rule);
model.SaveChanges();
return(val_Rule.Id);
}
}
public int Insert(ValidationSetting validationSetting)
{
using (var model = new gb_dvsstagingEntities())
{
var val_valSetting = new val_validationsetting
{
Name = validationSetting.Name,
Description = validationSetting.Description,
PriorityId = validationSetting.PriorityId,
ProductId = validationSetting.ProductId,
Expression = validationSetting.Expression,
CreatedBy = "Admin",
CreatedOn = DateTime.UtcNow,
UpdatedBy = "Admin",
UpdatedOn = DateTime.UtcNow,
IsSlackEnabled = validationSetting.IsSlackEnabled,
SlackChannel = validationSetting.SlackChannel,
IsActive = true
};
model.val_validationsetting.Add(val_valSetting);
model.SaveChanges();
return(val_valSetting.Id);
}
}
public void Update(ProductTree productTree)
{
lock (thisLock)
{
string xmlText;
using (var textWriter = new StringWriter())
{
new XmlSerializer(typeof(TreeNode)).Serialize(textWriter, productTree.Tree.core.data);
xmlText = textWriter.ToString();
}
using (var model = new gb_dvsstagingEntities())
{
var productTreeModel = model.dvs_producttree.Find(productTree.Id);
productTreeModel.ProductId = productTree.ProductId;
productTreeModel.XmlText = xmlText;
productTreeModel.UpdatedOn = DateTime.UtcNow;
model.Entry(productTreeModel).State = System.Data.Entity.EntityState.Modified;
model.SaveChanges();
}
}
}
public void Insert(int productId, TreeNode treeNode)
{
lock (thisLock)
{
string xmlText;
using (var textWriter = new StringWriter())
{
new XmlSerializer(typeof(TreeNode)).Serialize(textWriter, treeNode);
xmlText = textWriter.ToString();
}
using (var model = new gb_dvsstagingEntities())
{
var productTree = new dvs_producttree
{
ProductId = productId,
XmlText = xmlText,
CreatedBy = "Admin",
IsActive = true
};
model.dvs_producttree.Add(productTree);
model.SaveChanges();
}
}
}
public void BulkUpdate(IList <ArrivalMessage> arrivalMessages)
{
lock (thisLock)
{
using (var model = new gb_dvsstagingEntities())
{
model.Database.CommandTimeout = 300;
foreach (ArrivalMessage arrivaleMessageIterator in arrivalMessages)
{
var val_message = model.dvs_arrivalmessage.Find(arrivaleMessageIterator.Id, arrivaleMessageIterator.ProductId);
if (val_message != null)
{
var arrivalMessage = arrivaleMessageIterator;
CopyFromTo(ref arrivalMessage, ref val_message);
model.Entry(val_message).State = EntityState.Modified;
}
}
model.SaveChanges();
}
}
}
public void Insert(SchedulerHistory history)
{
using (var model = new gb_dvsstagingEntities())
{
var newHistory = new dvs_schedulershistory
{
CreatedBy = history.CreatedBy,
CreatedOn = history.CreatedOn,
StartedOn = history.StartedOn,
FinishedOn = history.FinishedOn,
IsByError = history.IsByError,
ErrorMessage = history.ErrorMessage,
AdditionalInfo = history.AdditionalInfo,
ArrivalMessageId = history.ArrivalMessageId,
ProductId = history.ProductId,
Type = history.Type,
IsActive = true
};
model.dvs_schedulershistory.Add(newHistory);
model.SaveChanges();
}
}
public Event Insert(Event @event)
{
using (var model = new gb_dvsstagingEntities())
{
var newRecord = NewRepositoryEventFrom(@event);
model.dvs_event.Add(newRecord);
model.SaveChanges();
@event.Id = newRecord.Id;
return(@event);
}
}
/*
* public async void SaveHistoriesGroups(List<HistoriesGroup> groups)
* {
* using(var model = new gb_dvsstagingEntities())
* {
* // comment, because not saved is merged
* //model.Configuration.AutoDetectChangesEnabled = false;
* //model.Configuration.ValidateOnSaveEnabled = false;
* model.Database.CommandTimeout = CONNECTION_TIMEOUT;
*
* var eventIds = groups.Select(x => x.EventId).ToList();
* var historiesIds = new List<int>();
*
* foreach(var g in groups)
* {
* historiesIds.AddRange(g.EventHistories.Select(x => x.Id));
* }
*
* // save events xmls
* var eventsQuery = (from @event in model.dvs_event
* where @event.IsActive && eventIds.Contains(@event.EventId)
* select @event);
*
* var tasks = eventsQuery.ForEachAsync((@event) =>
* {
* var group = groups.Find(x => x.EventId == @event.EventId);
*
* if (group != null)
* {
* @event.XmlText = group.BaseEventXmlText;
* }
* });
*
* await Task.WhenAll(tasks);
*
* await model.SaveChangesAsync();
*
* // save as merged
* var historiesQuery = (from history in model.dvs_eventhistory
* where history.IsActive && history.IsMerged == false && historiesIds.Contains(history.Id)
* select history);
*
* tasks = historiesQuery.ForEachAsync((history) =>
* {
* history.IsActive = false;
* history.IsMerged = true;
* });
*
* await Task.WhenAll(tasks);
*
* await model.SaveChangesAsync();
* }
* }
*
* public List<HistoriesGroup> GetGroupsNotMergedByEvent(int count)
* {
* using (var model = new gb_dvsstagingEntities())
* {
* model.Configuration.AutoDetectChangesEnabled = false;
* model.Configuration.ValidateOnSaveEnabled = false;
* model.Database.CommandTimeout = CONNECTION_TIMEOUT;
*
* var histories = model.dvs_eventhistory
* .AsNoTracking()
* .Where(history => history.IsActive && history.IsMerged == false)
* .OrderBy(history=>history.CreatedOn)
* .Take(count)
* .ToList()
* .Select(NewEventHistoryFrom)
* .ToList();
*
* var groups = histories.GroupBy(rec => rec.EventId)
* .Select(rec => new HistoriesGroup
* {
* EventId = rec.Key,
* EventHistories = rec.Select(x => x).ToList()
* });
*
* var historiesGroups = groups as HistoriesGroup[] ?? groups.ToArray();
*
* var eventIds = historiesGroups.Select(x => x.EventId);
*
* var query = model.dvs_event
* .AsNoTracking()
* .Where(@event => @event.IsActive && eventIds.Contains(@event.EventId))
* .Select(x=> new { EventId = x.EventId, XmlText = x.XmlText});
*
* var events = query.ToList();
*
* foreach ( var group in historiesGroups)
* {
* foreach ( var @event in events)
* {
* if ( @event.EventId == group.EventId)
* {
* group.BaseEventXmlText = @event.XmlText;
* }
* }
* }
*
* return historiesGroups.Where(group=>group.BaseEventXmlText!=null).ToList();
* }
* }
*/
public EventHistory Insert(EventHistory history)
{
using (var model = new gb_dvsstagingEntities())
{
var newRecord = NewRepositoryEventHistoryFrom(history);
model.dvs_eventhistory.Add(newRecord);
model.SaveChanges();
history.Id = newRecord.Id;
return(history);
}
}
public void BulkInsert(List <ArrivalMessage> messages, string groupId)
{
lock (thisLock)
{
using (var model = new gb_dvsstagingEntities())
{
var repositoryMessages = messages.Select(x => NewRepositoryArrivalMessage(x, groupId));
model.dvs_arrivalmessage.AddRange(repositoryMessages);
model.SaveChanges();
}
}
}
public void SetDisabledBySetting(int settingId)
{
using (var entities = new gb_dvsstagingEntities())
{
var query = entities.val_validationresult
.Where(x => x.ValidationSettingId == settingId);
foreach (var valValidationresult in query)
{
valValidationresult.IsActive = false;
}
entities.SaveChanges();
}
}
public void UpdateLastValidateAtFor(List <int> settingsIds)
{
using (var model = new gb_dvsstagingEntities())
{
var q = model.val_validationsetting.Where(x => settingsIds.Contains(x.Id));
foreach (var valValidationsetting in q)
{
valValidationsetting.LastValidateAt = DateTime.UtcNow;
}
model.SaveChanges();
//return q;
}
}
public int Insert(ArrivalMessage arrivalMessage)
{
lock (thisLock)
{
using (var model = new gb_dvsstagingEntities())
{
var message = NewRepositoryArrivalMessage(arrivalMessage, "");
model.dvs_arrivalmessage.Add(message);
model.SaveChanges();
return(message.Id);
}
}
}
public void Update(ArrivalMessage arrivalMessage)
{
lock (thisLock)
{
using (var model = new gb_dvsstagingEntities())
{
var val_message = model.dvs_arrivalmessage.Find(arrivalMessage.Id, arrivalMessage.ProductId);
CopyFromTo(ref arrivalMessage, ref val_message);
model.Entry(val_message).State = EntityState.Modified;
model.SaveChanges();
}
}
}
public void Delete(int validationSettingId)
{
using (var model = new gb_dvsstagingEntities())
{
var setting = model.val_validationsetting.FirstOrDefault(s => s.Id == validationSettingId);
if (setting == null)
{
return;
}
setting.IsActive = false;
setting.UpdatedOn = DateTime.UtcNow;
setting.UpdatedBy = "Admin";
model.SaveChanges();
}
}
public void BulkInsertByCreatingHistories(IList <Event> inserting)
{
lock (this.thisLock)
{
List <long> eventsIds = GetListEventsIds();
using (var model = new gb_dvsstagingEntities())
{
model.Configuration.AutoDetectChangesEnabled = false;
model.Configuration.ValidateOnSaveEnabled = false;
model.Database.CommandTimeout = CONNECTION_TIMEOUT;
// will add by counter events
for (int i = 0; i <= inserting.Count() / INSERT_COUNT; i++)
{
var events = new List <dvs_event>();
var histories = new List <dvs_eventhistory>();
var subEvents = inserting.Skip(i * INSERT_COUNT).Take(INSERT_COUNT).ToList();
foreach (var @event in subEvents)
{
if (eventsIds.Any(eventId => @event.EventId == eventId))
{
// pass
}
else
{
events.Add(NewRepositoryEventFrom(@event));
}
histories.Add(EventHistoryRepository.NewRepositoryEventHistoryFrom(@event));
}
model.dvs_event.AddRange(events);
model.dvs_eventhistory.AddRange(histories);
model.SaveChanges();
}
}
}
}
public void Delete(int id)
{
using (var model = new gb_dvsstagingEntities())
{
var setting = model.val_validationrule.FirstOrDefault(s => s.Id == id);
if (setting == null)
{
return;
}
setting.IsActive = false;
setting.UpdatedOn = DateTime.UtcNow;
setting.UpdatedBy = "Admin";
model.Entry(setting).State = EntityState.Modified;
model.SaveChanges();
}
}
/*
* public void InsertValidationResults(List<val_validationresult> validationResults)
* {
* using (var model = new gb_dvsstagingEntities())
* {
* model.Configuration.AutoDetectChangesEnabled = false;
* model.Configuration.ValidateOnSaveEnabled = false;
* model.Database.CommandTimeout = ConnectionTimeout;
*
* /*
* var savingEventIds = validationResults.Select(x => x.EventId).Distinct().ToArray();
* var validationSettingIds = validationResults.Select(x => x.ValidationSettingId).Distinct().ToArray();
* var markets = validationResults.Select(x => x.Market).Distinct().ToArray();
* var providers = validationResults.Select(x => x.Provider).Distinct().ToArray();
*
*
* var dbEventIds = model.val_validationresult.AsNoTracking().Where(x => x.IsActive
* && validationResults.Any(y=> y.EventId == x.EventId
* && y.ValidationSettingId == x.ValidationSettingId
* && y.Market == x.Market
* && y.Provider == x.Provider))
* .Select(x => x.EventId)
* .ToArray();
*
* var insertingValidationResults = validationResults
* .Where(x => !dbEventIds.Contains(x.EventId));
*
* model.val_validationresult.AddRange(insertingValidationResults);
*
* model.SaveChanges();
* }
* }
*/
public List <int> DisableForSettingEvent(int productId, int settingId, int eventId)
{
using (var model = new gb_dvsstagingEntities())
{
var results = model.val_validationresult
.Where(x => x.ProductId == productId)
.Where(x => x.ValidationSettingId == settingId && x.EventId == eventId);
foreach (var valValidationresult in results)
{
valValidationresult.IsActive = false;
}
model.SaveChanges();
var ids = results.Select(x => x.Id).ToList();
return(ids);
}
}
public void BulkInsert(IList <Event> events, int?productId)
{
// lock (this.thisLock)
{
using (var entities = new gb_dvsstagingEntities())
{
// entities.Configuration.AutoDetectChangesEnabled = false;
entities.Configuration.ValidateOnSaveEnabled = false;
entities.Database.CommandTimeout = 300;
bool isChanged = false;
var eventsIds = events.Select(x => x.EventId).ToArray();
var allByEvents = entities.dvs_selectiontreeitem.Where(rec => rec.IsActive &&
eventsIds.Contains((long)rec.ParentId) &&
rec.ProductId == productId).ToList();
foreach (var @event in events)
{
isChanged = false;
var items = allByEvents.Where(rec => rec.ParentId == @event.EventId).ToList();
var market = items.FirstOrDefault(rec => rec.TypeId == 5 && rec.ExternalId == @event.MarketId);
if (@event.MarketNames != null && @event.MarketNames.Count > 0)
{
if (market == null)
{
market = NewRepositoryTreeItemBy(productId, 5, @event.EventId, @event.MarketId, @event.MarketNames);
// market = NewRepositoryTreeItemBy(productId, 5, eventName.Id, @event.MarketId, @event.MarketNames);
entities.dvs_selectiontreeitem.Add(market);
isChanged = true;
}
else
{
var originValues = market.Name.Split(',').ToList();
var newValues = @event.MarketNames;
market.Name = string.Join(",", originValues.Union(newValues).Distinct().ToList());
isChanged = true;
}
}// pass
var provider = items.FirstOrDefault(rec => rec.TypeId == 6 && rec.ExternalId == @event.ProviderId);
if (@event.ProviderNames != null && @event.ProviderNames.Count > 0)
{
if (provider == null)
{
//provider = NewRepositoryTreeItemBy(productId, 6, eventName.Id, @event.ProviderId, @event.ProviderNames);
provider = NewRepositoryTreeItemBy(productId, 6, @event.EventId, @event.ProviderId, @event.ProviderNames);
entities.dvs_selectiontreeitem.Add(provider);
isChanged = true;
}
else
{
var originValues = provider.Name.Split(',').ToList();
var newValues = @event.ProviderNames;
provider.Name = string.Join(",", originValues.Union(newValues).Distinct().ToList());
isChanged = true;
}
}// pass
var status = items.FirstOrDefault(rec => rec.TypeId == 7 && rec.ExternalId == @event.EventId);;
if (status == null)
{
// status = NewRepositoryTreeItemBy(productId, 7, eventName.Id, @event.EventId, new List<string> { @event.Status });
status = NewRepositoryTreeItemBy(productId, 7, @event.EventId, @event.EventId, new List <string> {
@event.Status
});
entities.dvs_selectiontreeitem.Add(status);
isChanged = true;
}// pass
if (isChanged)
{
entities.SaveChanges();
}
}
}
}
}
