Пример #1
0
        public IHttpActionResult Update(UpdateRequest request)
        {
            log.Info("Update");
            log.Info(JsonConvert.SerializeObject(request));
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }
            UpdateResponse results = new UpdateResponse();

            results.Request = request;
            results.Result  = null;
            results.Id      = request.Id;
            results.Errors  = new List <Dictionary <string, string> >();


            Entity currentEntity = connect.Retrieve(request.Entity, request.Id, new ColumnSet(true));

            if (currentEntity != null)
            {
                foreach (KeyValuePair <string, object> field in request.Data)
                {
                    log.Info(field.Key);
                    currentEntity.Attributes[field.Key] = DynHelper.ParsedValue(field.Value, log);
                }

                try
                {
                    connect.Update(currentEntity);
                    results.Result = currentEntity;
                }
                catch (Exception ex)
                {
                    results.Errors.Add(new Dictionary <string, string> {
                        { "Message", ex.Message }, { "StackTrace", ex.StackTrace }
                    });
                    log.Error(ex.Message);
                    log.Error(ex.StackTrace);
                    if (ex.InnerException != null)
                    {
                        log.Error(ex.InnerException.Message);
                    }
                }
            }
            else
            {
                results.Errors.Add(new Dictionary <string, string> {
                    { "Message", "Entity not found" }
                });
                log.Error("Entity Not Found");
            }
            return(Ok <UpdateResponse>(results));
        }
Пример #2
0
        public IHttpActionResult Create(CreateRequest request)
        {
            log.Info("Create");
            log.Info(JsonConvert.SerializeObject(request));
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }
            CreateResponse results = new CreateResponse();

            results.Request = request;
            results.Result  = null;
            results.Id      = Guid.Empty;
            results.Errors  = new List <Dictionary <string, string> >();

            Entity newEntity = new Entity(request.Entity);

            foreach (KeyValuePair <string, object> field in request.Data)
            {
                log.Info(field.Key);
                newEntity.Attributes[field.Key] = DynHelper.ParsedValue(field.Value, log);
            }

            try
            {
                Guid id = connect.Create(newEntity);
                results.Result = newEntity;
                results.Id     = id;
                log.Info(JsonConvert.SerializeObject(newEntity));
            }
            catch (Exception ex)
            {
                results.Errors.Add(new Dictionary <string, string> {
                    { "Message", ex.Message }, { "StackTrace", ex.StackTrace }
                });
                log.Error(ex.Message);
                log.Error(ex.StackTrace);
                if (ex.InnerException != null)
                {
                    log.Error(ex.InnerException.Message);
                }
            }
            return(Ok <CreateResponse>(results));
        }
