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));
}
}
