public EntityResponse <int> GetLogsCountForEntityAction(EntityType type, LogType action, DateTime?start, DateTime?end) { var res = new EntityResponse <int>(); res.Success = true; try { switch (action) { case LogType.Purchase: res.Entity = _purchRep.GetMusicsPurchaseCount(start, end); break; case LogType.MusicView: res.Entity = _rep.LogCount(type, LogActionType.Watch, start, end); break; default: res.Success = false; res.Message = "This log type isn't supported!"; break; } } catch (Exception e) { res.Success = false; res.Message = e.ToString(); } return(res); }
public ActionResult Musics(MusicReportViewModel model) { EntityResponse <int> res = new EntityResponse <int>(); model.EndDate = model.EndDate.HasValue ? model.EndDate.Value.AddDays(1) : DateTime.Now.AddDays(1); model.StartDate = model.StartDate.HasValue ? model.StartDate : DateTime.Now.AddDays(-7); switch (model.Type) { case MusicReportType.All: res = musicService.GetMusicCount(null, null); break; case MusicReportType.Show: res = service.GetLogsCountForEntityAction(EntityType.Music, LogType.MusicView, model.StartDate, model.EndDate); break; case MusicReportType.Purchase: res = service.GetLogsCountForEntityAction(EntityType.Music, LogType.Purchase, model.StartDate, model.EndDate); break; } model.EndDate = model.EndDate.Value.AddDays(-1); if (!res.Success) { ModelState.AddModelError("", "נכשלה הבאת כמות היצירות!"); } else { model.Count = res.Entity; } return(View(model)); }
public async Task <EntityResponse <ContactDto> > CreateContactAsync(AddContactDto newContactDto) { var result = ModelValidator.ValidateAsEntityValidation(newContactDto, "E0001").As <ContactDto>(); if (!result.Ok) { return(result); } bool alreadyExists = _contactRepository.AsQueryable().Any(e => e.Email == newContactDto.Email); if (alreadyExists) { return(EntityResponse.CreateError("The email already exists.", "E0004").As <ContactDto>()); } Contact contact = newContactDto.CreateEntity(); await _contactRepository.AddAsync(contact); await unitOfWork.SaveChangesAsync(); ContactDto dto = new ContactDto { Email = contact.Email, Id = contact.Id, Name = contact.Name }; return(EntityResponse.CreateOk().As(dto)); }
public EntityResponse <Tag> GetNewInSystemTag() { EntityResponse <Tag> res = new EntityResponse <Tag>(); try { res.Entity = this._rep.GetNewInSystemTag(); if (res.Entity == null) { res.Success = false; res.Message = "התיוג חדש במערכת לא נמצא"; } else { res.Success = true; } } catch (Exception e) { res.Success = false; res.Message = e.Message; } return(res); }
public async Task Campaign_Create_CreateCampaignAndAddJobIdToEvents() { var appService = BuildAppService(); var newCampaignDto = new AddCampaignDto() { Name = "New 123", EmailTemplateId = 1, Events = new List <AddEventDto> { new AddEventDto { Date = DateTime.Now.AddDays(5) }, new AddEventDto { Date = DateTime.Now.AddDays(8) } }, ContactLists = new List <int> { 1 } }; EntityResponse <CampaignDto> result = await appService.CreateCampaignAsync(newCampaignDto); Assert.AreEqual(expected: true, result.Ok); foreach (var item in result.Data.Events) { Assert.AreEqual(expected: false, string.IsNullOrWhiteSpace(item.ScheduleJobId)); } }
public EntityResponse <string> GetPurchaseHTML(int musicID, PaskolUser buyer, int cost, string reference, string permission) { var res = new EntityResponse <string>(); try { Music music = _musicRep.GetByID(musicID); res.Entity = _pdfService.GetTempPurchaseHtml( DateTime.Now, buyer.UserName, buyer.Email, music.HebrewName, music.MusicWriter, music.MusicComposer, music.MusicPerformer, permission, cost, reference, music.Exceptions); res.Success = true; } catch (Exception e) { res.Success = false; res.Message = e.ToString(); } return(res); }
private ResponseFields GetResponseFields(EntityResponse value) { ResponseFields result = new ResponseFields(); value.section.ForEach(s => result.Entities.Add(GetEntity(s))); return(result); }
public async Task Campaign_Create_CreateCampaignAndAddContactList() { var appService = BuildAppService(); var newCampaignDto = new AddCampaignDto() { Name = "New 123", EmailTemplateId = 1, Events = new List <AddEventDto> { new AddEventDto { Date = DateTime.Now.AddDays(5) } }, ContactLists = new List <int> { 1 } }; EntityResponse <CampaignDto> result = await appService.CreateCampaignAsync(newCampaignDto); Assert.AreEqual(expected: true, result.Ok); Assert.AreEqual(expected: 1, result.Data.ContactLists.Count); Assert.AreEqual(expected: newCampaignDto.Name, result.Data.Name); Assert.AreEqual(expected: 1, result.Data.Events.Count); Assert.AreEqual(expected: newCampaignDto.Events.First().Date.Date, result.Data.Events.First().Date); Assert.AreEqual(expected: newCampaignDto.Events.First().Date, result.Data.Events.First().Hour); }
public string GetAuction(string id) { EntityResponse <AuctionRequirmentsViewModel> res = new EntityResponse <AuctionRequirmentsViewModel>(); res.Success = false; var AuctionResponse = _actionSrv.GetByID(id); // if artist is participate with this auction if (AuctionResponse?.Entity?.Participants?.Any(p => p.Id == User.Identity.GetUserId()) == true) { res.Success = true; res.Entity = new AuctionRequirmentsViewModel() { AuctionId = AuctionResponse.Entity.AuctionId, Budget = AuctionResponse.Entity.AuctionBudget, ContactMan = AuctionResponse.Entity.ContactName, Email = AuctionResponse.Entity.ContactEmail, MusicLength = AuctionResponse.Entity.MusicLength, Notes = AuctionResponse.Entity.Notes, Using = AuctionResponse.Entity.UsingName, Phone = AuctionResponse.Entity.ContactPhone, Open = AuctionResponse.Entity.OpenDate.Value.ToString("yyyy/MM/dd"), End = AuctionResponse.Entity.CloseDate.Value.ToString("yyyy/MM/dd"), MusicProperties = AuctionResponse.Entity.MusicProperties }; } return(JsonConvert.SerializeObject(res)); }
public async Task <EntityResponse <Product> > Handle(GetProductsByNameQuery request, CancellationToken cancellationToken) { var response = new EntityResponse <Product> () { ReponseName = nameof(GetProductsByNameQuery), Content = new List <Product> () { } }; var entities = await _productRepository.GetListAsync( p => (p.Name == request.productName) && (p.UnitPrice != 0)); _mapper.Map <List <Product> > (entities); if (entities == null) { response.Status = ResponseType.Warning; response.Message = $"No {nameof(Product)}s were found."; response.Content = null; } else { response.Status = ResponseType.Success; response.Message = $"{nameof(Product)}s get successfully."; response.Content.AddRange(entities); } return(response); }
/// <summary> /// Get ConfigSection by Id or All Root Sections /// </summary> public EntityResponse <IQueryable <ConfigDirectory> > GetConfigDirectoryById(long?id) { IQueryable <ConfigDirectory> configSectionQueryable; if (id.HasValue) { ConfigDirectory configSection = Uow.ConfigDirectories.GetById(id.Value); if (configSection == null) { return(ErrorCode.ConfigurationSectionNotFound); } configSectionQueryable = (new List <ConfigDirectory> { configSection }).AsQueryable(); } else { configSectionQueryable = Uow.ConfigDirectories.GetAllRoots(); } EntityResponse <IQueryable <ConfigDirectory> > result = EntityResponse <IQueryable <ConfigDirectory> > .Success(configSectionQueryable); return(result); }
public async Task <EntityResponse <MoneyApproval> > Handle(GetListMoneyApprovalQuery request, CancellationToken cancellationToken) { var response = new EntityResponse <MoneyApproval> () { ReponseName = nameof(GetListMoneyApprovalQuery), Content = new List <MoneyApproval> () { } }; var entities = await _approvalRepository.GetAllAsync(); _mapper.Map <List <MoneyApproval> > (entities); if (entities == null) { response.Status = ResponseType.Warning; response.Message = $"No {nameof(MoneyApproval)}s were found."; response.Content = null; } else { response.Status = ResponseType.Success; response.Message = $"{nameof(MoneyApproval)}s get successfully."; response.Content.AddRange(entities); } return(response); }
public override Task WriteToStreamAsync(Type type, object value, Stream writeStream, HttpContent content, TransportContext transportContext) { EntityResponse entityResponse = value as EntityResponse; if (entityResponse != null) { return(base.WriteToStreamAsync( entityResponse.Entity.GetType(), entityResponse.Entity, writeStream, content, transportContext)); } IEnumerable <EntityResponse> responses = value as IEnumerable <EntityResponse>; if (responses != null) { List <object> result = responses.Select(response => !response.IsSuccess ? response as object : response.Entity).ToList(); return(base.WriteToStreamAsync(result.GetType(), result, writeStream, content, transportContext)); } return(base.WriteToStreamAsync(type, value, writeStream, content, transportContext)); }
public EntityResponse CreateEntity(string workspaceId, CreateEntity body) { if (string.IsNullOrEmpty(workspaceId)) { throw new ArgumentNullException(nameof(workspaceId)); } if (body == null) { throw new ArgumentNullException(nameof(body)); } if (string.IsNullOrEmpty(VersionDate)) { throw new ArgumentNullException("versionDate cannot be null. Use 'CONVERSATION_VERSION_DATE_2017_05_26'"); } EntityResponse result = null; try { result = this.Client.WithAuthentication(this.UserName, this.Password) .PostAsync($"{this.Endpoint}/v1/workspaces/{workspaceId}/entities") .WithArgument("version", VersionDate) .WithBody <CreateEntity>(body) .As <EntityResponse>() .Result; } catch (AggregateException ae) { throw ae.Flatten(); } return(result); }
public async Task <EntityResponse <User> > Handle(GetUserQuery request, CancellationToken cancellationToken) { var response = new EntityResponse <User> () { ReponseName = nameof(GetUserQuery), Content = new List <User> () { } }; var user = await _userRepository.GetOneAsync(p => p.Id == request.Id); user = _mapper.Map <User> (user); if (user == null) { response.Status = ResponseType.Error; response.Message = $"{nameof(User)} not found."; response.Content = null; } else { response.Status = ResponseType.Success; response.Message = $"{nameof(User)} get successfully."; response.Content.Add(user); } return(response); }
public async Task <EntityResponse <ProductApproval> > Handle(CreateProductApprovalCommand request, CancellationToken cancellationToken) { var response = new EntityResponse <ProductApproval> () { ReponseName = nameof(CreateProductApprovalCommand), Content = new List <ProductApproval> () { } }; var entity = _mapper.Map <ProductApproval> (request); var newentity = await _approvalRepository.AddAsync(entity); if (newentity == null) { response.Status = ResponseType.Warning; response.Message = $"{nameof(ProductApproval)} could not be created."; response.Content = null; } else { response.Status = ResponseType.Success; response.Message = $"{nameof(ProductApproval)} created successfully."; response.Content.Add(newentity); } return(response); }
public EntityResponse<User> Login(LoginRequest credentials) { var response = new EntityResponse<User> {EntityType = typeof (User).ToString()}; // set up domain context var ctx = new PrincipalContext(ContextType.Domain); if (ctx.ValidateCredentials(credentials.UserName, credentials.Password)) { var user = UserPrincipal.FindByIdentity(ctx, credentials.UserName); if (user != null) { var u = new User { Email = user.EmailAddress, DisplayName = user.DisplayName, UserName = credentials.UserName }; response.ResponseCode = ResponseCode.Success; response.Message = ResponseMessage.Success; response.Data = u; } else { SetResponseError(ref response); } } else SetResponseError(ref response); return response; }
protected virtual void SetMissingRevFromResponseHeaders <T>(EntityResponse <T> response, HttpResponseHeaders responseHeaders) where T : class { if (string.IsNullOrWhiteSpace(response.Rev)) { response.Rev = responseHeaders.GetETag(); } }
public async Task <EntityResponse <Product> > Handle(GetProductsUserQuery request, CancellationToken cancellationToken) { var response = new EntityResponse <Product> () { ReponseName = nameof(GetProductsUserQuery), Content = new List <Product> () { } }; var entities = new List <Product> (); foreach (var item in request.productIds) { entities.Add(await _productRepository.GetAsync(p => (p.Id == item))); } _mapper.Map <List <Product> > (entities); if (entities == null) { response.Status = ResponseType.Warning; response.Message = $"No {nameof(Product)}s were found."; response.Content = null; } else { response.Status = ResponseType.Success; response.Message = $"{nameof(Product)}s get successfully."; response.Content.AddRange(entities); } return(response); }
public async Task <EntityResponse <Report> > Handle(GetReportsListQuery request, CancellationToken cancellationToken) { var response = new EntityResponse <Report> () { ReponseName = nameof(GetReportsListQuery), Content = new List <Report> () { } }; var ReportList = await _reportRepository.GetAllAsync(); _mapper.Map <List <Report> > (ReportList); if (ReportList == null) { response.Status = ResponseType.Error; response.Message = $"No {nameof(Report)}s were found ."; response.Content = null; } else { response.Status = ResponseType.Success; response.Message = $"{nameof(Report)}s get successfully."; response.Content.AddRange(ReportList); } return(response); }
protected virtual void SetMissingIdFromRequestUri <T>(EntityResponse <T> response, HttpRequestMessage request) where T : class { if (string.IsNullOrWhiteSpace(response.Id) && request.Method != HttpMethod.Post) { response.Id = request.ExtractIdFromUri(false); } }
public async Task <ActionResult <TEditEntityDto> > Post([FromBody] TCreateEntityDto entityDto, [FromServices] RemboardContext context, [FromServices] IAuthorizationService authorizationService, [FromServices] CrudResourcePointControllerFactory <TEntity, TCreateEntityDto, TEditEntityDto, TFilterableEntity, TKey> controllerFactory) { var result = await authorizationService.AuthorizeAsync(User, typeof(TEntity), CrudOperations.Create); if (!result.Succeeded) { return(Forbid()); } var validator = controllerFactory.GetCreateDtoValidator(); var validationResult = await ValidateAsync(validator, entityDto); if (validationResult == null) { var operation = controllerFactory.GetCrudOperation(); var correctors = controllerFactory.GetCorrectors(); var saved = await operation.Post(entityDto, context, correctors); var producers = controllerFactory.GetAfterEntityCreateCommandProducersOrNull(); await producers.SendToAll(entityDto, saved.entity.Id); return(Ok(saved.entityDto)); } var errorResponse = new EntityResponse { Message = "Failed to save entity", }; errorResponse.ValidationErrors.AddRange(validationResult); return(BadRequest(errorResponse)); }
public virtual async void Materialize <T>(EntityResponse <T> response, HttpResponseMessage httpResponse) where T : class { using (var content = await httpResponse.Content.ReadAsStreamAsync().ForAwait()) { var get = response as GetEntityResponse <T>; if (get != null) { response.Content = Serializer.DeserializeCopied <T>(content); response.Id = EntityReflector.IdMember.GetValueFrom(response.Content); response.Rev = EntityReflector.RevMember.GetValueFrom(response.Content); var tmp = Serializer.Deserialize <Temp>(content); get.Conflicts = tmp._conflicts; get.Id = get.Id ?? tmp.Id; get.Rev = get.Rev ?? tmp.Rev; } else { Serializer.Populate(response, content); } SetMissingIdFromRequestUri(response, httpResponse.RequestMessage); SetMissingRevFromRequestHeaders(response, httpResponse.Headers); } }
public IActionResult ClearItems(Guid orderId) { var response = new EntityResponse <Order>(null, ""); if (orderId == Guid.Empty) { response.Message = "ClearItems: orderId is invalid"; return(BadRequest(response)); } var order = _orderRepository.Get(orderId); if (order == null) { response.Message = "ClearItems: order not found"; return(BadRequest(response)); } order.Items.Clear(); if (_orderRepository.Update(order)) { response.Entity = order; response.Message = "OK"; return(Ok(response)); } response.Message = "ClearItems: items could not be deleted"; return(StatusCode((int)HttpStatusCode.InternalServerError, response)); }
public IActionResult AddItemToOrder(Guid orderId, [FromBody] Item item) { var response = new EntityResponse <Order>(null, ""); var order = _orderRepository.Get(orderId); if (order == null) { response.Message = "AddItemToOrder: order not found"; return(BadRequest(response)); } order.Items.Add(item); if (_orderRepository.Update(order)) { response.Entity = order; response.Message = "OK"; return(Ok(response)); } response.Message = "AddItemToOrder: item could not be added to order"; return(StatusCode((int)HttpStatusCode.InternalServerError, response)); }
public EntityResponse <AuthenticationModel> SignIn(SignInModel signInModel) { if (!ModelState.IsValid) { List <string> errorMessages = GetValidationErrorMessages(); EntityResponse <AuthenticationModel> error = EntityResponse <AuthenticationModel> .Error(ErrorCode.AccountVerificationInvalidModel, string.Join(".", errorMessages)); return(error); } Role role = _authenticationService.Authenticate(signInModel.Login, signInModel.Password, signInModel.LoginAccountType, signInModel.RememberMe); if (role == null) { EntityResponse <AuthenticationModel> error = EntityResponse <AuthenticationModel> .Error( ErrorCode.AccountVerificationInvalidLoginOrPassword, ClientErrorMessages.AccountController_AccountVerificationInvalidLoginOrPassword); return(error); } AuthenticationModel authenticationModel = GetSecurityModel(); return(authenticationModel); }
public async Task <EntityResponse <ProductApproval> > Handle(UpdateProductApprovalCommand request, CancellationToken cancellationToken) { var response = new EntityResponse <ProductApproval> () { ReponseName = nameof(UpdateProductApprovalCommand), Content = new List <ProductApproval> () { } }; var entity = await _approvalRepository.GetOneAsync(p => p.Id == request.Id); if (entity == null) { response.Status = ResponseType.Warning; response.Message = $"{nameof(ProductApproval)} not found."; response.Content = null; } else { _mapper.Map(request, entity, typeof(UpdateProductApprovalCommand), typeof(ProductApproval)); await _approvalRepository.UpdateAsync(entity); response.Status = ResponseType.Success; response.Message = $"{nameof(ProductApproval)} updated successfully."; response.Content.Add(entity); } return(response); }
/// <summary> /// Authenticates user in the system. /// </summary> /// <param name="loginName">login name</param> /// <param name="password">password</param> /// <param name="rememberMe">remember user or not</param> /// <returns><c>true</c> entity if authenticated, otherwise - <c>false</c></returns> public Role Authenticate(string loginName, string password, string loginAccountType, bool rememberMe = false) { User user = Uow.Users.GetByLoginName(loginName); if (user == null) { EntityResponse <UserLoginInformation> loginInfo = _accountManager.UserLogin( loginAccountType == "U" ? LoginAccountType.CustomerCode : LoginAccountType.CustomerAccountCode, loginName, password, PasswordUseScope.OptionTrade); if (loginInfo.IsSuccess) { EntityResponse <FCUser> fcUserResponse = _userService.AddOrUpdateFCUser(loginInfo.Entity, password); user = fcUserResponse.Entity; } } if (user != null) { return(Authenticate(user, password, rememberMe)); } Logger.Warn(string.Format("Invalid user name {0}", loginName)); return(null); }
public EntityResponse <List <HistoricalOptionTradeInformation> > GetHistoricalOptionTrades(HistoricalOptionOrdersArguments historicalOrderArguments) { List <SZKingdomArgument> arguments = new List <SZKingdomArgument>(); if (historicalOrderArguments.CustomerCode == null && historicalOrderArguments.CustomerAccountCode == null) { EntityResponse <List <HistoricalOptionTradeInformation> > entityResponse = EntityResponse <List <HistoricalOptionTradeInformation> > .Error(ErrorCode.SZKingdomLibraryError, SameCodesErrorMessage); return(entityResponse); } arguments.Add(SZKingdomArgument.CustomerCode(historicalOrderArguments.CustomerCode)); arguments.Add(SZKingdomArgument.CustomerAccountCode(historicalOrderArguments.CustomerAccountCode)); arguments.Add(SZKingdomArgument.StockBoard(historicalOrderArguments.StockBoard)); arguments.Add(SZKingdomArgument.TradeAccount(historicalOrderArguments.TradeAccount)); arguments.Add(SZKingdomArgument.OptionNumber(historicalOrderArguments.OptionNumber)); arguments.Add(SZKingdomArgument.OptionUnderlyingCode(historicalOrderArguments.OptionUnderlyingCode)); arguments.Add(SZKingdomArgument.OrderId(historicalOrderArguments.OrderId)); arguments.Add(SZKingdomArgument.OrderBatchSerialNo(historicalOrderArguments.OrderBatchSerialNo)); arguments.Add(SZKingdomArgument.BeginDate(historicalOrderArguments.BeginDate.ToString(SZKingdomMappingHelper.SZKingdomDateFormat))); arguments.Add(SZKingdomArgument.EndDate(historicalOrderArguments.EndDate.ToString(SZKingdomMappingHelper.SZKingdomDateFormat))); arguments.Add(SZKingdomArgument.PageNumber(historicalOrderArguments.PageNumber)); arguments.Add(SZKingdomArgument.PageRecordCount(historicalOrderArguments.PageRecordCount)); EntityResponse <List <HistoricalOptionTradeInformation> > result = _marketDataLibrary .ExecuteCommandList <HistoricalOptionTradeInformation>(SZKingdomRequest.HistoricalOptionTrades, arguments); return(result); }
public EntityResponse <List <IntradayOptionOrderBasicInformation> > GetCancellableOrders(IntradayOptionOrderArguments intradayOrderArguments) { List <SZKingdomArgument> arguments = new List <SZKingdomArgument>(); if (intradayOrderArguments.CustomerCode == null && intradayOrderArguments.CustomerAccountCode == null) { EntityResponse <List <IntradayOptionOrderBasicInformation> > entityRespose = EntityResponse <List <IntradayOptionOrderBasicInformation> > .Error(ErrorCode.SZKingdomLibraryError, SameCodesErrorMessage); return(entityRespose); } arguments.Add(SZKingdomArgument.CustomerCode(intradayOrderArguments.CustomerCode)); arguments.Add(SZKingdomArgument.CustomerAccountCode(intradayOrderArguments.CustomerAccountCode)); arguments.Add(SZKingdomArgument.StockBoard(intradayOrderArguments.StockBoard)); arguments.Add(SZKingdomArgument.TradeAccount(intradayOrderArguments.TradeAccount)); arguments.Add(SZKingdomArgument.OptionNumber(intradayOrderArguments.OptionNumber)); arguments.Add(SZKingdomArgument.OptionUnderlyingCode(intradayOrderArguments.OptionUnderlyingCode)); arguments.Add(SZKingdomArgument.OrderId(intradayOrderArguments.OrderId)); arguments.Add(SZKingdomArgument.QueryPosition(intradayOrderArguments.QueryPosition)); EntityResponse <List <IntradayOptionOrderBasicInformation> > result = _marketDataLibrary .ExecuteCommandList <IntradayOptionOrderBasicInformation>(SZKingdomRequest.CancelableOptionOrders, arguments); return(result); }
public async Task <EntityResponse <ProductApproval> > Handle(GetProductApprovalQuery request, CancellationToken cancellationToken) { var response = new EntityResponse <ProductApproval> () { ReponseName = nameof(GetProductApprovalQuery), Content = new List <ProductApproval> () { } }; var entity = await _approvalRepository.GetOneAsync(p => p.Id == request.Id); entity = _mapper.Map <ProductApproval> (entity);; if (entity == null) { response.Status = ResponseType.Warning; response.Message = $"{nameof(ProductApproval)} not found."; response.Content = null; } else { response.Status = ResponseType.Success; response.Message = $"{nameof(ProductApproval)} get successfully."; response.Content.Add(entity); } return(response); }
private void SetResponseError(ref EntityResponse<User> response) { response.Message = "Invalid UserName and/or Password!"; response.ResponseCode = ResponseCode.Fail; }