public static bool TryWechatAutoLogin(this IAccessControl ac, bool external, out string openId)
{
var app = ac.Context.RequestServices.GetService <IWeChatContainer>().GetApp();
try
{
var code = App.GetQuery("code", "");
var result = OAuthApi.GetAccessToken(app.AppId, app.AppSecret, code);
openId = result.openid;
}
catch
{
openId = "";
}
if (openId.HasValue())
{
if (external)
{
return(true);
}
var service = ac.Context.RequestServices.GetService <IUserService>();
var user = service.QueryByAuth(app.Id, openId);
if (user != null)
{
ac.Login(user, true).Wait();
return(true);
}
return(false);
}
return(false);
}
public AccessControl (Context context, ObjectPath opath)
{
this.access_control = context.GetObject<IAccessControl> (opath);
access_control.ACLAdded += OnACLAdded;
access_control.ACLRemoved += OnACLRemoved;
}
public AccessControl(Context context, ObjectPath opath)
{
this.access_control = context.GetObject <IAccessControl> (opath);
access_control.ACLAdded += OnACLAdded;
access_control.ACLRemoved += OnACLRemoved;
}
public static bool CanInsert(System.Security.Principal.IPrincipal user, IAccessControl accessControl)
{
if (accessControl != null)
return MatchPermissions(user, accessControl.InsertPermissions);
else
return true;
}
public static readonly IAccessControl AllAllowed; // full access on get
//public static readonly IAccessControl Restricted;
static AccessControl()
{
Logger = LogManager.GetCurrentClassLogger();
Undefined = new NoneAccessControl(); // (false);
AllAllowed = new FullAccessControl(); // (true);
//Restricted = null; // new AccessControl(true, false);
}
/// <summary>
/// Verify specified user can insert a specified entity or not?
/// </summary>
public static bool CanInsert(IPrincipal user, IAccessControl accessControl)
{
if (accessControl != null)
{
return(MatchPermissions(user, accessControl.InsertPermissions));
}
return(true);
}
public FileProvider(IAccessControl accessControl)
{
if (accessControl == null)
{
throw new ArgumentNullException(nameof(accessControl));
}
_accessControl = accessControl;
}
public static bool CanRead(System.Security.Principal.IPrincipal user, IAccessControl accessControl, IOwner entity)
{
if (MatchUser(user, entity))
return true;
else if (accessControl != null)
return MatchPermissions(user, accessControl.ReadPermissions);
else
return true;
}
public AccountController(IApplicationUserManager userManager,
IApplicationDbContext dbApplicationContext,
IRepository <ApplicationUser, string> users,
IAccessControl accessControl)
{
this.UserManager = userManager;
this.dbApplicationUser = dbApplicationContext;
this.users = users;
this.accessControl = accessControl;
}
public TriggerAccessController(
IAccessControl accessControl,
IMapper mapper,
mydbContext context,
IOptions <AppSettings> appSettings)
{
_context = context;
_mapper = mapper;
_accessControl = accessControl;
_appSettings = appSettings.Value;
}
public FileInfo(string path, IAccessControl accessControl, IFileOptions options)
{
_info = new System.IO.FileInfo(path);
_accessControl = accessControl;
_options = options;
if (!options.SkipResolvingSymbolicLinks)
{
_symlink = new SymLink(path);
}
}
public PhysicalStorage(Settings.LocalStorage settings, IAccessControl accessControl) //, bool securitySupported)//, IClient coreData)
{
Home = settings.Home.ThrowIf(settings.Home.IsNullOrEmpty());
//if (!Directory.Exists(Home))
//{
// Directory.CreateDirectory(Home);
//}
_spaceInfo = new StorageSpace(Home);
SecurityService = accessControl; // AccessControl.WithConfig(securitySupported);
}
/// <summary>
/// Verify specified user can read a specified entity or not?
/// </summary>
public static bool CanRead(IPrincipal user, IAccessControl accessControl, IOwner entity)
{
if (MatchUser(user, entity))
{
return(true);
}
else if (accessControl != null)
{
return(MatchPermissions(user, accessControl.ReadPermissions));
}
return(true);
}
public FileProvider(IAccessControl accessControl, IFileOptions options)
{
if (accessControl == null)
{
throw new ArgumentNullException(nameof(accessControl));
}
if (options == null)
{
throw new ArgumentNullException(nameof(options));
}
_options = options;
_accessControl = accessControl;
}
public static bool WeChatAuthorize(this IAccessControl ac, string openIdParamName)
{
var context = ac.Context;
// 是否微信运行
if (!context.SideInWeixinBrowser())
{
return(true);
}
// 检查是否wechat oauth, 是否传入appid
if (!App.GetQuery("appid", "").HasValue())
{
return(true);
}
try
{
var returnUrl = App.GetQuery("returnurl", "/wechat");
if (ac.Logined && ac.Auths.ContainsKey("wechat"))
{
if (returnUrl.StartsWith("http"))
{
returnUrl = UrlHelper.Append(returnUrl, openIdParamName, ac.Auths["wechat"].AuthId);
}
context.Response.Redirect(returnUrl);
return(true);
}
else if (ac.Logined)
{
// logout first
ac.Logout();
}
var app = ac.Context.RequestServices.GetService <IWeChatContainer>().GetApp();
var state = App.GetQuery("state", "state");
var scope = (OAuthScope)App.GetQuery("scope", 0);
var redirectUrl = $"{App.GetWebRoot(true)}plat/account/wechat?appid={app.Id}&redirect_uri={returnUrl}";
var authorizeUrl = OAuthApi.GetAuthorizeUrl(app.AppId, redirectUrl, state, scope);
context.Response.Redirect(authorizeUrl);
return(true);
}
catch
{
return(false);
}
}
static void Main(string[] args)
{
Console.ForegroundColor = ConsoleColor.Cyan;
Console.WriteLine("WELCOME TO FACTORY.SOLUTION 1");
Console.WriteLine("Enter the access control code, please");
string accessControlCode = Console.ReadLine();
IAccessControl accessControl = GetAccessControl(accessControlCode.ToUpper());
var users = accessControl.GetUsers();
var attendances = accessControl.GetAttendeces();
Console.WriteLine($"Selected Device: { accessControl.Code }");
users.ForEach(user => Console.WriteLine(user));
attendances.ForEach(attendance => Console.WriteLine(attendance));
Console.ReadLine();
}
public static string TryWeappAutoLogin(this IAccessControl ac, JObject data, out string errMsg)
{
errMsg = null;
var app = ac.Context.RequestServices.GetService <IWeChatContainer>().GetApp();
var session = data.GetValue("sessionid", key => SessionContainer.GetSession(key));
if (session == null)
{
// session未建立，通过code登录换取session
var result = WeChatApi.WxLogin(app, data.GetValue("code", ""));
if (result.ErrorCodeValue == 0)
{
// success，成功时更新session
session = SessionContainer.UpdateSession(null, result.openid, result.session_key, result.unionid);
}
else
{
errMsg = result.errmsg;
}
}
if (session != null)
{
// 根据OpenID自动登录
var service = ac.Context.RequestServices.GetService <IUserService>();
var user = service.GetByAuth(app.Id, session.OpenId);
if (user == null)
{
// OpenID对应的用户不存在，解密客户端数据
var cryptedData = data.GetValue("encryptedData", "");
var iv = data.GetValue("iv", "");
var userInfo = EncryptHelper.DecodeUserInfoBySessionId(session.Key, cryptedData, iv);
// 自动创建用户
var mobile = data.GetValue <string>("mobile");
var wechatService = ac.Context.RequestServices.GetService <IWechatService>();
user = wechatService.WeappRegist(app, userInfo, mobile);
}
return($"{user.HashId}-{session.SessionKey}");
}
return(null);
}
public static async Task WechatLogin(this IAccessControl ac, string userName, string password, string openId)
{
var app = ac.Context.RequestServices.GetService <IWeChatContainer>().GetApp();
var userService = ac.Context.RequestServices.GetService <IUserService>();
var user = userService.CheckUser(userName, password);
var userInfoJson = UserApi.Info(app.AppId, openId);
if (userInfoJson != null)
{
user.NickName = userInfoJson.nickname;
user.Photo = userInfoJson.headimgurl;
userService.Update(user);
}
userService.UpdateAuth(user, app.Id, openId, "wechat");
await ac.Login(user, true);
}
private void ConfigureOptions()
{
IAccessControl accessControl = (IAccessControl)Environment.Host.ApplicationBuilder.ApplicationServices.GetService(typeof(IAccessControl));
IFileProvider fileProvider = (IFileProvider)Environment.Host.ApplicationBuilder.ApplicationServices.GetService(typeof(IFileProvider));
string inetpubPath = System.Environment.ExpandEnvironmentVariables(@"%SystemDrive%\inetpub");
IEnumerable <string> claims = accessControl.GetClaims(inetpubPath);
if (claims == null)
{
//
// Only add default inetpub access if no access rights have been specified
fileProvider.Options.AddLocation(new Location()
{
Alias = "inetpub",
Path = inetpubPath,
Claims = new List <string> {
"read"
}
});
}
}
public static JsApiToken GetJsApiToken(this IAccessControl ac, bool resetUrl)
{
var app = ac.Context.RequestServices.GetService <IWeChatContainer>().GetApp();
var timestamp = JSSDKHelper.GetTimestamp();
var noncestr = JSSDKHelper.GetNoncestr();
var jsApiTicket = JsApiTicketContainer.GetJsApiTicket(app.AppId);
var url = ac.Context.Request.GetUrl();
if (resetUrl)
{
url = UrlHelper.Append(url, "t", timestamp);
}
var signature = JSSDKHelper.GetSignature(jsApiTicket, noncestr, timestamp, url);
return(new JsApiToken
{
AppId = app.AppId,
Ticket = jsApiTicket,
Timestamp = timestamp,
Nonce = noncestr,
Signature = signature
});
}
public static string GetWeopenToken(this IAccessControl ac)
{
return($"{ac.User.HashId}-{CryptoHelper.ComputeMD5("WEOPEN", ac.User.HashId)}");
}
/// <summary>
/// Deletes an access control policy.
/// </summary>
/// <param name="policyUriString">Unique URI that identifies the policy.</param>
/// <returns></returns>
public async Task ClearAccessControlPolicyAsync(string policyUriString)
{
IAccessControl accessControl = GetAccessControlPolicy(policyUriString);
await accessControl.ClearAsync();
}
/// <summary>
/// Gets an access control policy.
/// </summary>
/// <param name="policyUriString">Unqiue URI that identifies the policy.</param>
/// <returns>CAPL access control policy.</returns>
public async Task <AuthorizationPolicy> GetAccessControlPolicyAsync(string policyUriString)
{
IAccessControl accessControl = GetAccessControlPolicy(policyUriString);
return(await accessControl.GetPolicyAsync());
}
public FileInfo(string path, IAccessControl accessControl, IFileOptions options, bool exists) : this(path, accessControl, options)
{
_exists = exists;
}
/// <summary>
/// Adds or updates an CAPL access control policy.
/// </summary>
/// <param name="policyUriString">Unique URI that identifies the policy.</param>
/// <param name="policy">CAPL access control policy.</param>
/// <returns></returns>
public async Task UpsertAcessControlPolicyAsync(string policyUriString, AuthorizationPolicy policy)
{
IAccessControl accessControl = GetAccessControlPolicy(policyUriString);
await accessControl.UpsertPolicyAsync(policy);
}
public SubstanceProcessingStateMachine(IAccessControl accessControl)
{
_accessControl = accessControl ?? throw new ArgumentNullException(nameof(accessControl));
InstanceState(x => x.CurrentState);
Event(() => RecordParsed, x => x.CorrelateById(context => context.Message.Id).SelectId(context => context.Message.Id));
Event(() => SubstanceCreated, x => x.CorrelateById(context => context.Message.Id));
Event(() => StatusChanged, x => x.CorrelateById(context => context.Message.Id));
Event(() => ImageAdded, x => x.CorrelateById(context => context.Message.Id));
Event(() => PropertiesAdded, x => x.CorrelateById(context => context.Message.Id));
Event(() => IssuesAdded, x => x.CorrelateById(context => context.Message.Id));
Event(() => ImageGenerated, x => x.CorrelateById(context => context.Message.CorrelationId));
Event(() => ImageGenerationFailed, x => x.CorrelateById(context => context.Message.CorrelationId));
Event(() => SubstanceValidated, x => x.CorrelateById(context => context.Message.CorrelationId));
Event(() => SubstanceValidationFailed, x => x.CorrelateById(context => context.Message.CorrelationId));
Event(() => ChemicalPropertiesCalculated, x => x.CorrelateById(context => context.Message.CorrelationId));
Event(() => ChemicalPropertiesCalculationFailed, x => x.CorrelateById(context => context.Message.CorrelationId));
Event(() => SubstanceProcessed, x => x.CorrelateById(context => context.Message.CorrelationId));
Event(() => NodeStatusPersisted, x => x.CorrelateById(context => context.Message.Id));
Event(() => StatusPersisted, x => x.CorrelateById(context => context.Message.Id));
CompositeEvent(() => EndProcessing, x => x.AllProcessed, SubstanceValidationDone, ImageGenerationDone, ChemicalPropertiesCalculationDone);
CompositeEvent(() => AllPersisted, x => x.AllPersisted, StatusChanged, StatusPersistenceDone, NodeStatusPersistenceDone);
Initially(
When(RecordParsed)
.TransitionTo(Creating)
.ThenAsync(async context =>
{
context.Instance.Created = DateTimeOffset.UtcNow;
context.Instance.Updated = DateTimeOffset.UtcNow;
context.Instance.RecordId = context.Data.Id;
context.Instance.FileId = context.Data.FileId;
context.Instance.UserId = context.Data.UserId;
context.Instance.BlobId = context.Data.BlobId;
context.Instance.Bucket = context.Data.Bucket;
context.Instance.Index = context.Data.Index;
context.Instance.Fields = context.Data.Fields;
context.Instance.FileCorrelationId = context.Data.CorrelationId;
await context.Raise(BeginCreating);
})
);
During(Creating,
When(BeginCreating)
.ThenAsync(async context =>
{
await context.CreateConsumeContext().Publish <CreateSubstance>(new
{
Id = context.Instance.RecordId,
Index = context.Instance.Index,
FileId = context.Instance.FileId,
UserId = context.Instance.UserId,
BlobId = context.Instance.BlobId,
Bucket = context.Instance.Bucket,
Fields = context.Instance.Fields
});
}),
When(SubstanceCreated)
.ThenAsync(async context =>
{
if (context.Data.TimeStamp > context.Instance.Updated)
{
context.Instance.Updated = context.Data.TimeStamp;
}
await context.Raise(EndCreating);
}),
When(EndCreating)
.TransitionTo(Processing)
.ThenAsync(async context =>
{
await context.Raise(BeginProcessing);
})
);
During(Processing,
Ignore(StatusPersisted),
Ignore(NodeStatusPersisted),
When(BeginProcessing)
.ThenAsync(async context =>
{
await context.CreateConsumeContext().Publish <ChangeStatus>(new
{
Id = context.Instance.RecordId,
Status = RecordStatus.Processing,
UserId = context.Instance.UserId
});
}),
When(StatusChanged)
.ThenAsync(async context =>
{
if (context.Data.TimeStamp > context.Instance.Updated)
{
context.Instance.Updated = context.Data.TimeStamp;
}
// generate substance image
await context.CreateConsumeContext().Publish <GenerateImage>(new
{
Id = context.Instance.RecordId,
UserId = context.Instance.UserId,
BlobId = context.Instance.BlobId,
Bucket = context.Instance.Bucket,
CorrelationId = context.Instance.CorrelationId,
Image = new Imaging.Domain.Models.Image()
{
Id = NewId.NextGuid(),
Width = 200,
Height = 200,
Format = "SVG",
MimeType = "image/svg+xml"
}
});
// calculate chemical properties
if (_accessControl.IsServiceAvailable <CalculateChemicalProperties>())
{
await context.CreateConsumeContext().Publish <CalculateChemicalProperties>(new
{
Id = context.Instance.RecordId,
UserId = context.Instance.UserId,
BlobId = context.Instance.BlobId,
Bucket = context.Instance.Bucket,
CorrelationId = context.Instance.CorrelationId,
});
}
else
{
await context.Raise(ChemicalPropertiesCalculationDone);
}
// validate substance
if (_accessControl.IsServiceAvailable <Validate>())
{
await context.CreateConsumeContext().Publish <Validate>(new
{
Id = context.Instance.RecordId,
UserId = context.Instance.UserId,
BlobId = context.Instance.BlobId,
Bucket = context.Instance.Bucket,
CorrelationId = context.Instance.CorrelationId,
});
}
else
{
await context.Raise(SubstanceValidationDone);
}
}),
When(ImageGenerated)
.ThenAsync(async context =>
{
if (context.Data.TimeStamp > context.Instance.Updated)
{
context.Instance.Updated = context.Data.TimeStamp;
}
context.Instance.Image = context.Data.Image;
await context.CreateConsumeContext().Publish <AddImage>(new
{
Id = context.Instance.RecordId,
UserId = context.Instance.UserId,
Image = new Image(context.Instance.Bucket, context.Data.Image.Id, context.Data.Image.Format, context.Data.Image.MimeType, context.Data.Image.Width, context.Data.Image.Height, context.Data.Image.Exception)
});
if (context.Instance.Index < 10)
{
await context.CreateConsumeContext().Publish <ThumbnailGenerated>(new
{
Id = context.Data.Id,
Index = context.Instance.Index,
BlobId = context.Data.BlobId,
Bucket = context.Data.Bucket,
TimeStamp = DateTimeOffset.UtcNow,
UserId = context.Data.UserId,
Image = context.Data.Image,
CorrelationId = context.Instance.FileCorrelationId
});
}
//await context.Raise(ImageGenerationDone);
}),
When(ImageGenerationFailed)
.ThenAsync(async context => {
if (context.Data.TimeStamp > context.Instance.Updated)
{
context.Instance.Updated = context.Data.TimeStamp;
}
context.Instance.Image = context.Data.Image;
await context.Raise(ImageGenerationDone);
}),
When(ImageAdded)
.ThenAsync(async context => {
await context.Raise(ImageGenerationDone);
}),
When(ChemicalPropertiesCalculated)
.ThenAsync(async context => {
if (context.Data.TimeStamp > context.Instance.Updated)
{
context.Instance.Updated = context.Data.TimeStamp;
}
await context.CreateConsumeContext().Publish <AddProperties>(new
{
Id = context.Instance.RecordId,
UserId = context.Instance.UserId,
Properties = context.Data.Result.Properties
});
//await context.Raise(ChemicalPropertiesCalculationDone);
}),
When(ChemicalPropertiesCalculationFailed)
.ThenAsync(async context => {
if (context.Data.TimeStamp > context.Instance.Updated)
{
context.Instance.Updated = context.Data.TimeStamp;
}
await context.Raise(ChemicalPropertiesCalculationDone);
}),
When(PropertiesAdded)
.ThenAsync(async context => {
await context.Raise(ChemicalPropertiesCalculationDone);
}),
When(SubstanceValidated)
.ThenAsync(async context => {
if (context.Data.TimeStamp > context.Instance.Updated)
{
context.Instance.Updated = context.Data.TimeStamp;
}
await context.CreateConsumeContext().Publish <AddIssues>(new
{
Id = context.Instance.RecordId,
UserId = context.Instance.UserId,
Issues = context.Data.Record.Issues.Select(i => new Generic.Domain.ValueObjects.Issue()
{
Code = i.Code,
Title = i.Title,
Message = i.Message,
AuxInfo = i.AuxInfo,
Severity = (Severity)i.Severity
})
});
//await context.Raise(SubstanceValidationDone);
}),
When(SubstanceValidationFailed)
.ThenAsync(async context => {
if (context.Data.TimeStamp > context.Instance.Updated)
{
context.Instance.Updated = context.Data.TimeStamp;
}
await context.Raise(SubstanceValidationDone);
}),
When(IssuesAdded)
.ThenAsync(async context => {
await context.Raise(SubstanceValidationDone);
}),
When(EndProcessing)
.TransitionTo(Processed)
.ThenAsync(async context =>
{
await context.Raise(BeginProcessed);
})
);
During(Processed,
When(BeginProcessed)
.ThenAsync(async context =>
{
await context.CreateConsumeContext().Publish <ChangeStatus>(new
{
Id = context.Instance.RecordId,
UserId = context.Instance.UserId,
Status = RecordStatus.Processed
});
}),
When(NodeStatusPersisted)
.ThenAsync(async context =>
{
await context.Raise(NodeStatusPersistenceDone);
}),
When(StatusPersisted)
.ThenAsync(async context =>
{
await context.Raise(StatusPersistenceDone);
}),
When(AllPersisted)
.ThenAsync(async context =>
{
await context.Raise(EndProcessed);
}),
When(EndProcessed)
.ThenAsync(async context =>
{
await context.CreateConsumeContext().Publish <SubstanceProcessed>(new
{
Id = context.Instance.RecordId,
FileId = context.Instance.FileId,
Index = context.Instance.Index,
Type = RecordType.Structure,
CorrelationId = context.Instance.FileCorrelationId,
UserId = context.Instance.UserId,
Timestamp = DateTimeOffset.UtcNow
});
})
.Finalize()
);
SetCompletedWhenFinalized();
}
public WfRunner(IAccessControl ac)
{
this.AC = ac;
}
