public HttpResponseMessage SetCurrentCulture(Lite<CultureInfoEntity> culture)
{
var ci = ExecutionMode.Global().Using(_ => culture.Retrieve().ToCultureInfo());
if (UserEntity.Current != null) //Won't be used till next refresh
{
var user = UserEntity.Current.ToLite().Retrieve();
user.CultureInfo = culture.Retrieve();
using (AuthLogic.Disable())
using (OperationLogic.AllowSave<UserEntity>())
user.Save();
}
var resp = new HttpResponseMessage();
resp.Headers.AddCookies(new[]
{
new CookieHeaderValue("language", ci.Name)
{
Expires = DateTime.Now.AddMonths(6),
Domain = Request.RequestUri.Host,
Path = "/"
}
});
resp.StatusCode = HttpStatusCode.NoContent;
return resp;
}
public static int CountNotes(Lite<Entity> identifiable)
{
return Finder.QueryCount(new CountOptions(typeof(NoteEntity))
{
FilterOptions = { new FilterOption("Target", identifiable) }
});
}
public string[] EntityToStrings(Lite<Entity>[] lites)
{
if (lites == null || lites.Length == 0)
throw new ArgumentNullException(nameof(lites));
return lites.Select(a => Database.GetToStr(a.EntityType, a.Id)).ToArray();
}
public virtual void ChagePassword(Lite<UserEntity> user, byte[] passwordHash, byte[] newPasswordHash)
{
Execute(MethodInfo.GetCurrentMethod(), () =>
{
AuthLogic.ChangePassword(user, passwordHash, newPasswordHash);
});
}
public ActionResult LocalizableTypeUsedNotLocalized(Lite<RoleEntity> role)
{
if (role != null)
ViewBag.Role = role.InDB().Select(e => e.ToLite()).SingleEx();
return base.View(TranslationClient.ViewPrefix.FormatWith("LocalizableTypeUsedNotLocalized"), TranslationLogic.Occurrences);
}
private string GetDump(Lite<IEntity> target)
{
var entity = target.RetrieveAndForget();
using (CultureInfoUtils.ChangeBothCultures(Schema.Current.ForceCultureInfo))
return entity.Dump();
}
public static RuntimeInfoProxy FromLite(Lite<IEntity> lite)
{
return new RuntimeInfoProxy
{
EntityType = lite.EntityType,
IdOrNull = lite.IdOrNull,
IsNew = false,
Ticks = null,
};
}
public static int CountAlerts(Lite<Entity> identifiable, string filterField)
{
return Finder.QueryCount(new CountOptions(typeof(AlertEntity))
{
FilterOptions =
{
new FilterOption("Target", identifiable),
new FilterOption("Entity." + filterField, true)
},
});
}
public static byte[] ExecuteExcelReport(Lite<ExcelReportEntity> excelReport, QueryRequest request)
{
ResultTable queryResult = DynamicQueryManager.Current.ExecuteQuery(request);
ExcelReportEntity report = excelReport.RetrieveAndForget();
string extension = Path.GetExtension(report.File.FileName);
if (extension != ".xlsx")
throw new ApplicationException(ExcelMessage.ExcelTemplateMustHaveExtensionXLSXandCurrentOneHas0.NiceToString().FormatWith(extension));
return ExcelGenerator.WriteDataInExcelFile(queryResult, report.File.BinaryFile);
}
public ActionResult ExcelReport(QueryRequest request, Lite<ExcelReportEntity> excelReport)
{
if (!Finder.IsFindable(request.QueryName))
throw new UnauthorizedAccessException(NormalControlMessage.ViewForType0IsNotAllowed.NiceToString().FormatWith(request.QueryName));
byte[] file = ExcelLogic.ExecuteExcelReport(excelReport, request);
return File(file, MimeType.FromExtension(".xlsx"), Finder.ResolveWebQueryName(request.QueryName) + "-" + TimeZoneManager.Now.ToString("yyyyMMdd-HHmmss") + ".xlsx");
//Known Bug in IE: When the file dialog is shown, if Open is chosen the Excel will be broken as a result of IE automatically adding [1] to the name.
//There's not workaround for this, so either click on Save instead of Open, or use Firefox or Chrome
}
public DetailGridRowProxy AddRow(Lite<ProductEntity> product)
{
var buttons = this.Element.Parent().Child(a => a.Current.ClassName == "EntityButtons");
using (SearchWindowProxy sw = buttons.ChildById("btFind").ButtonInvokeCapture().ToSearchWindow())
{
sw.Search();
sw.SearchControl.GetRows().Single(a => a.Entity.Is(product)).Select();
sw.Ok();
}
return Rows().Last();
}
void DownloadDatabase_Loaded(object sender, RoutedEventArgs e)
{
estimation = Server.Return((IDisconnectedServer ds) => ds.GetDownloadEstimation(DisconnectedMachineEntity.Current));
pbGenerating.Minimum = 0;
pbGenerating.Maximum = 1;
currentLite = transferServer.BeginExportDatabase(UserEntity.Current.ToLite(), DisconnectedMachineEntity.Current);
timer.Tick += new EventHandler(timer_Tick);
timer.Interval = TimeSpan.FromSeconds(1);
timer.Start();
}
public ActionResult View(Lite<UserQueryEntity> lite, FindOptions findOptions, Lite<Entity> currentEntity)
{
UserQueryPermission.ViewUserQuery.AssertAuthorized();
UserQueryEntity uq = UserQueryLogic.RetrieveUserQuery(lite);
using (uq.EntityType == null ? null : CurrentEntityConverter.SetCurrentEntity(currentEntity.Retrieve()))
{
if (findOptions == null)
findOptions = uq.ToFindOptions();
else
findOptions.ApplyUserQuery(uq);
}
return Finder.SearchPage(this, findOptions);
}
public ViewResult View(Lite<DashboardEntity> panel, Lite<Entity> currentEntity)
{
DashboardPermission.ViewDashboard.AssertAuthorized();
var cp = DashboardLogic.RetrieveDashboard(panel);
if (cp.EntityType != null)
{
if (currentEntity == null)
throw new ArgumentNullException("currentEntity");
ViewData["currentEntity"] = currentEntity.Retrieve();
}
return View(DashboardClient.ViewPrefix.FormatWith("Dashboard"), cp);
}
public static MvcHtmlString LightEntityLine(this HtmlHelper helper, Lite<IIdentifiable> lite, bool isSearchEntity)
{
if (lite == null)
return MvcHtmlString.Empty;
if (lite.ToString() == null)
Database.FillToString(lite);
MvcHtmlString result = Navigator.IsNavigable(lite.EntityType, null, isSearchEntity) ?
helper.Href("",
lite.ToString(),
Navigator.NavigateRoute(lite),
HttpUtility.HtmlEncode(EntityControlMessage.View.NiceToString()),
"", null) :
lite.ToString().EncodeHtml();
return result;
}
void DownloadDatabase_Loaded(object sender, RoutedEventArgs e)
{
estimation = Server.Return((IDisconnectedServer ds) => ds.GetUploadEstimation(DisconnectedMachineEntity.Current));
UploadDatabase().ContinueWith(cl =>
{
pbUploading.Dispatcher.BeginInvoke(() =>
{
currentLite = cl.Result;
pbImporting.Minimum = 0;
pbImporting.Maximum = 1;
timer.Tick += new EventHandler(timer_Tick);
timer.Interval = TimeSpan.FromSeconds(1);
timer.Start();
});
});
}
public ActionResult Index(Lite<RoleEntity> role)
{
var cultures = TranslationLogic.CurrentCultureInfos(CultureInfo.GetCultureInfo("en"));
var assemblies = AssembliesToLocalize().ToDictionary(a => a.FullName);
var dg = DirectedGraph<Assembly>.Generate(assemblies.Values, a => a.GetReferencedAssemblies().Select(an => assemblies.TryGetC(an.FullName)).NotNull());
var dic = dg.CompilationOrderGroups().SelectMany(gr => gr.OrderBy(a => a.FullName)).ToDictionary(a => a,
a => cultures.Select(ci => new TranslationFile
{
Assembly = a,
CultureInfo = ci,
IsDefault = ci.Name == a.GetCustomAttribute<DefaultAssemblyCultureAttribute>().DefaultCulture,
FileName = LocalizedAssembly.TranslationFileName(a, ci)
}).ToDictionary(tf => tf.CultureInfo));
if (role != null)
ViewBag.Role = role.InDB().Select(e => e.ToLite()).SingleEx();
return base.View(TranslationClient.ViewPrefix.FormatWith("Index"), dic);
}
public static MvcHtmlString LightEntityLine(this HtmlHelper helper, Lite<IEntity> lite, bool isSearch, bool targetBlank = true, string innerText = null)
{
if (lite == null)
return MvcHtmlString.Empty;
if (lite.ToString() == null)
Database.FillToString(lite);
if (!Navigator.IsNavigable(lite.EntityType, null, isSearch))
return (innerText ?? lite.ToString()).EncodeHtml();
Dictionary<string, object> htmlAtributes = new Dictionary<string, object>();
if (targetBlank)
htmlAtributes.Add("target", "_blank");
if (!Navigator.EntitySettings(lite.EntityType).AvoidPopup)
htmlAtributes.Add("data-entity-link", lite.Key());
return helper.Href("",
innerText ?? lite.ToString(),
Navigator.NavigateRoute(lite),
HttpUtility.HtmlEncode(lite.ToString()),
"sf-light-entity-line", htmlAtributes);
}
public static void ChangePassword(Lite<UserEntity> user, byte[] passwordHash, byte[] newPasswordHash)
{
var userEntity = user.RetrieveAndForget();
userEntity.PasswordHash = newPasswordHash;
using (AuthLogic.Disable())
userEntity.Execute(UserOperation.Save);
}
internal static string Comment(Lite <RoleEntity> role, TypeEntity resource, TypeAllowed from, TypeAllowed to)
{
return("{0} {1} for {2} ({3} -> {4})".FormatWith(typeof(TypeEntity).NiceName(), resource.ToString(), role, from, to));
}
static bool RoleTracked(Lite <RoleEntity> role)
{
return(SessionLogPermission.TrackSession.IsAuthorized(role));
}
public static Color?ColorFor(Lite <Entity> lite)
{
return(ColorFor(lite.EntityType, lite.Id));
}
protected internal override Expression VisitLiteValue(LiteValueExpression lite)
{
var id = Visit(NullifyColumn(lite.Id));
if (id == null)
{
return(Expression.Constant(null, lite.Type));
}
var toStr = Visit(lite.ToStr);
var typeId = lite.TypeId;
var toStringOrNull = toStr ?? Expression.Constant(null, typeof(string));
Expression nothing = Expression.Constant(null, lite.Type);
Expression liteConstructor;
if (typeId is TypeEntityExpression tee)
{
Type type = tee.TypeValue;
liteConstructor = Expression.Condition(Expression.NotEqual(id, NullId),
Expression.Convert(Lite.NewExpression(type, id, toStringOrNull), lite.Type),
nothing);
}
else if (typeId is TypeImplementedByExpression tib)
{
liteConstructor = tib.TypeImplementations.Aggregate(nothing,
(acum, ti) =>
{
var visitId = Visit(NullifyColumn(ti.Value));
return(Expression.Condition(Expression.NotEqual(visitId, NullId),
Expression.Convert(Lite.NewExpression(ti.Key, visitId, toStringOrNull), lite.Type), acum));
});
}
else if (typeId is TypeImplementedByAllExpression tiba)
{
var tid = Visit(NullifyColumn(tiba.TypeColumn));
liteConstructor = Expression.Convert(Expression.Call(miLiteCreateParse, Expression.Constant(Schema.Current), tid, id.UnNullify(), toStringOrNull), lite.Type);
}
else
{
liteConstructor = Expression.Condition(Expression.NotEqual(id.Nullify(), NullId),
Expression.Convert(Expression.Call(miLiteCreate, Visit(typeId), id.UnNullify(), toStringOrNull), lite.Type),
nothing);
}
if (toStr != null)
{
return(Expression.Call(retriever, miModifiablePostRetrieving.MakeGenericMethod(typeof(LiteImp)), liteConstructor.TryConvert(typeof(LiteImp))).TryConvert(liteConstructor.Type));
}
else
{
return(Expression.Call(retriever, miRequestLite.MakeGenericMethod(Lite.Extract(lite.Type) !), liteConstructor));
}
}
public TranslatedSummaryState Status(Lite<RoleEntity> role)
{
if (!System.IO.File.Exists(FileName))
return TranslatedSummaryState.None;
var target = DescriptionManager.GetLocalizedAssembly(Assembly, CultureInfo);
CultureInfo defaultCulture = CultureInfo.GetCultureInfo(Assembly.GetCustomAttribute<DefaultAssemblyCultureAttribute>().DefaultCulture);
var master = DescriptionManager.GetLocalizedAssembly(Assembly, defaultCulture);
var result = TranslationSynchronizer.GetMergeChanges(target, master, new List<LocalizedAssembly>());
if (result.Any(r => role == null || TranslationLogic.GetCountNotLocalizedMemebers(role, CultureInfo, r.Type.Type) > 0))
return TranslatedSummaryState.Pending;
return TranslatedSummaryState.Completed;
}
public ActionResult Queries(Lite<RoleEntity> role, Lite<TypeEntity> type)
{
return this.PopupNavigate(QueryAuthLogic.GetQueryRules(role.FillToString(), type.Retrieve()));
}
public static RuleTypeEntity ToRuleType(this TypeAllowedAndConditions allowed, Lite <RoleEntity> role, TypeEntity resource)
{
return(new RuleTypeEntity
{
Role = role,
Resource = resource,
Allowed = allowed.Fallback.Value,
Conditions = allowed.Conditions.Select(a => new RuleTypeConditionEmbedded
{
Allowed = a.Allowed,
Condition = a.TypeCondition
}).ToMList()
});
}
public static DebugData IsAllowedForDebug(this Lite <IEntity> lite, TypeAllowedBasic allowed, bool inUserInterface)
{
return(miIsAllowedForDebugLite.GetInvoker(lite.EntityType).Invoke(lite, allowed, inUserInterface));
}
public static bool IsAllowedFor(this Lite <IEntity> lite, TypeAllowedBasic allowed)
{
return(IsAllowedFor(lite, allowed, ExecutionMode.InUserInterface));
}
public static void AssertAllowed(this Lite <IEntity> lite, TypeAllowedBasic allowed)
{
AssertAllowed(lite, allowed, ExecutionMode.InUserInterface);
}
public Func <Type, TypeAllowedAndConditions> MergeDefault(Lite <RoleEntity> role)
{
var taac = new TypeAllowedAndConditions(AuthLogic.GetDefaultAllowed(role) ? TypeAllowed.Write : TypeAllowed.None);
return(new ConstantFunctionButEnums(taac).GetValue);
}
public virtual Func <K, A, A> GetCoerceValue(Lite <RoleEntity> role)
{
return((key, allowed) => allowed);
}
internal static int Rank(Lite<RoleEntity> role)
{
return roles.Value.IndirectlyRelatedTo(role).Count;
}
public ViewResult Permissions(Lite<RoleEntity> role)
{
return Navigator.NormalPage(this, PermissionAuthLogic.GetPermissionRules(role.FillToString()));
}
public List <Lite <IWorkflowNodeEntity> > FindNode([Required, FromBody] WorkflowFindNodeRequest request)
{
var workflow = Lite.Create <WorkflowEntity>(request.workflowId);
return(WorkflowLogic.AutocompleteNodes(workflow, request.subString, request.count, request.excludes));
}
public UserQueryQuickLink(Lite<UserQueryEntity> userQuery, Lite<Entity> entity)
{
this.ToolTip = userQuery.ToString();
this.Label = userQuery.ToString();
this.userQuery = userQuery;
this.entity = entity;
this.Icon = ExtensionsImageLoader.GetImageSortName("userQuery.png");
this.IsVisible = true;
}
public CaseFlow GetCaseFlow(string caseId)
{
var lite = Lite.ParsePrimaryKey <CaseEntity>(caseId);
return(CaseFlowLogic.GetCaseFlow(lite.RetrieveAndRemember()));
}
public static ProcessEntity SendMultipleEmailsAsync(Lite <EmailTemplateEntity> template, List <Lite <Entity> > targets, ModelConverterSymbol converter)
{
return(ProcessLogic.Create(EmailMessageProcess.CreateEmailsSendAsync, new PackageEntity {
OperationArgs = new object[] { template, converter }
}.CreateLines(targets)));
}
public List <CaseTagTypeEntity> GetTags(string caseId)
{
var lite = Lite.ParsePrimaryKey <CaseEntity>(caseId);
return(Database.Query <CaseTagEntity>().Where(a => a.Case == lite).Select(a => a.TagType).ToList());
}
private static DateTime?SaveEmail(Pop3ConfigurationEntity config, Pop3ReceptionEntity reception, IPop3Client client, MessageUid mi)
{
DateTime?sent = null;
{
using (OperationLogic.AllowSave <EmailMessageEntity>())
using (Transaction tr = Transaction.ForceNew())
{
string rawContent = null;
try
{
var email = client.GetMessage(mi, reception.ToLite());
email.Subject = email.Subject == null ? "No Subject" : email.Subject.Replace('\n', ' ').Replace('\r', ' ');
if (email.Recipients.IsEmpty())
{
email.Recipients.Add(new EmailRecipientEntity
{
EmailAddress = config.Username,
Kind = EmailRecipientKind.To,
});
}
Lite <EmailMessageEntity> duplicate = Database.Query <EmailMessageEntity>()
.Where(a => a.BodyHash == email.BodyHash)
.Select(a => a.ToLite())
.FirstOrDefault();
if (duplicate != null && AreDuplicates(email, duplicate.Retrieve()))
{
var dup = duplicate.Entity;
email.AssignEntities(dup);
AssociateDuplicateEmail?.Invoke(email, dup);
}
else
{
AssociateNewEmail?.Invoke(email);
}
email.Save();
sent = email.Mixin <EmailReceptionMixin>().ReceptionInfo.SentDate;
tr.Commit();
}
catch (Exception e)
{
e.Data["rawContent"] = rawContent;
var ex = e.LogException();
using (Transaction tr2 = Transaction.ForceNew())
{
new Pop3ReceptionExceptionEntity
{
Exception = ex.ToLite(),
Reception = reception.ToLite()
}.Save();
tr2.Commit();
}
}
}
}
return(sent);
}
public virtual long Ticks(Lite <Entity> entity)
{
return(Return(MethodInfo.GetCurrentMethod(),
() => entity.InDB(e => e.Ticks)));
}
public static SMSMessageEntity CreateSMSMessage(Lite <SMSTemplateEntity> template, Entity entity, ISMSModel?model, CultureInfo?forceCulture)
{
var t = SMSLogic.SMSTemplatesLazy.Value.GetOrThrow(template);
var defaultCulture = SMSLogic.Configuration.DefaultCulture.ToCultureInfo();
var qd = QueryLogic.Queries.QueryDescription(t.Query.ToQueryName());
List <QueryToken> tokens = new List <QueryToken>();
t.ParseData(qd);
tokens.Add(t.To.Token);
var parsedNodes = t.Messages.ToDictionary(
tm => tm.CultureInfo.ToCultureInfo(),
tm => TextTemplateParser.Parse(tm.Message, qd, t.Model?.ToType())
);
parsedNodes.Values.ToList().ForEach(n => n.FillQueryTokens(tokens));
var columns = tokens.Distinct().Select(qt => new Column(qt, null)).ToList();
var filters = model != null?model.GetFilters(qd) :
new List <Filter>
{
new FilterCondition(QueryUtils.Parse("Entity", qd, 0), FilterOperation.EqualTo, entity.ToLite())
};
var table = QueryLogic.Queries.ExecuteQuery(new QueryRequest
{
QueryName = qd.QueryName,
Columns = columns,
Pagination = model?.GetPagination() ?? new Pagination.All(),
Filters = filters,
Orders = model?.GetOrders(qd) ?? new List <Order>(),
});
var columnTokens = table.Columns.ToDictionary(a => a.Column.Token);
var ownerData = (SMSOwnerData)table.Rows[0][columnTokens.GetOrThrow(t.To.Token)] !;
var ci = forceCulture ?? ownerData.CultureInfo?.ToCultureInfo() ?? defaultCulture;
var node = parsedNodes.TryGetC(ci) ?? parsedNodes.GetOrThrow(defaultCulture);
return(new SMSMessageEntity
{
Template = t.ToLite(),
Message = node.Print(new TextTemplateParameters(entity, ci, columnTokens, table.Rows)
{
Model = model
}),
From = t.From,
EditableMessage = t.EditableMessage,
State = SMSMessageState.Created,
Referred = ownerData.Owner,
DestinationNumber = ownerData.TelephoneNumber,
Certified = t.Certified
});
}
public override Lite <T>?Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options, Lite <T>?existingValue)
{
if (reader.TokenType == JsonTokenType.Null)
{
return(null);
}
reader.Assert(JsonTokenType.StartObject);
string?toString = null;
string?idObj = null;
string?typeStr = null;
Entity?entity = null;
reader.Read();
while (reader.TokenType == JsonTokenType.PropertyName)
{
var propName = reader.GetString();
switch (propName)
{
case "toStr": reader.Read(); toString = reader.GetString(); break;
case "id":
{
reader.Read();
idObj =
reader.TokenType == JsonTokenType.Null ? null :
reader.TokenType == JsonTokenType.String ? reader.GetString() :
reader.TokenType == JsonTokenType.Number ? reader.GetInt64().ToString() :
reader.TokenType == JsonTokenType.True ? true.ToString() :
reader.TokenType == JsonTokenType.False ? false.ToString() :
throw new UnexpectedValueException(reader.TokenType);
break;
}
case "EntityType": reader.Read(); typeStr = reader.GetString(); break;
case "entity":
using (EntityJsonConverterFactory.SetPath(".entity"))
{
reader.Read();
var converter = (JsonConverterWithExisting <Entity>)options.GetConverter(typeof(Entity));
entity = converter.Read(ref reader, typeof(Entity), options, (Entity?)(IEntity?)existingValue?.EntityOrNull);
}
break;
default: throw new JsonException("unexpected property " + propName);
}
reader.Read();
}
reader.Assert(JsonTokenType.EndObject);
Type type = TypeLogic.GetType(typeStr !);
PrimaryKey?idOrNull = idObj == null ? (PrimaryKey?)null : PrimaryKey.Parse(idObj, type);
if (entity == null)
{
return((Lite <T>)Lite.Create(type, idOrNull !.Value, toString !));
}
var result = (Lite <T>)entity.ToLiteFat(toString);
if (result.EntityType != type)
{
throw new InvalidOperationException("Types don't match");
}
if (result.IdOrNull != idOrNull)
{
throw new InvalidOperationException("Id's don't match");
}
var existing = existingValue as Lite <T>;
if (existing.Is(result) && existing !.EntityOrNull == null && result.EntityOrNull != null)
{
existing.SetEntity((Entity)(IEntity)result.EntityOrNull);
return(existing);
}
return(result);
}
TypeAllowedAndConditions IManualAuth <Type, TypeAllowedAndConditions> .GetAllowed(Lite <RoleEntity> role, Type key)
{
TypeEntity resource = TypeLogic.TypeToEntity[key];
ManualResourceCache miniCache = new ManualResourceCache(resource, merger);
return(miniCache.GetAllowed(role));
}
public TypeAllowedAndConditions GetAllowedBase(Lite <RoleEntity> role)
{
IEnumerable <Lite <RoleEntity> > related = AuthLogic.RelatedTo(role);
return(merger.Merge(resource.ToType(), role, related.Select(r => KVP.Create(r, GetAllowed(r)))));
}
internal TypeAllowedAndConditions GetAllowedBase(Lite <RoleEntity> role, Type key)
{
return(runtimeRules.Value[role].GetAllowedBase(key));
}
public override JsonConverter?CreateConverter(Type typeToConvert, JsonSerializerOptions options)
{
return((JsonConverter)Activator.CreateInstance(typeof(LiteJsonConverter <>).MakeGenericType(Lite.Extract(typeToConvert) !)) !);
}
public static HashSet<Lite<RoleEntity>> RolesFromRole(Lite<RoleEntity> role)
{
return roles.Value.IndirectlyRelatedTo(role, true);
}
public LocalizedInstanceKey(PropertyRoute route, Lite <Entity> instance, PrimaryKey?rowId)
{
this.Route = route ?? throw new ArgumentNullException(nameof(route));
this.Instance = instance ?? throw new ArgumentNullException("entity");
this.RowId = rowId;
}
public static int Compare(Lite<RoleEntity> role1, Lite<RoleEntity> role2)
{
if (roles.Value.IndirectlyRelatedTo(role1).Contains(role2))
return 1;
if (roles.Value.IndirectlyRelatedTo(role2).Contains(role1))
return -1;
return 0;
}
public static PredictorTrainingContext?GetTrainingContext(Lite <PredictorEntity> lite)
{
return(Trainings.TryGetC(lite)?.Context);
}
public ViewResult Types(Lite<RoleEntity> role)
{
return Navigator.NormalPage(this, TypeAuthLogic.GetTypeRules(role.FillToString()));
}
public void AutoComplete(Lite <IEntity> lite)
{
base.AutoCompleteWaitChanges(AutoCompleteElement.Find(), lite);
}
static IDisposable Manager_RetrievingForView(Lite<Entity> lite)
{
return ViewLogLogic.LogView(lite, "WebRetrieve");
}
public override void Execute()
{
#line 6 "..\..\Signum\Views\SearchResults.cshtml"
QueryDescription queryDescription = (QueryDescription)ViewData[ViewDataKeys.QueryDescription];
var entityColumn = queryDescription.Columns.SingleEx(a => a.IsEntity);
Implementations implementations = entityColumn.Implementations.Value;
bool navigable = (bool)ViewData[ViewDataKeys.Navigate] && (implementations.IsByAll ? true : implementations.Types.Any(t => Navigator.IsNavigable(t, null, isSearch: true)));
bool allowSelection = (bool)ViewData[ViewDataKeys.AllowSelection];
RowAttributes rowAttributes = (RowAttributes)ViewData[ViewDataKeys.RowAttributes];
QueryRequest queryRequest = (QueryRequest)ViewData[ViewDataKeys.QueryRequest];
ResultTable queryResult = (ResultTable)ViewData[ViewDataKeys.Results];
Dictionary <int, CellFormatter> formatters = (Dictionary <int, CellFormatter>)ViewData[ViewDataKeys.Formatters];
EntityFormatter entityFormatter = (EntityFormatter)ViewData[ViewDataKeys.EntityFormatter];
int columnsCount = queryResult.Columns.Count() + (navigable ? 1 : 0) + (allowSelection ? 1 : 0);
#line default
#line hidden
WriteLiteral("\r\n\r\n");
#line 21 "..\..\Signum\Views\SearchResults.cshtml"
if (ViewData.ContainsKey(ViewDataKeys.MultipliedMessage))
{
#line default
#line hidden
WriteLiteral(" <tr");
WriteLiteral(" class=\"extract\"");
WriteLiteral(">\r\n <td>\r\n <div");
WriteLiteral(" class=\"sf-td-multiply alert alert-warning\"");
WriteLiteral(">\r\n <span");
WriteLiteral(" class=\"glyphicon glyphicon-exclamation-sign\"");
WriteLiteral("></span>\r\n");
WriteLiteral(" ");
#line 27 "..\..\Signum\Views\SearchResults.cshtml"
Write(ViewData[ViewDataKeys.MultipliedMessage]);
#line default
#line hidden
WriteLiteral("\r\n </div>\r\n </td>\r\n </tr>\r\n");
#line 31 "..\..\Signum\Views\SearchResults.cshtml"
}
#line default
#line hidden
WriteLiteral("\r\n");
#line 33 "..\..\Signum\Views\SearchResults.cshtml"
foreach (var row in queryResult.Rows)
{
Lite <IEntity> entityField = row.Entity;
#line default
#line hidden
WriteLiteral(" <tr");
WriteLiteral(" data-entity=\"");
#line 36 "..\..\Signum\Views\SearchResults.cshtml"
Write(entityField?.Key() ?? "");
#line default
#line hidden
WriteLiteral("\"");
WriteLiteral(" ");
#line 36 "..\..\Signum\Views\SearchResults.cshtml"
Write(rowAttributes == null ? null : rowAttributes(Html, row));
#line default
#line hidden
WriteLiteral(">\r\n");
#line 37 "..\..\Signum\Views\SearchResults.cshtml"
#line default
#line hidden
#line 37 "..\..\Signum\Views\SearchResults.cshtml"
if (allowSelection)
{
#line default
#line hidden
WriteLiteral(" <td");
WriteLiteral(" style=\"text-align:center\"");
WriteLiteral(">");
#line 39 "..\..\Signum\Views\SearchResults.cshtml"
if (entityField != null)
{
#line default
#line hidden
#line 41 "..\..\Signum\Views\SearchResults.cshtml"
Write(Html.CheckBox(Model.Compose("rowSelection", row.Index.ToString()),
new
{
@class = "sf-td-selection",
value = entityField.Id.ToString() + "__" + Navigator.ResolveWebTypeName(entityField.EntityType) + "__" + entityField.ToString()
}));
#line default
#line hidden
#line 46 "..\..\Signum\Views\SearchResults.cshtml"
}
#line default
#line hidden
WriteLiteral("</td>\r\n");
#line 48 "..\..\Signum\Views\SearchResults.cshtml"
}
#line default
#line hidden
WriteLiteral(" ");
#line 49 "..\..\Signum\Views\SearchResults.cshtml"
if (navigable)
{
#line default
#line hidden
WriteLiteral(" <td>");
#line 51 "..\..\Signum\Views\SearchResults.cshtml"
if (entityField != null)
{
#line default
#line hidden
#line 53 "..\..\Signum\Views\SearchResults.cshtml"
Write((entityFormatter ?? QuerySettings.EntityFormatRules.Last(fr => fr.IsApplyable(row)).Formatter)(Html, row));
#line default
#line hidden
#line 53 "..\..\Signum\Views\SearchResults.cshtml"
}
#line default
#line hidden
WriteLiteral("</td>\r\n");
#line 55 "..\..\Signum\Views\SearchResults.cshtml"
}
#line default
#line hidden
WriteLiteral(" ");
#line 56 "..\..\Signum\Views\SearchResults.cshtml"
foreach (var col in queryResult.Columns.Where(a => a.Column.IsVisible))
{
var value = row[col];
var ft = formatters[col.Index];
#line default
#line hidden
WriteLiteral(" <td ");
#line 61 "..\..\Signum\Views\SearchResults.cshtml"
Write(ft.WriteDataAttribute(value));
#line default
#line hidden
WriteLiteral(" style=\"");
#line 61 "..\..\Signum\Views\SearchResults.cshtml"
Write(ft.TextAlign == null ? null : "text-align:" + ft.TextAlign);
#line default
#line hidden
WriteLiteral("\">");
#line 61 "..\..\Signum\Views\SearchResults.cshtml"
Write(ft.Formatter(Html, value));
#line default
#line hidden
WriteLiteral("</td>\r\n");
#line 62 "..\..\Signum\Views\SearchResults.cshtml"
}
#line default
#line hidden
WriteLiteral(" </tr>\r\n");
#line 64 "..\..\Signum\Views\SearchResults.cshtml"
}
#line default
#line hidden
WriteLiteral("\r\n");
#line 66 "..\..\Signum\Views\SearchResults.cshtml"
if (queryResult.Rows.IsNullOrEmpty())
{
#line default
#line hidden
WriteLiteral(" <tr>\r\n <td");
WriteAttribute("colspan", Tuple.Create(" colspan=\"", 2945), Tuple.Create("\"", 2968)
#line 69 "..\..\Signum\Views\SearchResults.cshtml"
, Tuple.Create(Tuple.Create("", 2955), Tuple.Create <System.Object, System.Int32>(columnsCount
#line default
#line hidden
, 2955), false)
);
WriteLiteral(">");
#line 69 "..\..\Signum\Views\SearchResults.cshtml"
Write(SearchMessage.NoResultsFound.NiceToString());
#line default
#line hidden
WriteLiteral("</td>\r\n </tr>\r\n");
#line 71 "..\..\Signum\Views\SearchResults.cshtml"
}
#line default
#line hidden
WriteLiteral("\r\n");
#line 73 "..\..\Signum\Views\SearchResults.cshtml"
ViewData[ViewDataKeys.Pagination] = queryResult.Pagination;
#line default
#line hidden
WriteLiteral(" <tr");
WriteLiteral(" class=\"extract\"");
WriteLiteral(">\r\n <td>\r\n");
WriteLiteral(" ");
#line 78 "..\..\Signum\Views\SearchResults.cshtml"
Write(Html.Partial(Finder.Manager.PaginationSelectorView, Model));
#line default
#line hidden
WriteLiteral("\r\n </td>\r\n </tr>\r\n");
#line 81 "..\..\Signum\Views\SearchResults.cshtml"
#line default
#line hidden
WriteLiteral("\r\n");
}
public ActionResult Sync(string assembly, string culture, bool translatedOnly, Lite<RoleEntity> role)
{
Assembly ass = AssembliesToLocalize().Where(a => a.GetName().Name == assembly).SingleEx(() => "Assembly {0}".FormatWith(assembly));
CultureInfo targetCulture = CultureInfo.GetCultureInfo(culture);
CultureInfo defaultCulture = CultureInfo.GetCultureInfo(ass.GetCustomAttribute<DefaultAssemblyCultureAttribute>().DefaultCulture);
Dictionary<CultureInfo, LocalizedAssembly> reference = (from ci in TranslationLogic.CurrentCultureInfos(defaultCulture)
let la = DescriptionManager.GetLocalizedAssembly(ass, ci)
where la != null || ci == defaultCulture || ci == targetCulture
select KVP.Create(ci, la ?? LocalizedAssembly.ImportXml(ass, ci, forceCreate: true))).ToDictionary();
var master = reference.Extract(defaultCulture);
var target = reference.Extract(targetCulture);
DictionaryByTypeName(target); //To avoid finding duplicated types on save
int totalTypes;
var changes = TranslationSynchronizer.GetAssemblyChanges(TranslationClient.Translator, target, master, reference.Values.ToList(), false, role, out totalTypes);
ViewBag.Role = role;
ViewBag.TotalTypes = totalTypes;
ViewBag.Culture = targetCulture;
return base.View(TranslationClient.ViewPrefix.FormatWith("Sync"), changes);
}
public static Entity ServiceConstructFromLite(Lite <IEntity> lite, OperationSymbol operationSymbol, params object[] args)
{
var op = Find <IConstructorFromOperation>(lite.EntityType, operationSymbol);
return((Entity)op.Construct(Database.RetrieveAndForget(lite), args));
}
public Dictionary <OperationSymbol, string> GetCanExecuteLiteAll(Lite <Entity> lite)
{
return(Return(MethodInfo.GetCurrentMethod(), lite.EntityType.Name,
() => OperationLogic.ServiceCanExecute(Database.Retrieve(lite))));
}
public NormalWindowProxy <T> SelectEntity <T>(Lite <T> lite) where T : Entity
{
return(OmniBox.SelectEntity <T>(lite));
}
public ActionResult ResetPasswordSetNew(Lite<ResetPasswordRequestEntity> rpr)
{
using (AuthLogic.Disable())
{
ResetPasswordRequestEntity request = rpr.Retrieve();
var user = request.User;
var context = user.ApplyChanges(this, UserMapping.ChangePassword, "").Validate();
if (!context.Errors.TryGetC(UserMapping.NewPasswordKey).IsNullOrEmpty() ||
!context.Errors.TryGetC(UserMapping.NewPasswordBisKey).IsNullOrEmpty())
{
ViewData["Title"] = AuthMessage.ChangePassword.NiceToString();
ModelState.FromContext(context);
return ResetPasswordSetNewError(request.Id, "");
}
string errorPasswordValidation = UserEntity.OnValidatePassword(Request.Params[UserMapping.NewPasswordKey]);
if (errorPasswordValidation.HasText())
return ResetPasswordSetNewError(request.Id, errorPasswordValidation);
using (OperationLogic.AllowSave<UserEntity>())
{
context.Value.Save();
}
//remove pending requests
Database.Query<ResetPasswordRequestEntity>().Where(r => r.User.Email == user.Email && r.Code == request.Code).UnsafeDelete();
}
return RedirectToAction("ResetPasswordSuccess");
}
protected static Type CleanType(Type type)
{
type = Lite.Extract(type) ?? type;
type = EnumEntity.Extract(type) ?? type;
return(type);
}