Пример #3
0
        public IHttpActionResult Retrieve(RetrieveRequest request)
        {
            log.Info("Retrieve");
            log.Info(JsonConvert.SerializeObject(request));
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }
            RetrieveResponse results = new RetrieveResponse();

            results.request = request;
            results.Results = new EntityCollection();
            results.Errors  = new List <Dictionary <string, string> >();

            QueryExpression query = new QueryExpression();

            query.EntityName = request.Entity;
            if (request.Fields == null || request.Fields.Count == 0)
            {
                query.ColumnSet = new ColumnSet(true);
            }
            else
            {
                query.ColumnSet = new ColumnSet(request.Fields.ToArray());
            }

            if (request.Conditions != null)
            {
                foreach (RetrieveCondition condition in request.Conditions)
                {
                    ConditionExpression exp = new ConditionExpression();
                    exp.AttributeName = condition.Field;
                    switch (condition.Operator.ToLower())
                    {
                    case "equal":
                        exp.Operator = ConditionOperator.Equal;
                        break;

                    case "notequal":
                        exp.Operator = ConditionOperator.NotEqual;
                        break;

                    case "greaterthan":
                        exp.Operator = ConditionOperator.GreaterThan;
                        break;

                    case "lessthan":
                        exp.Operator = ConditionOperator.LessThan;
                        break;

                    case "greaterequal":
                        exp.Operator = ConditionOperator.GreaterEqual;
                        break;

                    case "lessequal":
                        exp.Operator = ConditionOperator.LessEqual;
                        break;

                    case "like":
                        exp.Operator = ConditionOperator.Like;
                        break;

                    case "notlike":
                        exp.Operator = ConditionOperator.NotLike;
                        break;

                    case "in":
                        exp.Operator = ConditionOperator.In;
                        break;

                    case "notin":
                        exp.Operator = ConditionOperator.NotIn;
                        break;

                    case "between":
                        exp.Operator = ConditionOperator.Between;
                        break;

                    case "notbetween":
                        exp.Operator = ConditionOperator.NotBetween;
                        break;

                    case "null":
                        exp.Operator = ConditionOperator.Null;
                        break;

                    case "notnull":
                        exp.Operator = ConditionOperator.NotNull;
                        break;

                    case "yesterday":
                        exp.Operator = ConditionOperator.Yesterday;
                        break;

                    case "today":
                        exp.Operator = ConditionOperator.Today;
                        break;

                    case "tomorrow":
                        exp.Operator = ConditionOperator.Tomorrow;
                        break;

                    case "last7days":
                        exp.Operator = ConditionOperator.Last7Days;
                        break;

                    case "next7days":
                        exp.Operator = ConditionOperator.Next7Days;
                        break;

                    case "lastweek":
                        exp.Operator = ConditionOperator.LastWeek;
                        break;

                    case "thisweek":
                        exp.Operator = ConditionOperator.ThisWeek;
                        break;

                    case "nextweek":
                        exp.Operator = ConditionOperator.NextWeek;
                        break;

                    case "lastmonth":
                        exp.Operator = ConditionOperator.LastMonth;
                        break;

                    case "thismonth":
                        exp.Operator = ConditionOperator.ThisMonth;
                        break;

                    case "nextmonth":
                        exp.Operator = ConditionOperator.NextMonth;
                        break;

                    case "on":
                        exp.Operator = ConditionOperator.On;
                        break;

                    case "onorbefore":
                        exp.Operator = ConditionOperator.OnOrBefore;
                        break;

                    case "onorafter":
                        exp.Operator = ConditionOperator.OnOrAfter;
                        break;

                    case "lastyear":
                        exp.Operator = ConditionOperator.LastYear;
                        break;

                    case "thisyear":
                        exp.Operator = ConditionOperator.ThisYear;
                        break;

                    case "nextyear":
                        exp.Operator = ConditionOperator.NextYear;
                        break;

                    case "lastxhours":
                        exp.Operator = ConditionOperator.LastXHours;
                        break;

                    case "nextxhours":
                        exp.Operator = ConditionOperator.NextXHours;
                        break;

                    case "lastxdays":
                        exp.Operator = ConditionOperator.LastXDays;
                        break;

                    case "nextxdays":
                        exp.Operator = ConditionOperator.NextXDays;
                        break;

                    case "lastxweeks":
                        exp.Operator = ConditionOperator.LastXWeeks;
                        break;

                    case "nextxweeks":
                        exp.Operator = ConditionOperator.NextXWeeks;
                        break;

                    case "lastxmonths":
                        exp.Operator = ConditionOperator.LastXMonths;
                        break;

                    case "nextxmonths":
                        exp.Operator = ConditionOperator.NextXMonths;
                        break;

                    case "lastxyears":
                        exp.Operator = ConditionOperator.LastXYears;
                        break;

                    case "nextxyears":
                        exp.Operator = ConditionOperator.NextXYears;
                        break;

                    case "equaluserid":
                        exp.Operator = ConditionOperator.EqualUserId;
                        break;

                    case "notequaluserid":
                        exp.Operator = ConditionOperator.NotEqualUserId;
                        break;

                    case "equalbusinessid":
                        exp.Operator = ConditionOperator.EqualBusinessId;
                        break;

                    case "notequalbusinessid":
                        exp.Operator = ConditionOperator.NotEqualBusinessId;
                        break;

                    case "childof":
                        exp.Operator = ConditionOperator.ChildOf;
                        break;

                    case "mask":
                        exp.Operator = ConditionOperator.Mask;
                        break;

                    case "notmask":
                        exp.Operator = ConditionOperator.NotMask;
                        break;

                    case "masksselect":
                        exp.Operator = ConditionOperator.MasksSelect;
                        break;

                    case "contains":
                        exp.Operator = ConditionOperator.Contains;
                        break;

                    case "doesnotcontain":
                        exp.Operator = ConditionOperator.DoesNotContain;
                        break;

                    case "equaluserlanguage":
                        exp.Operator = ConditionOperator.EqualUserLanguage;
                        break;

                    case "noton":
                        exp.Operator = ConditionOperator.NotOn;
                        break;

                    case "olderthanxmonths":
                        exp.Operator = ConditionOperator.OlderThanXMonths;
                        break;

                    case "beginswith":
                        exp.Operator = ConditionOperator.BeginsWith;
                        break;

                    case "doesnotbeginwith":
                        exp.Operator = ConditionOperator.DoesNotBeginWith;
                        break;

                    case "endswith":
                        exp.Operator = ConditionOperator.EndsWith;
                        break;

                    case "doesnotendwith":
                        exp.Operator = ConditionOperator.DoesNotEndWith;
                        break;

                    case "thisfiscalyear":
                        exp.Operator = ConditionOperator.ThisFiscalYear;
                        break;

                    case "thisfiscalperiod":
                        exp.Operator = ConditionOperator.ThisFiscalPeriod;
                        break;

                    case "nextfiscalyear":
                        exp.Operator = ConditionOperator.NextFiscalYear;
                        break;

                    case "nextfiscalperiod":
                        exp.Operator = ConditionOperator.NextFiscalPeriod;
                        break;

                    case "lastfiscalyear":
                        exp.Operator = ConditionOperator.LastFiscalYear;
                        break;

                    case "lastfiscalperiod":
                        exp.Operator = ConditionOperator.LastFiscalPeriod;
                        break;

                    case "lastxfiscalyears":
                        exp.Operator = ConditionOperator.LastXFiscalYears;
                        break;

                    case "lastxfiscalperiods":
                        exp.Operator = ConditionOperator.LastXFiscalPeriods;
                        break;

                    case "nextxfiscalyears":
                        exp.Operator = ConditionOperator.NextXFiscalYears;
                        break;

                    case "nextxfiscalperiods":
                        exp.Operator = ConditionOperator.NextXFiscalPeriods;
                        break;

                    case "infiscalyear":
                        exp.Operator = ConditionOperator.InFiscalYear;
                        break;

                    case "infiscalperiod":
                        exp.Operator = ConditionOperator.InFiscalPeriod;
                        break;

                    case "infiscalperiodandyear":
                        exp.Operator = ConditionOperator.InFiscalPeriodAndYear;
                        break;

                    case "inorbeforefiscalperiodandyear":
                        exp.Operator = ConditionOperator.InOrBeforeFiscalPeriodAndYear;
                        break;

                    case "inorafterfiscalperiodandyear":
                        exp.Operator = ConditionOperator.InOrAfterFiscalPeriodAndYear;
                        break;

                    case "equaluserteams":
                        exp.Operator = ConditionOperator.EqualUserTeams;
                        break;

                    default:
                        exp.Operator = ConditionOperator.Equal;
                        break;
                    }
                    log.Info(condition.Field);
                    foreach (object value in condition.Values)
                    {
                        log.Info(value);
                        exp.Values.Add(DynHelper.ParsedValue(value, log));
                    }

                    query.Criteria.AddCondition(exp);
                }
            }
            query.Criteria.FilterOperator = LogicalOperator.And;
            if (request.WhereOperator != null && request.WhereOperator.ToLower() == "or")
            {
                query.Criteria.FilterOperator = LogicalOperator.Or;
            }

            if (request.Order != null)
            {
                foreach (string order in request.Order)
                {
                    if (request.OrderDirection == null || request.OrderDirection.ToLower() == "asc")
                    {
                        query.AddOrder(order, OrderType.Ascending);
                    }
                    else
                    {
                        query.AddOrder(order, OrderType.Descending);
                    }
                }
            }

            try
            {
                EntityCollection entities = connect.RetrieveMultiple(query);
                results.Results = entities;
            }
            catch (Exception ex)
            {
                results.Errors.Add(new Dictionary <string, string> {
                    { "Message", ex.Message }, { "StackTrace", ex.StackTrace }
                });
                log.Error(ex.Message);
                log.Error(ex.StackTrace);
                if (ex.InnerException != null)
                {
                    log.Error(ex.InnerException.Message);
                }
            }
            return(Ok <RetrieveResponse>(results));
        }