private object ExecuteInternal(Expression expression) { var searchBody = SearchParser.Parse(expression); Elastic.PostSearch(connection, new PostSearchRequest { Body = searchBody }); //var translation = ElasticQueryTranslator.Translate(Mapping, Prefix, expression); //var elementType = TypeHelper.GetSequenceElementType(expression.Type); //Log.Debug(null, null, "Executing query against type {0}", elementType); //try //{ // var response = AsyncHelper.RunSync(() => requestProcessor.SearchAsync(translation.SearchRequest)); // if (response == null) // throw new InvalidOperationException("No HTTP response received."); // return translation.Materializer.Materialize(response); //} //catch (AggregateException ex) { //ExceptionDispatchInfo.Capture(ex.InnerException).Throw(); return(null); // Never called, as the above code re-throws } }
public ServiceResult <object> Save(BusinessParam bp, PersonDto dto) { var methodName = $".{new StackTrace().GetFrame(1).GetMethod().Name}"; try { DataLayer.Model.Core.Person.Person person; if (dto.EntityId == 0) { using (var unitOfWork = new UnitOfWork()) { person = Copier.GetEntity(dto, bp, true); unitOfWork.Person.Insert(person); unitOfWork.Person.Save(); } } else { using (var unitOfWork = new UnitOfWork()) { person = Copier.GetEntity(dto, bp, false); unitOfWork.Person.Update(person); unitOfWork.Person.Save(); } } Elastic <PersonDto, DataLayer.Model.Core.Person.Person> .SaveToElastic(person, ClassDetails[0].Clazz, bp); return(new ServiceResult <object>(Copier.GetDto(person), 1)); } catch (Exception e) { return(ExceptionUtil.ExceptionHandler(e, ClassDetails[0].Facade + methodName, bp.UserInfo)); } }
public static async Task UploadResult(ArtilleryResult artilleryResult, string serverurl, string username, string password, Dictionary <string, string> extraFields) { var allrequests = new List <ElasticBulkDocument>(); foreach (var request in artilleryResult.Requests) { dynamic jobject = new JObject { ["LoadtestID"] = artilleryResult.LoadtestID, ["@timestamp"] = request.StartTime.ToString("yyyy-MM-ddTHH:mm:ss.fff"), ["LatencyNS"] = request.Latency, ["HttpResult"] = request.HttpResult, ["RebasedTimestamp"] = request.StartTime.AddMilliseconds(artilleryResult.Diff_ms).ToString("yyyy-MM-ddTHH:mm:ss.fff") }; foreach (var field in extraFields) { jobject[field.Key] = field.Value; } var bulkDocument = new ElasticBulkDocument { Index = $"artillery-{request.StartTime:yyyy}.{request.StartTime:MM}", Id = GetHashString(jobject.ToString()), Document = jobject }; allrequests.Add(bulkDocument); } Log($"Request count: {allrequests.Count}"); await Elastic.PutIntoIndex(serverurl, username, password, allrequests.ToArray()); }
public ServiceResult <object> DeletedList(BusinessParam bp, long roleId) { var methodName = $".{new StackTrace().GetFrame(1).GetMethod().Name}"; try { using (var unitOfWork = new UnitOfWork()) { var accessGroups = unitOfWork.RoleAccessGroup.Get(p => p.Role == roleId).ToList(); foreach (var item in accessGroups) { unitOfWork.RoleAccessGroup.Delete(item); Elastic <RoleAccessGroupDto, DataLayer.Model.Core.RoleAccessGroup.RoleAccessGroup> .SaveToElastic( item, ClassDetails[0].Clazz, bp); } unitOfWork.UseCaseActionAccessGroup.Save(); } return(new ServiceResult <object>(true, 1)); } catch (Exception e) { return(ExceptionUtil.ExceptionHandler(e, ClassDetails[0].Facade + methodName, bp.UserInfo)); } }
public ScriptFilter(Elastic.Scripts.Script script) { if (script == null) throw new ArgumentNullException("script", "ScriptFilter requires a script."); Script = script; Cache = ScriptFilterSerializer._CACHE_DEFAULT; }
public ContentController(Postgres postgres, Mongo mongo, Redis redis, Elastic elastic, Wrappers.Neo4j neo4j) { this.postgres = postgres; this.mongo = mongo; this.redis = redis; this.elastic = elastic; this.neo4j = neo4j; }
public void CreateMatchQueryTest() { var queryContainer = Elastic.MakeMatchQuery("query-test", "field-test", fuzziness: 1); var queryString = elastic.Client.RequestResponseSerializer.SerializeToString(queryContainer); var realQuery = "{\"match\":{\"field-test\":{\"fuzziness\":1,\"query\":\"query-test\"}}}"; Assert.Equal(realQuery, queryString); }
public static float CalculateLerpValueClamp01(float lerpValue, Type easingType, bool isZeroToOne) { switch (easingType) { case Type.Linear: lerpValue = Linear.InOut(lerpValue); break; case Type.Quadratic: lerpValue = Quadratic.InOut(lerpValue); break; case Type.Cubic: lerpValue = Cubic.InOut(lerpValue); break; case Type.Quartic: lerpValue = Quartic.InOut(lerpValue); break; case Type.Quintic: lerpValue = Quintic.InOut(lerpValue); break; case Type.Sinusoidal: lerpValue = Sinusoidal.InOut(lerpValue); break; case Type.Exponential: lerpValue = Exponential.InOut(lerpValue); break; case Type.Circular: lerpValue = Circular.InOut(lerpValue); break; case Type.Elastic: lerpValue = Elastic.InOut(lerpValue); break; case Type.Back: lerpValue = Back.InOut(lerpValue); break; case Type.Bounce: lerpValue = Bounce.InOut(lerpValue); break; default: return(-1f); } lerpValue = ClampMinMax(0f, 1f, lerpValue); return(lerpValue); }
public static float easeInOut(float t) { if (t <= 0.5f) { return(Elastic.easeIn(t * 2) / 2); } else { return((Elastic.easeOut((t - 0.5f) * 2.0f) / 2) + 0.5f); } }
IEnumerator Follow() { yield return(new WaitForSeconds(.1f)); Elastic left = GameObject.Find("ElasticRight").GetComponent <Elastic>(); Elastic right = GameObject.Find("ElasticLeft").GetComponent <Elastic>(); left.Reset(); right.Reset(); game.SetLoaded(null); }
private async Task RegisterIncidentAtElasticAsync(string host, VTShortReport shortReport, string restrictingPolicy) { var incident = new EventIncident(host, shortReport.md5, shortReport.full_class, restrictingPolicy); var firstOccurrenceIp = await Elastic.FindFirstOccurrenceIpByFileHash(shortReport.md5); var paths = await Neo4J.FindAllPaths(firstOccurrenceIp, host); incident.SetPossibleRoutes(paths); incident.ExcludeRestrictedRoutes(shortReport, Redis); await Logstash.SendEventAsync(incident); }
public void BulkTest() { var documents = new List <Document> { new Document("1", "one"), new Document("2", "two"), new Document("3", "three") }; elastic.BulkIndex <Document>(documents, "DocumentId"); elastic.Refresh(); var response = elastic.GetResponseOfQuery <Document>(Elastic.MakeMatchQuery("one", "content")); Assert.Equal("one", response.Hits.ToList().Single().Source.Content); }
/// <summary> /// Create a script sort without parameters. /// </summary> /// <param name="script">Sets the text of the script to execute against the documents.</param> /// <param name="type">Sets the type of value the script produces.</param> public ScriptSort(Elastic.Scripts.Script script, string type) { if (script == null) throw new ArgumentNullException("script", "ScriptSort requires a script."); if (string.IsNullOrWhiteSpace(type)) throw new ArgumentNullException("type", "ScriptSort requires the type of value produced by the script."); Script = script; Type = type; SortOrder = SortClauseSerializer._ORDER_DEFAULT; Reverse = SortClauseSerializer._REVERSE_DEFAULT; }
public ISearchResponse <TObject> GetByQuery <TObject>(string indexName, Func <QueryContainerDescriptor <TObject>, QueryContainer> query) where TObject : class { ISearchRequest <TObject> Selector(SearchDescriptor <TObject> descriptor) { return(descriptor .Index(indexName) .Type(GetTypeName <TObject>()) .Query(query) as ISearchRequest <TObject>); } return(Elastic.Search <TObject>(Selector)); }
public ServiceResult <object> Delete(BusinessParam bp) { var methodName = $".{new StackTrace().GetFrame(1).GetMethod().Name}"; long entityId = 0; foreach (var where in bp.Clause.Wheres.Where(where => where.Key.Equals("entityId") && where.Value != null && !where.Value.Equals(""))) { entityId = long.Parse(where.Value); } try { if (entityId == 0) { return(ExceptionUtil.ExceptionHandler("شناسه مورد نظر یافت نشد", ClassDetails[0].Facade + methodName, bp.UserInfo)); } DataLayer.Model.Core.UseCase.UseCase useCase; using (var unitOfWork = new UnitOfWork()) { useCase = unitOfWork.UseCase.GetRecord(entityId); } if (useCase == null) { return(ExceptionUtil.ExceptionHandler("شناسه مورد نظر یافت نشد", ClassDetails[0].Facade + methodName, bp.UserInfo)); } useCase.Deleted = useCase.EntityId; using (var unitOfWork = new UnitOfWork()) { unitOfWork.UseCase.Update(useCase); unitOfWork.UseCase.Save(); } Elastic <UseCaseDto, DataLayer.Model.Core.UseCase.UseCase> .SaveToElastic(useCase, ClassDetails[0].Clazz, bp); return(new ServiceResult <object>(true, 1)); } catch (Exception e) { return(ExceptionUtil.ExceptionHandler(e, ClassDetails[0].Facade + methodName, bp.UserInfo)); } }
private async Task <ServiceResult <object> > CreateThumbnail(IFormFile formFile, FileDto fileDto, BusinessParam bp) { var methodName = $".{new StackTrace().GetFrame(1).GetMethod().Name}"; try { var webRootPath = bp.Environment.WebRootPath; var dto = new FileDto { Alt = fileDto.Alt, DataSize = fileDto.DataSize, Description = fileDto.Description, DisplayInFileManager = false, Extension = fileDto.Extension, FullTitle = fileDto.FullTitle, Name = fileDto.Name, ParentId = fileDto.ParentId, Path = fileDto.Path, Thumbnail = fileDto.Thumbnail, Title = fileDto.Title }; var resize = new ImageResize(); resize.Resize(webRootPath + dto.Path, webRootPath + dto.Thumbnail); dto.DisplayInFileManager = false; dto.Path = dto.Thumbnail; var file = Copier.GetEntity(dto, bp, true); using (var unitOfWork = new UnitOfWork()) { var done = unitOfWork.File.Insert(file); unitOfWork.File.Save(); if (!done) { return(ExceptionUtil.ExceptionHandler("خطا در ذخیره فایل درون دیتابیس", ClassDetails[0].Facade + methodName, bp.UserInfo)); } Elastic <FileDto, DataLayer.Model.Core.File.File> .SaveToElastic(file, ClassDetails[0].Clazz, bp); dto.EntityId = file.EntityId; return(new ServiceResult <object>(dto, 1)); } } catch (Exception e) { return(ExceptionUtil.ExceptionHandler(e, ClassDetails[0].Facade + methodName, bp.UserInfo)); } }
public async Task <int> Insert(LearningPath model) { var parameters = new { model.Name, model.Slug, model.TotalCourses, model.PathIcon, model.LearningPathDescription, @CreateDate = DateTime.Now, @ModifiedDate = DateTime.Now }; var result = await _dapperBaseRepository.Excute("sp_AddLearningPath", parameters); Elastic.LogInformation(model, EnumHelper.GetEnumValue(EnumHelper.SystemEnums.Status, result), MethodBase.GetCurrentMethod().DeclaringType.FullName, "UserIDHERE"); return(result); }
static async Task Main(string[] args) { var apiClient = new ApiClient(); var id = await apiClient.Participate(); Console.WriteLine($"Got participant id {id}"); var response = await Elastic.GetMovements(id); Console.WriteLine("Movements:\n"); Console.WriteLine(JsonConvert.SerializeObject(response, Formatting.Indented)); Console.WriteLine("Sending position ..."); var pos = await apiClient.SubmitPosition(response); Console.WriteLine($"Got position:\n{pos}"); }
public ServiceResult <object> SaveList(BusinessParam bp, List <UseCaseActionAccessGroupDto> lstDto) { var methodName = $".{new StackTrace().GetFrame(1).GetMethod().Name}"; try { foreach (var dto in lstDto) { DataLayer.Model.Core.UseCaseActionAccessGroup.UseCaseActionAccessGroup caseActionAccessGroup; if (dto.EntityId == 0) { using (var unitOfWork = new UnitOfWork()) { caseActionAccessGroup = Copier.GetEntity(dto, bp, true); if (caseActionAccessGroup.UseCaseAction != -1) { unitOfWork.UseCaseActionAccessGroup.Insert(caseActionAccessGroup); unitOfWork.UseCaseActionAccessGroup.Save(); } } } else { using (var unitOfWork = new UnitOfWork()) { caseActionAccessGroup = Copier.GetEntity(dto, bp, false); unitOfWork.UseCaseActionAccessGroup.Update(caseActionAccessGroup); unitOfWork.UseCaseActionAccessGroup.Save(); } } Elastic <UseCaseActionAccessGroupDto, DataLayer.Model.Core.UseCaseActionAccessGroup.UseCaseActionAccessGroup> .SaveToElastic(caseActionAccessGroup, "UseCaseActionAccessGroup", bp); } return(new ServiceResult <object>(true, 1)); } catch (Exception e) { return(ExceptionUtil.ExceptionHandler(e, ClassDetails[0].Facade + methodName, bp.UserInfo)); } }
public DatabaseManager(IConfiguration config) { string host = config["Host"]; Mongo = new Mongo(host, config["Mongo:Port"], config["Mongo:Login"], config["Mongo:Password"], "vt_reports", "short_vt_reports"); Redis = new Redis(host, config["Redis:Port"]); //Neo4J = new Neo4J(host, config["Neo4j:Port"], config["Neo4j:Login"], config["Neo4j:Password"]); Neo4J = new Neo4JExperimental(host, config["Neo4j:Port"], config["Neo4j:Login"], config["Neo4j:Password"]); Postgres = new Postgres(host, config["Postgre:Port"], config["Postgre:Login"], config["Postgre:Password"], config["Postgre:Database"]); Elastic = new Elastic(host, config["ElasticSearch:Port"]); VirusTotal = new VirusTotal(@"Resources\.virustotal.api", @"Resources\sigs.json", Mongo); Logstash = new Logstash.Logstash(host, int.Parse(config["Logstash:Port"])); }
/// <summary> /// Calculate a Ease OutIn from a pourcent /// </summary> /// <param name="linearStep">Pourcent on the ease</param> /// <param name="type">Easing Type</param> public static float EaseOutIn(float linearStep, EasingType type) { switch (type) { case EasingType.Step: return(Mathf.Round(linearStep)); default: case EasingType.Linear: return(linearStep); case EasingType.Sine: return(Sine.EaseOutIn(linearStep)); case EasingType.Quadratic: return(Power.EaseOutIn(linearStep, 2)); case EasingType.Cubic: return(Power.EaseOutIn(linearStep, 3)); case EasingType.Quartic: return(Power.EaseOutIn(linearStep, 4)); case EasingType.Quintic: return(Power.EaseOutIn(linearStep, 5)); case EasingType.Elastic: return(Elastic.EaseOutIn(linearStep)); case EasingType.Bounce: return(Bounce.EaseOutIn(linearStep)); case EasingType.Back: return(Back.EaseOutIn(linearStep)); case EasingType.Expo: return(Expo.EaseOutIn(linearStep)); case EasingType.Circ: return(Circ.EaseOutIn(linearStep)); } }
public async Task <int> Update(LearningPath model) { var parameters = new { model.Id, model.Name, model.Slug, model.PathIcon, model.LearningPathDescription, @ModifiedDate = DateTime.Now }; //execute find method to get current details (async dont await) var currentObject = Find(model.Id); var result = await _dapperBaseRepository.Excute("sp_UpdateLearningPath", parameters); Elastic.LogInformation(await currentObject, model, EnumHelper.GetEnumValue(EnumHelper.SystemEnums.Status, result), MethodBase.GetCurrentMethod().DeclaringType.FullName, "userIDHERE"); return(result); }
public static float EaseOut(float linearStep, EaseType type) { switch (type) { case EaseType.None: return(1); case EaseType.Linear: return(linearStep); case EaseType.Sine: return(Sine.EaseOut(linearStep)); case EaseType.Quad: return(Power.EaseOut(linearStep, 2)); case EaseType.Cubic: return(Power.EaseOut(linearStep, 3)); case EaseType.Quartic: return(Power.EaseOut(linearStep, 4)); case EaseType.Quintic: return(Power.EaseOut(linearStep, 5)); case EaseType.Circ: return(Circ.EaseOut(linearStep)); case EaseType.Bounce: return(Bounce.EaseOut(linearStep)); case EaseType.Back: return(Back.EaseOut(linearStep)); case EaseType.Elastic: return(Elastic.EaseOut(linearStep)); } Debug.LogError("Um."); return(0); }
public static Func <float, float> GetEaseFunction(EaseFunction functionType, EaseType easeType) { switch (functionType) { case EaseFunction.Linear: return(Linear); case EaseFunction.Quad: return(Quad.Get(easeType)); case EaseFunction.Cubic: return(Cubic.Get(easeType)); case EaseFunction.Quartic: return(Quartic.Get(easeType)); case EaseFunction.Quintic: return(Quintic.Get(easeType)); case EaseFunction.Sin: return(Sin.Get(easeType)); case EaseFunction.Exponential: return(Exponential.Get(easeType)); case EaseFunction.Circular: return(Circular.Get(easeType)); case EaseFunction.Bounce: return(Bounce.Get(easeType)); case EaseFunction.Elastic: return(Elastic.Get(easeType)); case EaseFunction.Back: return(Back.Get(easeType)); } return(f => f); }
public ServiceResult <object> Save(BusinessParam bp, BusinessAccessDto dto) { var methodName = $".{new StackTrace().GetFrame(1).GetMethod().Name}"; try { DataLayer.Model.Core.BusinessAccess.BusinessAccess businessAccess; dto = AddList(bp, dto); if (dto.EntityId == 0) { using (var unitOfWork = new UnitOfWork()) { businessAccess = Copier.GetEntity(dto, bp, true); unitOfWork.BusinessAccess.Insert(businessAccess); unitOfWork.BusinessAccess.Save(); } } else { using (var unitOfWork = new UnitOfWork()) { businessAccess = Copier.GetEntity(dto, bp, false); unitOfWork.BusinessAccess.Update(businessAccess); unitOfWork.BusinessAccess.Save(); } } Elastic <BusinessAccessDto, DataLayer.Model.Core.BusinessAccess.BusinessAccess> .SaveToElastic( businessAccess, ClassDetails[0].Clazz, bp); return(new ServiceResult <object>(Copier.GetDto(businessAccess), 1)); } catch (Exception e) { return(ExceptionUtil.ExceptionHandler(e, ClassDetails[0].Facade + methodName, bp.UserInfo)); } }
public ServiceResult <object> Delete(BusinessParam bp, EntityStateDto dto) { var methodName = $".{new StackTrace().GetFrame(1).GetMethod().Name}"; try { DataLayer.Model.Core.EntityState.EntityState entityState; using (var unitOfWork = new UnitOfWork()) { entityState = unitOfWork.EntityState .Get(p => p.TableEntityId == dto.TableEntityId && p.TableName == dto.TableName) .FirstOrDefault(); } if (entityState == null) { return(ExceptionUtil.ExceptionHandler("شناسه مورد نظر یافت نشد", ClassDetails[0].Facade + methodName, bp.UserInfo)); } using (var unitOfWork = new UnitOfWork()) { unitOfWork.EntityState.Delete(entityState); unitOfWork.EntityState.Save(); } Elastic <EntityStateDto, DataLayer.Model.Core.EntityState.EntityState> .SaveToElastic(entityState, ClassDetails[0].Clazz, bp); return(new ServiceResult <object>(true, 1)); } catch (Exception e) { return(ExceptionUtil.ExceptionHandler(e, ClassDetails[0].Facade + methodName, bp.UserInfo)); } }
//------------------------------------------------------------------------------------------------------------ public static float GetEasingFunction(Type easingFunction, float t) { // Quad if (easingFunction == Type.EaseInQuad) { return(Quadratic.In(t)); } if (easingFunction == Type.EaseOutQuad) { return(Quadratic.Out(t)); } if (easingFunction == Type.EaseInOutQuad) { return(Quadratic.InOut(t)); } // Cubic if (easingFunction == Type.EaseInCubic) { return(Cubic.In(t)); } if (easingFunction == Type.EaseOutCubic) { return(Cubic.Out(t)); } if (easingFunction == Type.EaseInOutCubic) { return(Cubic.InOut(t)); } // Quart if (easingFunction == Type.EaseInQuart) { return(Quartic.In(t)); } if (easingFunction == Type.EaseOutQuart) { return(Quartic.Out(t));; } if (easingFunction == Type.EaseInOutQuart) { return(Quartic.InOut(t));; } // Quint if (easingFunction == Type.EaseInQuint) { return(Quintic.In(t)); } if (easingFunction == Type.EaseOutQuint) { return(Quintic.Out(t)); } if (easingFunction == Type.EaseInOutQuint) { return(Quintic.InOut(t)); } // Sine if (easingFunction == Type.EaseInSine) { return(Sinusoidal.In(t)); } if (easingFunction == Type.EaseOutSine) { return(Sinusoidal.Out(t)); } if (easingFunction == Type.EaseInOutSine) { return(Sinusoidal.InOut(t)); } // Expo if (easingFunction == Type.EaseInExpo) { return(Exponential.In(t)); } if (easingFunction == Type.EaseOutExpo) { return(Exponential.Out(t)); } if (easingFunction == Type.EaseInOutExpo) { return(Exponential.InOut(t)); } // CirC if (easingFunction == Type.EaseInCirc) { return(Circular.In(t)); } if (easingFunction == Type.EaseOutCirc) { return(Circular.Out(t)); } if (easingFunction == Type.EaseInOutCirc) { return(Circular.InOut(t)); } // Linear if (easingFunction == Type.Linear) { return(Linear(t)); } // Bounce if (easingFunction == Type.EaseInBounce) { return(Bounce.In(t)); } if (easingFunction == Type.EaseOutBounce) { return(Bounce.Out(t)); } if (easingFunction == Type.EaseInOutBounce) { return(Bounce.InOut(t)); } // Back if (easingFunction == Type.EaseInBack) { return(Back.In(t)); } if (easingFunction == Type.EaseOutBack) { return(Back.Out(t)); } if (easingFunction == Type.EaseInOutBack) { return(Back.InOut(t)); } // Elastic if (easingFunction == Type.EaseInElastic) { return(Elastic.In(t)); } if (easingFunction == Type.EaseOutElastic) { return(Elastic.Out(t)); } if (easingFunction == Type.EaseInOutElastic) { return(Elastic.InOut(t)); } return(0); }
public ServiceResult <object> Save(BusinessParam bp, UserDto dto) { var methodName = $".{new StackTrace().GetFrame(1).GetMethod().Name}"; try { Users users; if (dto.EntityId == 0) { var checkUserExist = CheckUserExist(bp, dto.Username); if (!checkUserExist.Done) { return(checkUserExist); } if (checkUserExist.Done && checkUserExist.ResultCountAll == 1) { return(new ServiceResult <object>(Enumerator.ErrorCode.ApplicationError, "کاربر گرامی با عرض پوزش این نام کاربری از قبل موجود می باشد")); } dto.Password = GetHashPassword(dto.Password); using (var unitOfWork = new UnitOfWork()) { users = Copier.GetEntity(dto, bp, true); unitOfWork.Users.Insert(users); unitOfWork.Users.Save(); } } else { var checkUserExist = CheckUserExist(bp, dto.Username); if (!checkUserExist.Done) { return(checkUserExist); } if (checkUserExist.Done && checkUserExist.ResultCountAll == 1) { var result = (Users)checkUserExist.Result; if (result.EntityId != dto.EntityId) { return(new ServiceResult <object>(Enumerator.ErrorCode.ApplicationError, "کاربر گرامی با عرض پوزش این نام کاربری از قبل موجود می باشد")); } if (result.Password != dto.Password) { dto.Password = GetHashPassword(dto.Password); } using (var unitOfWork = new UnitOfWork()) { users = Copier.GetEntity(dto, bp, false); unitOfWork.Users.Update(users); unitOfWork.Users.Save(); } } else { dto.Password = GetHashPassword(dto.Password); using (var unitOfWork = new UnitOfWork()) { users = Copier.GetEntity(dto, bp, false); unitOfWork.Users.Update(users); unitOfWork.Users.Save(); } } } Elastic <UserDto, Users> .SaveToElastic(users, ClassDetails[0].Clazz, bp); return(new ServiceResult <object>(Copier.GetDto(users), 1)); } catch (Exception e) { return(ExceptionUtil.ExceptionHandler(e, ClassDetails[0].Facade + methodName, bp.UserInfo)); } }
public static IEasing ElasticOutInWith(float amplitude = 0, float period = 0) { return(Elastic.easeOutInWith(amplitude, period)); }
public ServiceResult <object> CreateFolder(BusinessParam bp, FolderDto dto) { var methodName = $".{new StackTrace().GetFrame(1).GetMethod().Name}"; try { if (string.IsNullOrEmpty(dto.FolderName)) { return(ExceptionUtil.ExceptionHandler("لطفا نام پوشه را وارد نمایید", ClassDetails[0].Facade + methodName, bp.UserInfo)); } long?parentId = null; var webRootPath = bp.Environment.WebRootPath; var fileName = "\\file\\" + DateTime.UtcNow.RepositoryFolderName(); if (!string.IsNullOrEmpty(dto.Path)) { parentId = dto.ParentId; fileName = dto.Path + DateTime.UtcNow.RepositoryFolderName(); } var exists = Directory.Exists(webRootPath + fileName); if (exists) { return(ExceptionUtil.ExceptionHandler("نام پوشه تکراری می باشد", ClassDetails[0].Facade + methodName, bp.UserInfo)); } Directory.CreateDirectory(webRootPath + fileName); var fileDto = new FileDto { Alt = "", DataSize = "0", Description = "", DisplayInFileManager = true, Extension = null, FullTitle = fileName + " | " + dto.FolderName, Name = dto.FolderName, ParentId = parentId, Path = fileName + "\\", Thumbnail = fileName + "\\", Title = dto.FolderName }; var file = Copier.GetEntity(fileDto, bp, true); using (var unitOfWork = new UnitOfWork()) { var done = unitOfWork.File.Insert(file); unitOfWork.File.Save(); if (!done) { return(ExceptionUtil.ExceptionHandler("خطا در ذخیره فایل درون دیتابیس", ClassDetails[0].Facade + methodName, bp.UserInfo)); } Elastic <FileDto, DataLayer.Model.Core.File.File> .SaveToElastic(file, ClassDetails[0].Clazz, bp); fileDto.EntityId = file.EntityId; return(new ServiceResult <object>(fileDto, 1)); } } catch (Exception e) { return(ExceptionUtil.ExceptionHandler(e, ClassDetails[0].Facade + methodName, bp.UserInfo)); } }
public async Task <ServiceResult <object> > CreateFile(BusinessParam bp, HttpRequest request) { var methodName = $".{new StackTrace().GetFrame(1).GetMethod().Name}"; try { if (string.IsNullOrEmpty(request.Form["name"])) { return(ExceptionUtil.ExceptionHandler("لطفا نام فایل را وارد نمایید", ClassDetails[0].Facade + methodName, bp.UserInfo)); } if (request.Form.Files["file"] == null) { return(ExceptionUtil.ExceptionHandler("لطفا فایل را انتخاب نمایید", ClassDetails[0].Facade + methodName, bp.UserInfo)); } long?parentId = null; var webRootPath = bp.Environment.WebRootPath; var fileName = "\\file\\" + DateTime.UtcNow.RepositoryFolderName(); if (!string.IsNullOrEmpty(request.Form["path"])) { parentId = long.Parse(request.Form["parentId"]); fileName = request.Form["path"] + DateTime.UtcNow.RepositoryFolderName(); } var formFile = request.Form.Files["file"]; if (formFile.Length <= 0) { return(ExceptionUtil.ExceptionHandler("فایل ارسالی خالی می باشد", ClassDetails[0].Facade + methodName, bp.UserInfo)); } var extension = formFile.FileName.Split(".")[1]; var exists = System.IO.File.Exists(webRootPath + fileName + "." + extension); if (exists) { return(ExceptionUtil.ExceptionHandler("فایل تکراری می باشد", ClassDetails[0].Facade + methodName, bp.UserInfo)); } var checkFileIsValid = CheckFileIsValid(formFile, extension); if (!checkFileIsValid.Done) { return(checkFileIsValid); } using (var inputStream = new FileStream(webRootPath + fileName + "." + extension, FileMode.Create)) { await formFile.CopyToAsync(inputStream); var array = new byte[inputStream.Length]; inputStream.Seek(0, SeekOrigin.Begin); inputStream.Read(array, 0, array.Length); } var fileDto = new FileDto { Alt = request.Form["alt"], DataSize = formFile.Length.ToString(), Description = request.Form["description"], DisplayInFileManager = true, Extension = extension.ToLower(), FullTitle = request.Form["name"] + " | " + request.Form["description"] + " | " + request.Form["alt"], Name = request.Form["name"], ParentId = parentId, Path = fileName + "." + extension, Thumbnail = fileName + "_thumb." + extension, Title = formFile.FileName }; if (formFile.IsImage()) { var thumbnail = CreateThumbnail(formFile, fileDto, bp); } var file = Copier.GetEntity(fileDto, bp, true); using (var unitOfWork = new UnitOfWork()) { var done = unitOfWork.File.Insert(file); unitOfWork.File.Save(); if (!done) { return(ExceptionUtil.ExceptionHandler("خطا در ذخیره فایل درون دیتابیس", ClassDetails[0].Facade + methodName, bp.UserInfo)); } Elastic <FileDto, DataLayer.Model.Core.File.File> .SaveToElastic(file, ClassDetails[0].Clazz, bp); fileDto.EntityId = file.EntityId; return(new ServiceResult <object>(fileDto, 1)); } } catch (Exception e) { return(ExceptionUtil.ExceptionHandler(e, ClassDetails[0].Facade + methodName, bp.UserInfo)); } }
public ServiceResult <object> Save(BusinessParam bp, UseCaseDto dto) { var methodName = $".{new StackTrace().GetFrame(1).GetMethod().Name}"; try { if (dto.Parent == null) { dto.Parent = new UseCaseDto { EntityId = 1 } } ; var useCase = new DataLayer.Model.Core.UseCase.UseCase(); if (dto.EntityId == 0) { using (var unitOfWork = new UnitOfWork()) { useCase = Copier.GetEntity(dto, bp, true); unitOfWork.UseCase.Insert(useCase); unitOfWork.UseCase.Save(); } if (dto.UseCaseActions != null) { foreach (var item in dto.UseCaseActions) { item.UseCase = new UseCaseDto { EntityId = useCase.EntityId } } ; var serviceResult = UseCaseActionFacade.GetInstance().SaveList(bp, dto.UseCaseActions); if (!serviceResult.Done) { return(serviceResult); } } } else { var deletedList = UseCaseActionFacade.GetInstance().DeletedList(bp, dto.EntityId); if (deletedList.Done) { if (dto.UseCaseActions != null) { foreach (var item in dto.UseCaseActions) { item.UseCase = new UseCaseDto { EntityId = dto.EntityId } } ; var serviceResult = UseCaseActionFacade.GetInstance().SaveList(bp, dto.UseCaseActions); if (serviceResult.Done) { using (var unitOfWork = new UnitOfWork()) { useCase = Copier.GetEntity(dto, bp, false); unitOfWork.UseCase.Update(useCase); unitOfWork.UseCase.Save(); } } else { return(serviceResult); } } } else { return(deletedList); } } Elastic <UseCaseDto, DataLayer.Model.Core.UseCase.UseCase> .SaveToElastic(useCase, ClassDetails[0].Clazz, bp); return(new ServiceResult <object>(Copier.GetDto(useCase), 1)); } catch (Exception e) { return(ExceptionUtil.ExceptionHandler(e, ClassDetails[0].Facade + methodName, bp.UserInfo)); } }