private static int GetFreeOrder(int entityTypeId, int beginRange = 1)
{
// получить минимальное из неиспользуемых значений Order
var existingOrders = CustomActionRepository.GetActionOrdersForEntityType(entityTypeId).ToList();
return(existingOrders.Any() ? Enumerable.Range(beginRange, existingOrders.Max() + 1).Except(existingOrders).Min() : 1);
}
public CopyResult Copy(int id, int[] selectedActionsIds)
{
var result = new CopyResult();
var action = ReadForModify(id);
action.Id = 0;
if (action.Action != null)
{
action.Action.Id = 0;
}
if (action == null)
{
throw new Exception(string.Format(CustomActionStrings.ActionNotFoundByCode, id));
}
if (!action.IsUpdatable || !action.IsAccessible(ActionTypeCode.Read))
{
result.Message = MessageResult.Error(CustomActionStrings.CannotCopyBecauseOfSecurity);
}
if (result.Message == null)
{
action = Normalize(action, selectedActionsIds);
action = CustomActionRepository.Copy(action);
}
return(result);
}
public CustomAction ReadByCode(string code)
{
using (new QPConnectionScope(ConnectionString))
{
return(CustomActionRepository.GetByCode(code));
}
}
public ListResult <CustomActionListItem> List(ListCommand cmd)
{
var list = CustomActionRepository.List(cmd, out var totalRecords);
return(new ListResult <CustomActionListItem>
{
Data = list.ToList(),
TotalRecords = totalRecords
});
}
public CustomAction Read(int id)
{
var action = CustomActionRepository.GetById(id);
if (action == null)
{
throw new ApplicationException(string.Format(CustomActionStrings.ActionNotFound, id));
}
return(action);
}
public CustomAction Save(CustomAction customAction, int[] selectedActionsIds)
{
if (customAction == null)
{
throw new ArgumentNullException(nameof(customAction));
}
customAction = Normalize(customAction, selectedActionsIds);
customAction = CustomActionRepository.Save(customAction);
return(customAction);
}
public override void Validate()
{
var errors = new RulesException <CustomAction>();
base.Validate(errors);
if (Order < 0)
{
errors.ErrorFor(a => a.Order, CustomActionStrings.OrderIsNotInRange);
}
else if (Order > 0 && Action.EntityTypeId > 0 && !CustomActionRepository.IsOrderUnique(Id, Order, Action.EntityTypeId))
{
var freeOrder = GetFreeOrder(Action.EntityTypeId);
errors.ErrorFor(a => a.Order, string.Format(CustomActionStrings.OrderValueIsNotUniq, freeOrder));
}
if (Action.IsInterface && Action.IsWindow)
{
if (!Action.WindowHeight.HasValue)
{
errors.ErrorFor(a => a.Action.WindowHeight, CustomActionStrings.WindowHeightIsNotEntered);
}
else if (!Action.WindowHeight.Value.IsInRange(100, 1000))
{
errors.ErrorFor(a => a.Action.WindowHeight, string.Format(CustomActionStrings.WindowHeightIsNotInRange, 100, 1000));
}
if (!Action.WindowWidth.HasValue)
{
errors.ErrorFor(a => a.Action.WindowWidth, CustomActionStrings.WindowWidthIsNotEntered);
}
else if (!Action.WindowWidth.Value.IsInRange(100, 1000))
{
errors.ErrorFor(a => a.Action.WindowWidth, string.Format(CustomActionStrings.WindowWidthIsNotInRange, 100, 1000));
}
}
if (!UrlHelpers.IsValidUrl(Url))
{
errors.ErrorFor(a => a.Url, string.Format(CustomActionStrings.UrlInvalidFormat));
}
if (!UrlHelpers.IsValidUrl(IconUrl))
{
errors.ErrorFor(a => a.IconUrl, string.Format(CustomActionStrings.IconUrlInvalidFormat));
}
if (!errors.IsEmpty)
{
throw errors;
}
}
public CustomAction Update(CustomAction customAction, int[] selectedActionsIds)
{
if (customAction == null)
{
throw new ArgumentNullException(nameof(customAction));
}
if (!CustomActionRepository.Exists(customAction.Id))
{
throw new ApplicationException(string.Format(CustomActionStrings.ActionNotFound, customAction.Id));
}
customAction = Normalize(customAction, selectedActionsIds);
customAction = CustomActionRepository.Update(customAction);
return(customAction);
}
private async Task StartAfterReboot(AlarmerImplementation alarmer)
{
AlarmRepository _alarmRepo = new AlarmRepository();
TimingRepository _timingRepository = new TimingRepository();
CustomActionRepository _customActionRepository = new CustomActionRepository();
try
{
var alarmList = await _alarmRepo.GetListAsync();
if (alarmList != null && alarmList.Count > 0)
{
foreach (var alarm in alarmList)
{
var timings = await _timingRepository.QueryAsync().Where(w => w.AlarmId == alarm.Id).ToArrayAsync();
var customs = await _customActionRepository.QueryAsync().Where(w => w.AlarmId == alarm.Id).ToArrayAsync();
var alarmOption = new AlarmOptions
{
EndDate = alarm.EndDate,
AdditionalTimes = timings.Select(s => s.Time).ToArray(),
AlarmSequence = alarm.AlarmSequence,
DaysOfWeek = alarm.DaysOfWeek,
Interval = alarm.Interval,
TotalAlarmCount = alarm.TotalAlarmCount
};
var notification = new NotificationOptions
{
EnableSound = alarm.EnableSound,
EnableVibration = alarm.EnableVibration,
LargeIcon = alarm.LargeIcon,
SmallIcon = alarm.SmallIcon,
CustomActions = customs.Select(s => { return(new CustomAction {
Icon = s.Icon, Name = s.Name
}); }).ToArray()
};
alarmer.Schedule(alarm.Id, alarm.Title, alarm.Message, alarm.StartDate, alarmOption, notification, isNew: false);
}
}
}
catch (Exception)
{
}
}
public CustomActionPrepareResult PrepareForExecuting(string hostId, int parentId, CustomActionQuery query)
{
var action = CustomActionRepository.GetByCode(query.ActionCode);
var session = _repository.GetCurrent();
if (session == null)
{
throw new SecurityException("Session log record doesn't exist");
}
session.Sid = Guid.NewGuid().ToString();
_repository.Update(session);
action.SessionId = session.Sid;
action.Ids = query.Ids;
action.ParentId = parentId;
return(SecurityCheck(new CustomActionPrepareResult {
CustomAction = action
}, action, query.Ids));
}
public MessageResult Remove(int id)
{
CustomActionRepository.Delete(id);
return(null);
}
public static IEnumerable <BackendActionStatus> ResolveStatus(string entityTypeCode, int entityId, int parentEntityId, BackendActionStatus[] statuses)
{
var testEntityTypeCode = entityTypeCode != EntityTypeCode.VirtualArticle ? entityTypeCode : EntityTypeCode.VirtualContent;
var testEntityId = entityTypeCode != EntityTypeCode.VirtualArticle ? entityId : parentEntityId;
// Получить родительский контент и сайт
IEnumerable <EntityInfo> bindableParentEntities =
EntityObjectRepository.GetParentsChain(testEntityTypeCode, testEntityId)
.Where(ei =>
ei.Id > 0 &&
(
ei.Code.Equals(EntityTypeCode.Site, StringComparison.InvariantCultureIgnoreCase) ||
ei.Code.Equals(EntityTypeCode.Content, StringComparison.InvariantCultureIgnoreCase) ||
ei.Code.Equals(EntityTypeCode.VirtualContent, StringComparison.InvariantCultureIgnoreCase)
)
)
.ToArray();
var customActions = CustomActionRepository.GetListByCodes(statuses.Select(s => s.Code).ToArray());
// Если есть как минимум сайт - то проверяем
if (customActions.Any())
{
if (bindableParentEntities.Any())
{
var parentSiteInfo = bindableParentEntities.FirstOrDefault(ei => ei.Code.Equals(EntityTypeCode.Site, StringComparison.InvariantCultureIgnoreCase));
var parentContentInfo = bindableParentEntities.FirstOrDefault(ei => ei.Code.Equals(EntityTypeCode.Content, StringComparison.InvariantCultureIgnoreCase) ||
ei.Code.Equals(EntityTypeCode.VirtualContent, StringComparison.InvariantCultureIgnoreCase)
);
foreach (var ca in customActions)
{
var status = statuses.Single(s => s.Code.Equals(ca.Action.Code, StringComparison.InvariantCultureIgnoreCase));
if (status.Visible)
{
var visibleBySite = false;
var visibleByContent = false;
if (ca.Sites.Any(s => s.Id == parentSiteInfo.Id)) // сайт выбран для текущего Custom Action
{
visibleBySite = ca.SiteExcluded;
}
else
{
visibleBySite = !ca.SiteExcluded;
}
if (visibleBySite)
{
if (parentContentInfo != null)
{
if (ca.Contents.Any(c => c.Id == parentContentInfo.Id)) // контент выбран для текущего Custom Action
{
visibleByContent = ca.ContentExcluded;
}
//else if (!ca.Contents.Any())
// visibleByContent = true;
else
{
visibleByContent = !ca.ContentExcluded;
}
}
else
{
visibleByContent = visibleBySite;
}
}
// Побеждает всегда False если он есть
status.Visible = visibleBySite && visibleBySite == visibleByContent;
if (status.Visible && ca.Action.ExcludeCodes != null)
{
foreach (var code in ca.Action.ExcludeCodes)
{
var excludedStatus = statuses.SingleOrDefault(s => s.Code.Equals(code, StringComparison.InvariantCultureIgnoreCase));
if (excludedStatus != null)
{
excludedStatus.Visible = false;
}
}
}
}
}
}
else
{
foreach (var ca in customActions)
{
var status = statuses.Single(s => s.Code.Equals(ca.Action.Code, StringComparison.InvariantCultureIgnoreCase));
status.Visible = false;
}
}
}
return(statuses);
}
public AlarmerImplementation()
{
_alarmRepo = new AlarmRepository();
_timingRepository = new TimingRepository();
_customActionRepository = new CustomActionRepository();
}
